diff --git a/.clang-format b/.clang-format
new file mode 100644
index 00000000..5b9e3fd5
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,84 @@
+#AccessModifierOffset: 2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+#AlignConsecutiveBitFields: false
+AlignConsecutiveDeclarations: false
+AlignConsecutiveMacros: false
+AlignEscapedNewlines: Right
+#AlignOperands: AlignAfterOperator
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Empty
+AllowShortCaseLabelsOnASingleLine: false
+#AllowShortEnumsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLambdasOnASingleLine: Empty
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: false
+BinPackParameters: false
+#BitFieldColonSpacing: Both
+BreakBeforeBraces: Custom # or Allman
+BraceWrapping:
+ AfterCaseLabel: true
+ AfterClass: true
+ AfterControlStatement: Always
+ AfterEnum: true
+ AfterFunction: true
+ AfterNamespace: false
+ AfterStruct: true
+ AfterUnion: true
+ AfterExternBlock: false
+ BeforeCatch: true
+ BeforeElse: true
+ #BeforeLambdaBody: false
+ #BeforeWhile: false
+ SplitEmptyFunction: false
+ SplitEmptyRecord: false
+ SplitEmptyNamespace: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeComma
+BreakStringLiterals: false
+ColumnLimit: 0
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 2
+Cpp11BracedListStyle: true
+PointerAlignment: Left
+FixNamespaceComments: true
+IncludeBlocks: Preserve
+#IndentCaseBlocks: false
+IndentCaseLabels: true
+IndentGotoLabels: false
+IndentPPDirectives: BeforeHash
+IndentWidth: 4
+KeepEmptyLinesAtTheStartOfBlocks: false
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ReflowComments: false
+SortIncludes: true
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: c++11
+TabWidth: 4
+UseTab: Never
diff --git a/.clang-tidy b/.clang-tidy
index feee8194..046d84f8 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,23 +1,20 @@
-Checks: '-*,
- bugprone-*,
- cert-*,
- clang-analyzer-*,
- google-*,
- -google-runtime-references,
+Checks: '*,
+ -cppcoreguidelines-avoid-goto,
+ -cppcoreguidelines-avoid-magic-numbers,
+ -cppcoreguidelines-macro-usage,
+ -fuchsia-default-arguments-calls,
+ -fuchsia-default-arguments-declarations,
+ -fuchsia-overloaded-operator,
-google-explicit-constructor,
- hicpp-*,
+ -google-runtime-references,
+ -hicpp-avoid-goto,
+ -hicpp-explicit-conversions,
-hicpp-no-array-decay,
-hicpp-uppercase-literal-suffix,
- -hicpp-explicit-conversions,
- misc-*,
- -misc-non-private-member-variables-in-classes,
- llvm-*,
-llvm-header-guard,
- modernize-*,
+ -llvm-include-order,
+ -misc-non-private-member-variables-in-classes,
-modernize-use-trailing-return-type,
- performance-*,
- portability-*,
- readability-*,
-readability-magic-numbers,
-readability-uppercase-literal-suffix'
diff --git a/.github/ISSUE_TEMPLATE/Bug_report.md b/.github/ISSUE_TEMPLATE/Bug_report.md
index 3485a689..a2df8dca 100644
--- a/.github/ISSUE_TEMPLATE/Bug_report.md
+++ b/.github/ISSUE_TEMPLATE/Bug_report.md
@@ -47,7 +47,7 @@ assignees: ''
<!-- Please add an `x` to the respective line. -->
-- [ ] latest release version 3.7.3
+- [ ] latest release version 3.9.0
- [ ] other release - please state the version: ___
- [ ] the `develop` branch
diff --git a/.github/ISSUE_TEMPLATE/Feature_request.md b/.github/ISSUE_TEMPLATE/Feature_request.md
deleted file mode 100644
index f7effbaf..00000000
--- a/.github/ISSUE_TEMPLATE/Feature_request.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: 'kind: enhancement/improvement'
-assignees: ''
-
----
-
-#### Which feature do you want to see in the library?
-
-<!-- Describe the feature in as much detail as possible. -->
-
-#### How would the feature be usable for other users?
-
-<!-- Include sample usage where appropriate. -->
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 00000000..0e966338
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+ - name: Ask a question
+ url: https://github.com/nlohmann/json/discussions
+ about: Ask questions and discuss with other community members
diff --git a/.github/ISSUE_TEMPLATE/question.md b/.github/ISSUE_TEMPLATE/question.md
deleted file mode 100644
index 3f522cde..00000000
--- a/.github/ISSUE_TEMPLATE/question.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-name: Question
-about: Ask a question regarding the library.
-title: ''
-labels: 'kind: question'
-assignees: ''
-
----
-
-<!-- Provide a concise summary of the issue in the title above. -->
-
-#### What do you want to achieve?
-
-<!-- Please describe the feature as detailed as possible. -->
-
-#### What have you tried?
-
-<!-- There are thousands of issues to search: https://github.com/nlohmann/json/issues?q=is%3Aissue+ -->
-<!-- There is a full documentation of the API: https://nlohmann.github.io/json/ -->
-<!-- There is a detailed README file: https://github.com/nlohmann/json/blob/develop/README.md -->
-
-#### Can you provide a small code example?
-
-<!-- Please understand that we cannot analyze and debug large code bases. -->
-
-#### Which compiler and operating system are you using?
-
-<!-- Include as many relevant details about the environment you experienced the bug in. -->
-<!-- Make sure you use a supported compiler, see https://github.com/nlohmann/json#supported-compilers. -->
-
-- Compiler: ___
-- Operating system: ___
-
-#### Which version of the library did you use?
-
-<!-- Please add an `x` to the respective line. -->
-
-- [ ] latest release version 3.7.3
-- [ ] other release - please state the version: ___
-- [ ] the `develop` branch
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
new file mode 100644
index 00000000..5ee44a04
--- /dev/null
+++ b/.github/workflows/codeql-analysis.yml
@@ -0,0 +1,54 @@
+name: "Code scanning - action"
+
+on:
+ push:
+ branches: [develop, ]
+ pull_request:
+ # The branches below must be a subset of the branches above
+ branches: [develop]
+ schedule:
+ - cron: '0 19 * * 1'
+
+jobs:
+ CodeQL-Build:
+
+ runs-on: ubuntu-latest
+
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v2
+ with:
+ # We must fetch at least the immediate parents so that if this is
+ # a pull request then we can checkout the head.
+ fetch-depth: 2
+
+ # If this run was triggered by a pull request event, then checkout
+ # the head of the pull request instead of the merge commit.
+ - run: git checkout HEAD^2
+ if: ${{ github.event_name == 'pull_request' }}
+
+ # Initializes the CodeQL tools for scanning.
+ - name: Initialize CodeQL
+ uses: github/codeql-action/init@v1
+ # Override language selection by uncommenting this and choosing your languages
+ # with:
+ # languages: go, javascript, csharp, python, cpp, java
+
+ # Autobuild attempts to build any compiled languages (C/C++, C#, or Java).
+ # If this step fails, then you should remove it and run the build manually (see below)
+ - name: Autobuild
+ uses: github/codeql-action/autobuild@v1
+
+ # ℹ️ Command-line programs to run using the OS shell.
+ # 📚 https://git.io/JvXDl
+
+ # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+ # and modify them (or add more) to build your code if your project
+ # uses a compiled language
+
+ #- run: |
+ # make bootstrap
+ # make release
+
+ - name: Perform CodeQL Analysis
+ uses: github/codeql-action/analyze@v1
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index 476b21df..5846cf75 100644
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -3,8 +3,7 @@ name: Windows
on: [push, pull_request]
jobs:
- build:
-
+ msvc2019:
runs-on: windows-latest
steps:
@@ -15,3 +14,55 @@ jobs:
run: cmake --build build --parallel 10
- name: test
run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
+
+ clang9:
+ runs-on: windows-latest
+
+ steps:
+ - uses: actions/checkout@v1
+ - name: install Clang
+ run: curl -fsSL -o LLVM9.exe https://releases.llvm.org/9.0.0/LLVM-9.0.0-win64.exe ; 7z x LLVM9.exe -y -o"C:/Program Files/LLVM"
+ - name: cmake
+ run: cmake -S . -B build -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" -G"MinGW Makefiles" -DCMAKE_BUILD_TYPE=Debug -DJSON_BuildTests=On
+ - name: build
+ run: cmake --build build --parallel 10
+ - name: test
+ run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
+
+ clang10:
+ runs-on: windows-latest
+
+ steps:
+ - uses: actions/checkout@v1
+ - name: install Clang
+ run: curl -fsSL -o LLVM10.exe https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.0/LLVM-10.0.0-win64.exe ; 7z x LLVM10.exe -y -o"C:/Program Files/LLVM"
+ - name: cmake
+ run: cmake -S . -B build -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" -G"MinGW Makefiles" -DCMAKE_BUILD_TYPE=Debug -DJSON_BuildTests=On
+ - name: build
+ run: cmake --build build --parallel 10
+ - name: test
+ run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
+
+ clang-cl-10-x64:
+ runs-on: windows-latest
+
+ steps:
+ - uses: actions/checkout@v1
+ - name: cmake
+ run: cmake -S . -B build -G "Visual Studio 16 2019" -A x64 -T ClangCL -DJSON_BuildTests=On
+ - name: build
+ run: cmake --build build --config Debug --parallel 10
+ - name: test
+ run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
+
+ clang-cl-10-x86:
+ runs-on: windows-latest
+
+ steps:
+ - uses: actions/checkout@v1
+ - name: cmake
+ run: cmake -S . -B build -G "Visual Studio 16 2019" -A Win32 -T ClangCL -DJSON_BuildTests=On
+ - name: build
+ run: cmake --build build --config Debug --parallel 10
+ - name: test
+ run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
diff --git a/.gitignore b/.gitignore
index bec7f598..7e5a881e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,7 +22,7 @@ benchmarks/files/numbers/*.json
.wsjcpp/*
.idea
-cmake-build-debug
+/cmake-build-*
test/test-*
/.vs
@@ -32,3 +32,4 @@ doc/mkdocs/docs/images
doc/mkdocs/docs/examples
doc/mkdocs/site
doc/mkdocs/docs/__pycache__/
+doc/xml
diff --git a/.travis.yml b/.travis.yml
index 0fef3f44..bf749c1e 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -10,17 +10,6 @@ sudo: required
group: edge
-###################
-# global settings #
-###################
-
-env:
- global:
- # The next declaration is the encrypted COVERITY_SCAN_TOKEN, created
- # via the "travis encrypt" command using the project repo's public key
- - secure: "m89SSgE+ASLO38rSKx7MTXK3n5NkP9bIx95jwY71YEiuFzib30PDJ/DifKnXxBjvy/AkCGztErQRk/8ZCvq+4HXozU2knEGnL/RUitvlwbhzfh2D4lmS3BvWBGS3N3NewoPBrRmdcvnT0xjOGXxtZaJ3P74TkB9GBnlz/HmKORA="
-
-
################
# build matrix #
################
@@ -129,6 +118,9 @@ matrix:
env:
- SPECIAL=coverity
- COMPILER=clang++-3.6
+ # The next declaration is the encrypted COVERITY_SCAN_TOKEN, created
+ # via the "travis encrypt" command using the project repo's public key
+ - secure: "m89SSgE+ASLO38rSKx7MTXK3n5NkP9bIx95jwY71YEiuFzib30PDJ/DifKnXxBjvy/AkCGztErQRk/8ZCvq+4HXozU2knEGnL/RUitvlwbhzfh2D4lmS3BvWBGS3N3NewoPBrRmdcvnT0xjOGXxtZaJ3P74TkB9GBnlz/HmKORA="
# OSX / Clang
@@ -150,6 +142,14 @@ matrix:
- os: osx
osx_image: xcode11.2
+ - os: osx
+ osx_image: xcode12
+
+ - os: osx
+ osx_image: xcode12
+ env:
+ - IMPLICIT_CONVERSIONS=OFF
+
# Linux / GCC
- os: linux
@@ -208,6 +208,16 @@ matrix:
sources: ['ubuntu-toolchain-r-test']
packages: ['g++-9', 'ninja-build']
+ - os: linux
+ compiler: gcc
+ env:
+ - COMPILER=g++-9
+ - IMPLICIT_CONVERSIONS=OFF
+ addons:
+ apt:
+ sources: ['ubuntu-toolchain-r-test']
+ packages: ['g++-9', 'ninja-build']
+
- os: linux
compiler: gcc
env:
@@ -320,10 +330,12 @@ script:
- if [[ "${COMPILER}" != "" ]]; then export CXX=${COMPILER}; fi
# by default, use the single-header version
- if [[ "${MULTIPLE_HEADERS}" == "" ]]; then export MULTIPLE_HEADERS=OFF; fi
+ # by default, use implicit conversions
+ - if [[ "${IMPLICIT_CONVERSIONS}" == "" ]]; then export IMPLICIT_CONVERSIONS=ON; fi
# compile and execute unit tests
- mkdir -p build && cd build
- - cmake .. ${CMAKE_OPTIONS} -DJSON_MultipleHeaders=${MULTIPLE_HEADERS} -DJSON_BuildTests=On -GNinja && cmake --build . --config Release
+ - cmake .. ${CMAKE_OPTIONS} -DJSON_MultipleHeaders=${MULTIPLE_HEADERS} -DJSON_ImplicitConversions=${IMPLICIT_CONVERSIONS} -DJSON_BuildTests=On -GNinja && cmake --build . --config Release
- ctest -C Release --timeout 2700 -V -j
- cd ..
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7f163041..d5d0ae34 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 3.1)
## PROJECT
## name and version
##
-project(nlohmann_json VERSION 3.8.0 LANGUAGES CXX)
+project(nlohmann_json VERSION 3.9.0 LANGUAGES CXX)
##
## INCLUDE
@@ -15,9 +15,16 @@ include(ExternalProject)
##
## OPTIONS
##
+
+if (POLICY CMP0077)
+ # Allow CMake 3.13+ to override options when using FetchContent / add_subdirectory.
+ cmake_policy(SET CMP0077 NEW)
+endif ()
+
option(JSON_BuildTests "Build the unit tests when BUILD_TESTING is enabled." ON)
option(JSON_Install "Install CMake targets during install step." ON)
option(JSON_MultipleHeaders "Use non-amalgamated version of the library." OFF)
+option(JSON_ImplicitConversions "Enable implicit conversions." ON)
##
## CONFIGURATION
@@ -42,6 +49,10 @@ else()
message(STATUS "Using the single-header code from ${NLOHMANN_JSON_INCLUDE_BUILD_DIR}")
endif()
+if (NOT JSON_ImplicitConversions)
+ message(STATUS "Implicit conversions are disabled")
+endif()
+
##
## TARGET
## create target and add include path
@@ -54,6 +65,12 @@ else()
target_compile_features(${NLOHMANN_JSON_TARGET_NAME} INTERFACE cxx_std_11)
endif()
+target_compile_definitions(
+ ${NLOHMANN_JSON_TARGET_NAME}
+ INTERFACE
+ JSON_USE_IMPLICIT_CONVERSIONS=$<BOOL:${JSON_ImplicitConversions}>
+)
+
target_include_directories(
${NLOHMANN_JSON_TARGET_NAME}
INTERFACE
@@ -73,6 +90,12 @@ if (MSVC)
)
endif()
+# Install a pkg-config file, so other tools can find this.
+CONFIGURE_FILE(
+ "${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkg-config.pc.in"
+ "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"
+)
+
##
## TESTS
## create and configure the unit test target
@@ -133,4 +156,8 @@ endif()
NAMESPACE ${PROJECT_NAME}::
DESTINATION ${NLOHMANN_JSON_CONFIG_INSTALL_DIR}
)
+ install(
+ FILES "${CMAKE_BINARY_DIR}/${PROJECT_NAME}.pc"
+ DESTINATION lib/pkgconfig
+ )
endif()
diff --git a/ChangeLog.md b/ChangeLog.md
index 63ff3fb4..7a762275 100644
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,13 +1,129 @@
# Changelog
All notable changes to this project will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org/).
+## [v3.9.0](https://github.com/nlohmann/json/releases/tag/v3.9.0) (2020-07-27)
+
+[Full Changelog](https://github.com/nlohmann/json/compare/v3.8.0...v3.9.0)
+
+- Unknown Type Name clang error when using NLOHMANN\_DEFINE\_TYPE\_NON\_INTRUSIVE [\#2313](https://github.com/nlohmann/json/issues/2313)
+- Clang 10.0 / GCC 10.1 warnings on disabled exceptions [\#2304](https://github.com/nlohmann/json/issues/2304)
+- Application stalls indefinitely with message byte size 10 [\#2293](https://github.com/nlohmann/json/issues/2293)
+- linker error [\#2292](https://github.com/nlohmann/json/issues/2292)
+- Add support for high-precision numbers in UBJSON encoding [\#2286](https://github.com/nlohmann/json/issues/2286)
+- NLOHMANN\_DEFINE\_TYPE\_NON\_INTRUSIVE fails if the length of the argument is 10 [\#2280](https://github.com/nlohmann/json/issues/2280)
+- Custom types : MACRO expansion bug [\#2267](https://github.com/nlohmann/json/issues/2267)
+- to/from\_json Failing To Convert String [\#2238](https://github.com/nlohmann/json/issues/2238)
+- clang 9.0 report warning: unused type alias 'size\_type' \[-Wunused-local-typedef\] [\#2221](https://github.com/nlohmann/json/issues/2221)
+- Enormous array created when working with map\<int,T\> [\#2220](https://github.com/nlohmann/json/issues/2220)
+- Can I disable sorting of json values [\#2219](https://github.com/nlohmann/json/issues/2219)
+- Getting Qt types to work [\#2217](https://github.com/nlohmann/json/issues/2217)
+- Convert to Qt QVariant [\#2216](https://github.com/nlohmann/json/issues/2216)
+- How to custom serialize same data type of vector? [\#2215](https://github.com/nlohmann/json/issues/2215)
+- json constructor does not support std::optional [\#2214](https://github.com/nlohmann/json/issues/2214)
+- Failing to Parse Valid JSON [\#2209](https://github.com/nlohmann/json/issues/2209)
+- \(De-\)Serialization of std::variant with namespaces [\#2208](https://github.com/nlohmann/json/issues/2208)
+- Addint support for complex type [\#2207](https://github.com/nlohmann/json/issues/2207)
+- array\_index possible out of range [\#2205](https://github.com/nlohmann/json/issues/2205)
+- Object deserialized as array [\#2204](https://github.com/nlohmann/json/issues/2204)
+- Sending to a function a reference to a sub-branch [\#2200](https://github.com/nlohmann/json/issues/2200)
+- How to Serialize derived class to JSON object? [\#2199](https://github.com/nlohmann/json/issues/2199)
+- JSON incorrectly serialized [\#2198](https://github.com/nlohmann/json/issues/2198)
+- Exception Unhandled out\_of\_range error [\#2197](https://github.com/nlohmann/json/issues/2197)
+- msgpack serialisation : float is treated as 64bit float, not 32bit float. [\#2196](https://github.com/nlohmann/json/issues/2196)
+- Is it possible to use compile-time type guarantees for JSON structures? [\#2195](https://github.com/nlohmann/json/issues/2195)
+- Question : performance against python dict [\#2194](https://github.com/nlohmann/json/issues/2194)
+- vs2017 compile error [\#2192](https://github.com/nlohmann/json/issues/2192)
+- Check if a key exists [\#2191](https://github.com/nlohmann/json/issues/2191)
+- Failed to run tests due to missing test data on builders without Internet access [\#2190](https://github.com/nlohmann/json/issues/2190)
+- 3.8.0: unit-cbor.cpp test failures [\#2189](https://github.com/nlohmann/json/issues/2189)
+- 'nlohmann/json.hpp' file not found [\#2188](https://github.com/nlohmann/json/issues/2188)
+- How to send json data over the wire? [\#2185](https://github.com/nlohmann/json/issues/2185)
+- Ubuntu 16 not supporting nlohmann/json? [\#2184](https://github.com/nlohmann/json/issues/2184)
+- .get\<std::string\> causing emdash errors [\#2180](https://github.com/nlohmann/json/issues/2180)
+- Object properties should not be re-sorted alphabetically [\#2179](https://github.com/nlohmann/json/issues/2179)
+- Custom type registration : instrusive API [\#2175](https://github.com/nlohmann/json/issues/2175)
+- Many version of the function "void to\_json\(json& j, const MyStruct& struct\)" [\#2171](https://github.com/nlohmann/json/issues/2171)
+- How should strings be escaped? [\#2155](https://github.com/nlohmann/json/issues/2155)
+- Adding a value to an existing json puts it at the beginning instead of the end [\#2149](https://github.com/nlohmann/json/issues/2149)
+- The header file is big, can we use what we need. [\#2134](https://github.com/nlohmann/json/issues/2134)
+- Changing the default format for unordered\_map \(or other set\) [\#2132](https://github.com/nlohmann/json/issues/2132)
+- Getting size of deserialized bson document [\#2131](https://github.com/nlohmann/json/issues/2131)
+- implicit conversion failure [\#2128](https://github.com/nlohmann/json/issues/2128)
+- Error thrown when parsing in a subclass [\#2124](https://github.com/nlohmann/json/issues/2124)
+- explicit conversion to string not considered for std::map keys in GCC8 [\#2096](https://github.com/nlohmann/json/issues/2096)
+- Add support for JSONC [\#2061](https://github.com/nlohmann/json/issues/2061)
+- Library provides template arg for string\_type but assumes std::string in some places [\#2059](https://github.com/nlohmann/json/issues/2059)
+- incremental parsing with sax\_parser [\#2030](https://github.com/nlohmann/json/issues/2030)
+- Question about flatten and unflatten [\#1989](https://github.com/nlohmann/json/issues/1989)
+- CBOR parser doesn't skip tags [\#1968](https://github.com/nlohmann/json/issues/1968)
+- Compilation failure using Clang on Windows [\#1898](https://github.com/nlohmann/json/issues/1898)
+- Fail to build when including json.hpp as a system include [\#1818](https://github.com/nlohmann/json/issues/1818)
+- Parsing string into json doesn't preserve the order correctly. [\#1817](https://github.com/nlohmann/json/issues/1817)
+- \[C++17\] Allow std::optional to convert to nlohmann::json [\#1749](https://github.com/nlohmann/json/issues/1749)
+- How can I save json object in file in order? [\#1717](https://github.com/nlohmann/json/issues/1717)
+- Support for Comments [\#1513](https://github.com/nlohmann/json/issues/1513)
+- clang compiler: error : unknown type name 'not' [\#1119](https://github.com/nlohmann/json/issues/1119)
+- dump\(\) without alphabetical order [\#1106](https://github.com/nlohmann/json/issues/1106)
+- operator T\(\) considered harmful [\#958](https://github.com/nlohmann/json/issues/958)
+- Order of the elements in JSON object [\#952](https://github.com/nlohmann/json/issues/952)
+- How to prevent alphabetical sorting of data? [\#727](https://github.com/nlohmann/json/issues/727)
+- Why is an object ordering values by Alphabetical Order? [\#660](https://github.com/nlohmann/json/issues/660)
+- Feature request: Comments [\#597](https://github.com/nlohmann/json/issues/597)
+- Head Elements Sorting [\#543](https://github.com/nlohmann/json/issues/543)
+- Automatic ordered JSON [\#424](https://github.com/nlohmann/json/issues/424)
+- Support for comments. [\#376](https://github.com/nlohmann/json/issues/376)
+- Optional comment support. [\#363](https://github.com/nlohmann/json/issues/363)
+- Strip comments / Minify [\#294](https://github.com/nlohmann/json/issues/294)
+- maintaining order of keys during iteration [\#106](https://github.com/nlohmann/json/issues/106)
+
+- Update documentation [\#2312](https://github.com/nlohmann/json/pull/2312) ([nlohmann](https://github.com/nlohmann))
+- Fix bug in CBOR tag handling [\#2308](https://github.com/nlohmann/json/pull/2308) ([nlohmann](https://github.com/nlohmann))
+- added inline to NLOHMANN\_DEFINE\_TYPE\_NON\_INTRUSIVE macro [\#2306](https://github.com/nlohmann/json/pull/2306) ([jwittbrodt](https://github.com/jwittbrodt))
+- fixes unused variable 'ex' for \#2304 [\#2305](https://github.com/nlohmann/json/pull/2305) ([AODQ](https://github.com/AODQ))
+- Cleanup [\#2303](https://github.com/nlohmann/json/pull/2303) ([nlohmann](https://github.com/nlohmann))
+- Add test with multiple translation units [\#2301](https://github.com/nlohmann/json/pull/2301) ([nlohmann](https://github.com/nlohmann))
+- Merge GitHub actions [\#2300](https://github.com/nlohmann/json/pull/2300) ([nlohmann](https://github.com/nlohmann))
+- Fix unused parameter [\#2299](https://github.com/nlohmann/json/pull/2299) ([nlohmann](https://github.com/nlohmann))
+- Add support for high-precision numbers in UBJSON encoding [\#2297](https://github.com/nlohmann/json/pull/2297) ([nlohmann](https://github.com/nlohmann))
+- fix eof for get\_binary and get\_string [\#2294](https://github.com/nlohmann/json/pull/2294) ([jprochazk](https://github.com/jprochazk))
+- Serialisation macros: increase upper bound on number of member variables [\#2287](https://github.com/nlohmann/json/pull/2287) ([pfeatherstone](https://github.com/pfeatherstone))
+- add inline specifier for detail::combine [\#2285](https://github.com/nlohmann/json/pull/2285) ([T0b1-iOS](https://github.com/T0b1-iOS))
+- Add static assertion for missing binary function in SAX interface [\#2282](https://github.com/nlohmann/json/pull/2282) ([nlohmann](https://github.com/nlohmann))
+- Add test for target\_include\_directories [\#2279](https://github.com/nlohmann/json/pull/2279) ([nlohmann](https://github.com/nlohmann))
+- Clean up maintainer Makefiles and fix some linter warnings [\#2274](https://github.com/nlohmann/json/pull/2274) ([nlohmann](https://github.com/nlohmann))
+- Add option to ignore CBOR tags [\#2273](https://github.com/nlohmann/json/pull/2273) ([nlohmann](https://github.com/nlohmann))
+- Hash function without allocation [\#2269](https://github.com/nlohmann/json/pull/2269) ([nlohmann](https://github.com/nlohmann))
+- Add ClangCL for MSVC [\#2268](https://github.com/nlohmann/json/pull/2268) ([t-b](https://github.com/t-b))
+- Makefile: Always use SED variable [\#2264](https://github.com/nlohmann/json/pull/2264) ([t-b](https://github.com/t-b))
+- Add Xcode 12 CI [\#2262](https://github.com/nlohmann/json/pull/2262) ([nlohmann](https://github.com/nlohmann))
+- Make library work with Clang on Windows [\#2259](https://github.com/nlohmann/json/pull/2259) ([nlohmann](https://github.com/nlohmann))
+- Add ordered\_json specialization with ordered object keys [\#2258](https://github.com/nlohmann/json/pull/2258) ([nlohmann](https://github.com/nlohmann))
+- Add pkg-config file [\#2253](https://github.com/nlohmann/json/pull/2253) ([ericonr](https://github.com/ericonr))
+- Fix regression from \#2181 [\#2251](https://github.com/nlohmann/json/pull/2251) ([nlohmann](https://github.com/nlohmann))
+- Tag binary values in cbor if set [\#2244](https://github.com/nlohmann/json/pull/2244) ([matthewbauer](https://github.com/matthewbauer))
+- Make assert configurable via JSON\_ASSERT [\#2242](https://github.com/nlohmann/json/pull/2242) ([nlohmann](https://github.com/nlohmann))
+- Add specialization of get\_to [\#2233](https://github.com/nlohmann/json/pull/2233) ([nlohmann](https://github.com/nlohmann))
+- Refine documentation of error\_handler parameter [\#2232](https://github.com/nlohmann/json/pull/2232) ([nlohmann](https://github.com/nlohmann))
+- Simplify conversion from/to custom types [\#2225](https://github.com/nlohmann/json/pull/2225) ([nlohmann](https://github.com/nlohmann))
+- Remove unused typedefs [\#2224](https://github.com/nlohmann/json/pull/2224) ([nlohmann](https://github.com/nlohmann))
+- Enable CMake policy CMP0077 [\#2222](https://github.com/nlohmann/json/pull/2222) ([alexreinking](https://github.com/alexreinking))
+- Add option to ignore comments in parse/accept functions [\#2212](https://github.com/nlohmann/json/pull/2212) ([nlohmann](https://github.com/nlohmann))
+- Fix Clang-Tidy warnings [\#2211](https://github.com/nlohmann/json/pull/2211) ([nlohmann](https://github.com/nlohmann))
+- Simple ordered\_json that works on all supported compilers [\#2206](https://github.com/nlohmann/json/pull/2206) ([gatopeich](https://github.com/gatopeich))
+- Use unsigned indizies for array index in json pointer [\#2203](https://github.com/nlohmann/json/pull/2203) ([t-b](https://github.com/t-b))
+- Add option to not rely on Internet connectivity during test stage [\#2202](https://github.com/nlohmann/json/pull/2202) ([nlohmann](https://github.com/nlohmann))
+- Serialize floating-point numbers with 32 bit when possible \(MessagePack\) [\#2201](https://github.com/nlohmann/json/pull/2201) ([nlohmann](https://github.com/nlohmann))
+- Fix consistency in function `int\_to\_string\(\)` [\#2193](https://github.com/nlohmann/json/pull/2193) ([dota17](https://github.com/dota17))
+- Fix issue\#1275 [\#2181](https://github.com/nlohmann/json/pull/2181) ([dota17](https://github.com/dota17))
+- C++20 support by removing swap specialization [\#2176](https://github.com/nlohmann/json/pull/2176) ([gracicot](https://github.com/gracicot))
+- Feat/explicit conversion operator [\#1559](https://github.com/nlohmann/json/pull/1559) ([theodelrieu](https://github.com/theodelrieu))
+
## [v3.8.0](https://github.com/nlohmann/json/releases/tag/v3.8.0) (2020-06-14)
[Full Changelog](https://github.com/nlohmann/json/compare/v3.7.3...v3.8.0)
- sorry delete this issue, i'm stupid [\#2187](https://github.com/nlohmann/json/issues/2187)
- Append to a std::nlohmann::json type [\#2186](https://github.com/nlohmann/json/issues/2186)
-- Object properties should not be re-sorted alphabetically [\#2179](https://github.com/nlohmann/json/issues/2179)
- Some troubles to compile the last revision [\#2177](https://github.com/nlohmann/json/issues/2177)
- \# Top level CMakeLists.txt
project\(FOO\)
@@ -34,7 +150,6 @@ All notable changes to this project will be documented in this file. This projec
- test-cbor fails [\#2154](https://github.com/nlohmann/json/issues/2154)
- Accessing array inside array syntax? [\#2151](https://github.com/nlohmann/json/issues/2151)
- Best way to catch errors when querying json [\#2150](https://github.com/nlohmann/json/issues/2150)
-- Adding a value to an existing json puts it at the beginning instead of the end [\#2149](https://github.com/nlohmann/json/issues/2149)
- JSON Data Mapping Key-Value from other Key-Value [\#2148](https://github.com/nlohmann/json/issues/2148)
- Conflicts with std \<any\> compiling with GCC 10 [\#2146](https://github.com/nlohmann/json/issues/2146)
- Incorrect CMake FetchContent example [\#2142](https://github.com/nlohmann/json/issues/2142)
@@ -64,7 +179,6 @@ All notable changes to this project will be documented in this file. This projec
- Can't ad an object in another objet [\#2101](https://github.com/nlohmann/json/issues/2101)
- Implicit conversion causes "cannot use operator\[\] with a string argument with string" [\#2098](https://github.com/nlohmann/json/issues/2098)
- C++20: char8\_t [\#2097](https://github.com/nlohmann/json/issues/2097)
-- UTF8 [\#2095](https://github.com/nlohmann/json/issues/2095)
- Compilation issues when included in project [\#2094](https://github.com/nlohmann/json/issues/2094)
- string value with null character causes infinite loop [\#2093](https://github.com/nlohmann/json/issues/2093)
- corrupted size vs. prev\_size \(aborted\) [\#2092](https://github.com/nlohmann/json/issues/2092)
@@ -91,7 +205,6 @@ All notable changes to this project will be documented in this file. This projec
- Bug: returning reference to local temporary object [\#2064](https://github.com/nlohmann/json/issues/2064)
- Allow to use non strict parsing [\#2063](https://github.com/nlohmann/json/issues/2063)
- Crashing on json::at [\#2062](https://github.com/nlohmann/json/issues/2062)
-- Add support for JSONC [\#2061](https://github.com/nlohmann/json/issues/2061)
- How to convert a const std::vector\<char8\_t\> message to a json, to be able to parse it and extract information from it? Can you point to any examples? [\#2058](https://github.com/nlohmann/json/issues/2058)
- Nice library [\#2057](https://github.com/nlohmann/json/issues/2057)
- json.hpp:15372:22: error: expected unqualified-id if \(not std::isfinite\(x\)\): Started getting this bug after updating my XCode [\#2056](https://github.com/nlohmann/json/issues/2056)
@@ -197,7 +310,6 @@ All notable changes to this project will be documented in this file. This projec
- typo in a comment [\#1903](https://github.com/nlohmann/json/issues/1903)
- Watch JSON variables in Debug [\#1902](https://github.com/nlohmann/json/issues/1902)
- does Json sdk cares about dfc dfd utf8 issue? [\#1901](https://github.com/nlohmann/json/issues/1901)
-- Compilation failure using Clang on Windows [\#1898](https://github.com/nlohmann/json/issues/1898)
- Allow multiple line string value in JSON [\#1897](https://github.com/nlohmann/json/issues/1897)
- Writing map to json file [\#1896](https://github.com/nlohmann/json/issues/1896)
- Small documentation mistake [\#1895](https://github.com/nlohmann/json/issues/1895)
@@ -253,7 +365,6 @@ All notable changes to this project will be documented in this file. This projec
- Serialize big data in json [\#1828](https://github.com/nlohmann/json/issues/1828)
- Backslash '\' in value causes exception [\#1827](https://github.com/nlohmann/json/issues/1827)
- from\_json for non default constructible class with dependency injection [\#1819](https://github.com/nlohmann/json/issues/1819)
-- Fail to build when including json.hpp as a system include [\#1818](https://github.com/nlohmann/json/issues/1818)
- Semi-frequent timeouts in `test-unicode\_all` with 3.6.1 \(aarch64\) [\#1816](https://github.com/nlohmann/json/issues/1816)
- input\_adapter not user extensible [\#1813](https://github.com/nlohmann/json/issues/1813)
- crash at json::destroy on android [\#1812](https://github.com/nlohmann/json/issues/1812)
@@ -322,7 +433,6 @@ All notable changes to this project will be documented in this file. This projec
- Fix issue\#1719 [\#2044](https://github.com/nlohmann/json/pull/2044) ([dota17](https://github.com/dota17))
- Add missing testcase about NaN in unit-constructor1.cpp [\#2043](https://github.com/nlohmann/json/pull/2043) ([dota17](https://github.com/dota17))
- Templatize basic\_json constructor from json\_ref [\#2034](https://github.com/nlohmann/json/pull/2034) ([ArtemSarmini](https://github.com/ArtemSarmini))
-- Replace deprecated std::is\_pod [\#2033](https://github.com/nlohmann/json/pull/2033) ([nlohmann](https://github.com/nlohmann))
- fix \#1982:json\_pointer.contains\(\) exception is incorrectly raised [\#2019](https://github.com/nlohmann/json/pull/2019) ([dota17](https://github.com/dota17))
- catch exceptions for json\_pointer : ..../+99 [\#1990](https://github.com/nlohmann/json/pull/1990) ([dota17](https://github.com/dota17))
- fix warnings in serializer.hpp for VS2019 [\#1969](https://github.com/nlohmann/json/pull/1969) ([dota17](https://github.com/dota17))
@@ -369,7 +479,6 @@ All notable changes to this project will be documented in this file. This projec
- json class should have a get\_or member function [\#1823](https://github.com/nlohmann/json/issues/1823)
- NLOHMANN\_JSON\_SERIALIZE\_ENUM macro capture's json objects by value [\#1822](https://github.com/nlohmann/json/issues/1822)
- Parse fails when number literals start with zero [\#1820](https://github.com/nlohmann/json/issues/1820)
-- Parsing string into json doesn't preserve the order correctly. [\#1817](https://github.com/nlohmann/json/issues/1817)
- Weird behaviour of `contains` with `json\_pointer` [\#1815](https://github.com/nlohmann/json/issues/1815)
- strange behaviour with json\_pointer and .contains\(\) [\#1811](https://github.com/nlohmann/json/issues/1811)
- Can \#1695 be re-opened? [\#1808](https://github.com/nlohmann/json/issues/1808)
@@ -426,7 +535,6 @@ All notable changes to this project will be documented in this file. This projec
- CMake not correctly finding the configuration package for 3.7.0 [\#1721](https://github.com/nlohmann/json/issues/1721)
- name typo in the "spack package management" section of README.md [\#1720](https://github.com/nlohmann/json/issues/1720)
- How to add json to another json? [\#1718](https://github.com/nlohmann/json/issues/1718)
-- How can I save json object in file in order? [\#1717](https://github.com/nlohmann/json/issues/1717)
- json::parse\(\) ubsan regression with v3.7.0 [\#1716](https://github.com/nlohmann/json/issues/1716)
- What I am doing wrong?!? [\#1714](https://github.com/nlohmann/json/issues/1714)
- Potential memory leak detected by Valgrind [\#1713](https://github.com/nlohmann/json/issues/1713)
@@ -633,8 +741,6 @@ All notable changes to this project will be documented in this file. This projec
- Added to\_string and added basic tests [\#1585](https://github.com/nlohmann/json/pull/1585) ([Macr0Nerd](https://github.com/Macr0Nerd))
- Regression tests for MSVC [\#1570](https://github.com/nlohmann/json/pull/1570) ([nickaein](https://github.com/nickaein))
- Fix/1511 [\#1555](https://github.com/nlohmann/json/pull/1555) ([theodelrieu](https://github.com/theodelrieu))
-- Remove C++17 extension warning from clang; \#1535 [\#1551](https://github.com/nlohmann/json/pull/1551) ([heavywatal](https://github.com/heavywatal))
-- moved from Catch to doctest for unit tests [\#1439](https://github.com/nlohmann/json/pull/1439) ([onqtam](https://github.com/onqtam))
## [v3.6.1](https://github.com/nlohmann/json/releases/tag/v3.6.1) (2019-03-20)
@@ -658,7 +764,6 @@ All notable changes to this project will be documented in this file. This projec
- how to precision to four decimal for double when use to\_json [\#1519](https://github.com/nlohmann/json/issues/1519)
- error parse [\#1518](https://github.com/nlohmann/json/issues/1518)
- Compile error: template argument deduction/substitution failed [\#1515](https://github.com/nlohmann/json/issues/1515)
-- Support for Comments [\#1513](https://github.com/nlohmann/json/issues/1513)
- std::complex type [\#1510](https://github.com/nlohmann/json/issues/1510)
- CBOR byte string support [\#1509](https://github.com/nlohmann/json/issues/1509)
- Compilation error getting a std::pair\<\> on latest VS 2017 compiler [\#1506](https://github.com/nlohmann/json/issues/1506)
@@ -738,6 +843,7 @@ All notable changes to this project will be documented in this file. This projec
- Implicit type conversion error on MSVC [\#1333](https://github.com/nlohmann/json/issues/1333)
- NuGet Package [\#1132](https://github.com/nlohmann/json/issues/1132)
+- Remove C++17 extension warning from clang; \#1535 [\#1551](https://github.com/nlohmann/json/pull/1551) ([heavywatal](https://github.com/heavywatal))
- Change macros to numeric\_limits [\#1514](https://github.com/nlohmann/json/pull/1514) ([naszta](https://github.com/naszta))
- fix GCC 7.1.1 - 7.2.1 on CentOS [\#1496](https://github.com/nlohmann/json/pull/1496) ([lieff](https://github.com/lieff))
- Update Buckaroo instructions in README.md [\#1495](https://github.com/nlohmann/json/pull/1495) ([njlr](https://github.com/njlr))
@@ -753,6 +859,7 @@ All notable changes to this project will be documented in this file. This projec
- remove extra semicolon from readme [\#1451](https://github.com/nlohmann/json/pull/1451) ([Afforix](https://github.com/Afforix))
- attempt to fix \#1445, flush buffer in serializer::dump\_escaped in UTF8\_REJECT case. [\#1446](https://github.com/nlohmann/json/pull/1446) ([scinart](https://github.com/scinart))
- Use C++11 features supported by CMake 3.1. [\#1441](https://github.com/nlohmann/json/pull/1441) ([iwanders](https://github.com/iwanders))
+- moved from Catch to doctest for unit tests [\#1439](https://github.com/nlohmann/json/pull/1439) ([onqtam](https://github.com/onqtam))
- :rotating\_light: fixed unused variable warning [\#1435](https://github.com/nlohmann/json/pull/1435) ([pboettch](https://github.com/pboettch))
- allow push\_back\(\) and pop\_back\(\) calls on json\_pointer [\#1434](https://github.com/nlohmann/json/pull/1434) ([pboettch](https://github.com/pboettch))
- Add instructions about using nlohmann/json with the conda package manager [\#1430](https://github.com/nlohmann/json/pull/1430) ([nicoddemus](https://github.com/nicoddemus))
@@ -824,7 +931,6 @@ All notable changes to this project will be documented in this file. This projec
- Comparisons between large unsigned and negative signed integers [\#1295](https://github.com/nlohmann/json/issues/1295)
- CMake alias to `nlohmann::json` [\#1291](https://github.com/nlohmann/json/issues/1291)
- Release zips without tests [\#1285](https://github.com/nlohmann/json/issues/1285)
-- Suggestion to improve value\(\) accessors with respect to move semantics [\#1275](https://github.com/nlohmann/json/issues/1275)
- separate object\_t::key\_type from basic\_json::key\_type, and use an allocator which returns object\_t::key\_type [\#1274](https://github.com/nlohmann/json/issues/1274)
- Is there a nice way to associate external values with json elements? [\#1256](https://github.com/nlohmann/json/issues/1256)
- Delete by json\_pointer [\#1248](https://github.com/nlohmann/json/issues/1248)
@@ -1023,7 +1129,6 @@ All notable changes to this project will be documented in this file. This projec
- can't not parse "\\“ string [\#1123](https://github.com/nlohmann/json/issues/1123)
- if json file contain Internationalization chars , get exception [\#1122](https://github.com/nlohmann/json/issues/1122)
- How to use a json::iterator dereferenced value in code? [\#1120](https://github.com/nlohmann/json/issues/1120)
-- clang compiler: error : unknown type name 'not' [\#1119](https://github.com/nlohmann/json/issues/1119)
- Disable implicit conversions from json to std::initializer\_list\<T\> for any T [\#1118](https://github.com/nlohmann/json/issues/1118)
- Implicit conversions to complex types can lead to surprising and confusing errors [\#1116](https://github.com/nlohmann/json/issues/1116)
- How can I write from\_json for a complex datatype that is not default constructible? [\#1115](https://github.com/nlohmann/json/issues/1115)
@@ -1035,7 +1140,6 @@ All notable changes to this project will be documented in this file. This projec
- JSON representation for floating point values has too many digits [\#1109](https://github.com/nlohmann/json/issues/1109)
- Not working for classes containing "\_declspec\(dllimport\)" in their declaration [\#1108](https://github.com/nlohmann/json/issues/1108)
- Get keys from json object [\#1107](https://github.com/nlohmann/json/issues/1107)
-- dump\(\) without alphabetical order [\#1106](https://github.com/nlohmann/json/issues/1106)
- Cannot deserialize types using std::ratio [\#1105](https://github.com/nlohmann/json/issues/1105)
- i want to learn json [\#1104](https://github.com/nlohmann/json/issues/1104)
- Type checking during compile [\#1103](https://github.com/nlohmann/json/issues/1103)
@@ -1182,6 +1286,7 @@ All notable changes to this project will be documented in this file. This projec
- Allowing for user-defined string type in lexer/parser [\#1009](https://github.com/nlohmann/json/pull/1009) ([nlohmann](https://github.com/nlohmann))
- dump to alternative string type, as defined in basic\_json template [\#1006](https://github.com/nlohmann/json/pull/1006) ([agrianius](https://github.com/agrianius))
+- Fix memory leak during parser callback [\#1001](https://github.com/nlohmann/json/pull/1001) ([nlohmann](https://github.com/nlohmann))
- fixed misprinted condition detected by PVS Studio. [\#992](https://github.com/nlohmann/json/pull/992) ([bogemic](https://github.com/bogemic))
- Fix/basic json conversion [\#986](https://github.com/nlohmann/json/pull/986) ([theodelrieu](https://github.com/theodelrieu))
- Make integration section concise [\#981](https://github.com/nlohmann/json/pull/981) ([wla80](https://github.com/wla80))
@@ -1205,7 +1310,6 @@ All notable changes to this project will be documented in this file. This projec
- \[Request\] Macro generating from\_json\(\) and to\_json\(\) [\#895](https://github.com/nlohmann/json/issues/895)
- basic\_json::value throws exception instead of returning default value [\#871](https://github.com/nlohmann/json/issues/871)
-- Fix memory leak during parser callback [\#1001](https://github.com/nlohmann/json/pull/1001) ([nlohmann](https://github.com/nlohmann))
- Fix constraints on from\_json\(CompatibleArrayType\) [\#969](https://github.com/nlohmann/json/pull/969) ([theodelrieu](https://github.com/theodelrieu))
- Make coveralls watch the include folder [\#957](https://github.com/nlohmann/json/pull/957) ([theodelrieu](https://github.com/theodelrieu))
- Fix links in README.md [\#955](https://github.com/nlohmann/json/pull/955) ([patrikhuber](https://github.com/patrikhuber))
@@ -1219,7 +1323,6 @@ All notable changes to this project will be documented in this file. This projec
[Full Changelog](https://github.com/nlohmann/json/compare/v3.0.1...3.1.0)
-- Order of the elements in JSON object [\#952](https://github.com/nlohmann/json/issues/952)
- I have a proposal [\#949](https://github.com/nlohmann/json/issues/949)
- VERSION define\(s\) [\#948](https://github.com/nlohmann/json/issues/948)
- v3.0.1 compile error in icc 16.0.4 [\#947](https://github.com/nlohmann/json/issues/947)
@@ -1421,7 +1524,6 @@ All notable changes to this project will be documented in this file. This projec
- Project's name is too generic and hard to search for [\#730](https://github.com/nlohmann/json/issues/730)
- Visual Studio 2015 IntelliTrace problems [\#729](https://github.com/nlohmann/json/issues/729)
- How to erase nested objects inside other objects? [\#728](https://github.com/nlohmann/json/issues/728)
-- How to prevent alphabetical sorting of data? [\#727](https://github.com/nlohmann/json/issues/727)
- Serialization for CBOR [\#726](https://github.com/nlohmann/json/issues/726)
- Using json Object as value in a map [\#725](https://github.com/nlohmann/json/issues/725)
- std::regex and nlohmann::json value [\#724](https://github.com/nlohmann/json/issues/724)
@@ -1469,7 +1571,6 @@ All notable changes to this project will be documented in this file. This projec
- could this json lib work on windows? [\#664](https://github.com/nlohmann/json/issues/664)
- How does from\_json work? [\#662](https://github.com/nlohmann/json/issues/662)
- insert\(or merge\) object should replace same key , not ignore [\#661](https://github.com/nlohmann/json/issues/661)
-- Why is an object ordering values by Alphabetical Order? [\#660](https://github.com/nlohmann/json/issues/660)
- Parse method doesn't handle newlines. [\#659](https://github.com/nlohmann/json/issues/659)
- Compilation "note" on GCC 6 ARM [\#658](https://github.com/nlohmann/json/issues/658)
- Adding additional push\_back/operator+= rvalue overloads for JSON object [\#657](https://github.com/nlohmann/json/issues/657)
@@ -1519,7 +1620,6 @@ All notable changes to this project will be documented in this file. This projec
- Use of the binary type in CBOR and Message Pack [\#601](https://github.com/nlohmann/json/issues/601)
- Newbie issue: how does one convert a map in Json back to std::map? [\#600](https://github.com/nlohmann/json/issues/600)
- Plugin system [\#599](https://github.com/nlohmann/json/issues/599)
-- Feature request: Comments [\#597](https://github.com/nlohmann/json/issues/597)
- Using custom types for scalars? [\#596](https://github.com/nlohmann/json/issues/596)
- Issues with the arithmetic in iterator and reverse iterator [\#593](https://github.com/nlohmann/json/issues/593)
- not enough examples [\#592](https://github.com/nlohmann/json/issues/592)
@@ -1561,7 +1661,6 @@ All notable changes to this project will be documented in this file. This projec
- Ambiguous compare operators with clang-5.0 [\#547](https://github.com/nlohmann/json/issues/547)
- Using tsl::ordered\_map [\#546](https://github.com/nlohmann/json/issues/546)
- Compiler support errors are inconvenient [\#544](https://github.com/nlohmann/json/issues/544)
-- Head Elements Sorting [\#543](https://github.com/nlohmann/json/issues/543)
- Duplicate symbols error happens while to\_json/from\_json method implemented inside entity definition header file [\#542](https://github.com/nlohmann/json/issues/542)
- consider adding a bool json::is\_valid\(std::string const&\) non-member function [\#541](https://github.com/nlohmann/json/issues/541)
- Help request [\#539](https://github.com/nlohmann/json/issues/539)
@@ -1730,7 +1829,6 @@ All notable changes to this project will be documented in this file. This projec
- Getting std::invalid\_argument: stream error when following example [\#429](https://github.com/nlohmann/json/issues/429)
- Forward declare-only header? [\#427](https://github.com/nlohmann/json/issues/427)
- Implicit conversion from array to object [\#425](https://github.com/nlohmann/json/issues/425)
-- Automatic ordered JSON [\#424](https://github.com/nlohmann/json/issues/424)
- error C4996: 'strerror' when reading file [\#422](https://github.com/nlohmann/json/issues/422)
- Get an error - JSON pointer must be empty or begin with '/' [\#421](https://github.com/nlohmann/json/issues/421)
- size parameter for parse\(\) [\#419](https://github.com/nlohmann/json/issues/419)
@@ -1739,7 +1837,6 @@ All notable changes to this project will be documented in this file. This projec
- comparing to 0 literal [\#414](https://github.com/nlohmann/json/issues/414)
- Single char converted to ASCII code instead of string [\#413](https://github.com/nlohmann/json/issues/413)
- How to know if a string was parsed as utf-8? [\#406](https://github.com/nlohmann/json/issues/406)
-- Heap-buffer-overflow \(OSS-Fuzz issue 342\) [\#405](https://github.com/nlohmann/json/issues/405)
- Overloaded += to add objects to an array makes no sense? [\#404](https://github.com/nlohmann/json/issues/404)
- Finding a value in an array [\#399](https://github.com/nlohmann/json/issues/399)
- add release information in static function [\#397](https://github.com/nlohmann/json/issues/397)
@@ -1769,6 +1866,7 @@ All notable changes to this project will be documented in this file. This projec
- Use-of-uninitialized-value \(OSS-Fuzz issue 347\) [\#409](https://github.com/nlohmann/json/issues/409)
- Heap-buffer-overflow \(OSS-Fuzz issue 344\) [\#408](https://github.com/nlohmann/json/issues/408)
- Heap-buffer-overflow \(OSS-Fuzz issue 343\) [\#407](https://github.com/nlohmann/json/issues/407)
+- Heap-buffer-overflow \(OSS-Fuzz issue 342\) [\#405](https://github.com/nlohmann/json/issues/405)
- strerror throwing error in compiler VS2015 [\#403](https://github.com/nlohmann/json/issues/403)
- json::parse of std::string being underlined by Visual Studio [\#402](https://github.com/nlohmann/json/issues/402)
- Explicitly getting string without .dump\(\) [\#401](https://github.com/nlohmann/json/issues/401)
@@ -1800,7 +1898,6 @@ All notable changes to this project will be documented in this file. This projec
- Allow for forward declaring nlohmann::json [\#381](https://github.com/nlohmann/json/issues/381)
- Bug in overflow detection when parsing integers [\#380](https://github.com/nlohmann/json/issues/380)
- A unique name to mention the library? [\#377](https://github.com/nlohmann/json/issues/377)
-- Support for comments. [\#376](https://github.com/nlohmann/json/issues/376)
- Non-unique keys in objects. [\#375](https://github.com/nlohmann/json/issues/375)
- Request: binary serialization/deserialization [\#358](https://github.com/nlohmann/json/issues/358)
@@ -1824,7 +1921,6 @@ All notable changes to this project will be documented in this file. This projec
- json::parse on failed stream gets stuck [\#366](https://github.com/nlohmann/json/issues/366)
- Performance improvements [\#365](https://github.com/nlohmann/json/issues/365)
- 'to\_string' is not a member of 'std' [\#364](https://github.com/nlohmann/json/issues/364)
-- Optional comment support. [\#363](https://github.com/nlohmann/json/issues/363)
- Crash in dump\(\) from a static object [\#359](https://github.com/nlohmann/json/issues/359)
- json::parse\(...\) vs json j; j.parse\(...\) [\#357](https://github.com/nlohmann/json/issues/357)
- Hi, is there any method to dump json to string with the insert order rather than alphabets [\#356](https://github.com/nlohmann/json/issues/356)
@@ -1902,7 +1998,6 @@ All notable changes to this project will be documented in this file. This projec
[Full Changelog](https://github.com/nlohmann/json/compare/v2.0.2...v2.0.3)
- warning C4706: assignment within conditional expression [\#295](https://github.com/nlohmann/json/issues/295)
-- Strip comments / Minify [\#294](https://github.com/nlohmann/json/issues/294)
- Q: Is it possible to build json tree from already UTF8 encoded values? [\#293](https://github.com/nlohmann/json/issues/293)
- Equality operator results in array when assigned object [\#292](https://github.com/nlohmann/json/issues/292)
- Support for integers not from the range \[-\(2\*\*53\)+1, \(2\*\*53\)-1\] in parser [\#291](https://github.com/nlohmann/json/issues/291)
@@ -2077,7 +2172,6 @@ All notable changes to this project will be documented in this file. This projec
- error: unterminated raw string [\#109](https://github.com/nlohmann/json/issues/109)
- vector\<json\> copy constructor really weird [\#108](https://github.com/nlohmann/json/issues/108)
- \[clang-3.6.2\] string/sstream with number to json issue [\#107](https://github.com/nlohmann/json/issues/107)
-- maintaining order of keys during iteration [\#106](https://github.com/nlohmann/json/issues/106)
- object field accessors [\#103](https://github.com/nlohmann/json/issues/103)
- v8pp and json [\#95](https://github.com/nlohmann/json/issues/95)
- Wishlist [\#65](https://github.com/nlohmann/json/issues/65)
diff --git a/Makefile b/Makefile
index 8579fb5d..98fa365a 100644
--- a/Makefile
+++ b/Makefile
@@ -5,7 +5,7 @@
##########################################################################
# directory to recent compiler binaries
-COMPILER_DIR=/Users/niels/Documents/projects/compilers/local/bin
+COMPILER_DIR=/usr/local/opt/llvm/bin
# find GNU sed to use `-i` parameter
SED:=$(shell command -v gsed || which sed)
@@ -30,7 +30,6 @@ AMALGAMATED_FILE=single_include/nlohmann/json.hpp
all:
@echo "amalgamate - amalgamate file single_include/nlohmann/json.hpp from the include/nlohmann sources"
@echo "ChangeLog.md - generate ChangeLog file"
- @echo "check - compile and execute test suite"
@echo "check-amalgamation - check whether sources have been amalgamated"
@echo "clean - remove built files"
@echo "coverage - create coverage information with lcov"
@@ -44,38 +43,24 @@ all:
@echo "fuzz_testing_cbor - prepare fuzz testing of the CBOR parser"
@echo "fuzz_testing_msgpack - prepare fuzz testing of the MessagePack parser"
@echo "fuzz_testing_ubjson - prepare fuzz testing of the UBJSON parser"
- @echo "json_unit - create single-file test executable"
@echo "pedantic_clang - run Clang with maximal warning flags"
@echo "pedantic_gcc - run GCC with maximal warning flags"
@echo "pretty - beautify code with Artistic Style"
@echo "run_benchmarks - build and run benchmarks"
-##########################################################################
-# unit tests
-##########################################################################
-
-# build unit tests
-json_unit:
- @$(MAKE) json_unit -C test
-
-# run unit tests
-check:
- $(MAKE) check -C test
-
-
##########################################################################
# coverage
##########################################################################
coverage:
- rm -fr build_coverage
- mkdir build_coverage
- cd build_coverage ; cmake .. -GNinja -DCMAKE_BUILD_TYPE=Debug -DJSON_Coverage=ON -DJSON_MultipleHeaders=ON
- cd build_coverage ; ninja
- cd build_coverage ; ctest -j10
- cd build_coverage ; ninja lcov_html
- open build_coverage/test/html/index.html
+ rm -fr cmake-build-coverage
+ mkdir cmake-build-coverage
+ cd cmake-build-coverage ; cmake .. -GNinja -DCMAKE_BUILD_TYPE=Debug -DJSON_Coverage=ON -DJSON_MultipleHeaders=ON
+ cd cmake-build-coverage ; ninja
+ cd cmake-build-coverage ; ctest -j10
+ cd cmake-build-coverage ; ninja lcov_html
+ open cmake-build-coverage/test/html/index.html
##########################################################################
# documentation tests
@@ -97,12 +82,13 @@ doctest:
# -Wno-exit-time-destructors: warning in json code triggered by NLOHMANN_JSON_SERIALIZE_ENUM
# -Wno-float-equal: not all comparisons in the tests can be replaced by Approx
# -Wno-keyword-macro: unit-tests use "#define private public"
+# -Wno-missing-prototypes: for NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
# -Wno-padded: padding is nothing to warn about
# -Wno-range-loop-analysis: items tests "for(const auto i...)"
# -Wno-switch-enum -Wno-covered-switch-default: pedantic/contradicting warnings about switches
# -Wno-weak-vtables: exception class is defined inline, but has virtual method
pedantic_clang:
- rm -fr build_pedantic
+ rm -fr cmake-build-pedantic
CXXFLAGS=" \
-std=c++11 -Wno-c++98-compat -Wno-c++98-compat-pedantic \
-Werror \
@@ -113,15 +99,16 @@ pedantic_clang:
-Wno-exit-time-destructors \
-Wno-float-equal \
-Wno-keyword-macro \
+ -Wno-missing-prototypes \
-Wno-padded \
-Wno-range-loop-analysis \
-Wno-switch-enum -Wno-covered-switch-default \
- -Wno-weak-vtables" cmake -S . -B build_pedantic -GNinja -DCMAKE_BUILD_TYPE=Debug -DJSON_MultipleHeaders=ON -DJSON_BuildTests=On
- cmake --build build_pedantic
+ -Wno-weak-vtables" cmake -S . -B cmake-build-pedantic -GNinja -DCMAKE_BUILD_TYPE=Debug -DJSON_MultipleHeaders=ON -DJSON_BuildTests=On
+ cmake --build cmake-build-pedantic
# calling GCC with most warnings
pedantic_gcc:
- rm -fr build_pedantic
+ rm -fr cmake-build-pedantic
CXXFLAGS=" \
-std=c++11 \
-pedantic \
@@ -253,7 +240,7 @@ pedantic_gcc:
-Wmismatched-tags \
-Wmissing-attributes \
-Wmissing-braces \
- -Wmissing-declarations \
+ -Wno-missing-declarations \
-Wmissing-field-initializers \
-Wmissing-include-dirs \
-Wmissing-profile \
@@ -379,19 +366,19 @@ pedantic_gcc:
-Wwrite-strings \
-Wzero-as-null-pointer-constant \
-Wzero-length-bounds \
- " cmake -S . -B build_pedantic -GNinja -DCMAKE_BUILD_TYPE=Debug -DJSON_MultipleHeaders=ON -DJSON_BuildTests=On
- cmake --build build_pedantic
+ " cmake -S . -B cmake-build-pedantic -GNinja -DCMAKE_BUILD_TYPE=Debug -DJSON_MultipleHeaders=ON -DJSON_BuildTests=On
+ cmake --build cmake-build-pedantic
##########################################################################
# benchmarks
##########################################################################
run_benchmarks:
- rm -fr build_benchmarks
- mkdir build_benchmarks
- cd build_benchmarks ; cmake ../benchmarks -GNinja -DCMAKE_BUILD_TYPE=Release -DJSON_BuildTests=On
- cd build_benchmarks ; ninja
- cd build_benchmarks ; ./json_benchmarks
+ rm -fr cmake-build-benchmarks
+ mkdir cmake-build-benchmarks
+ cd cmake-build-benchmarks ; cmake ../benchmarks -GNinja -DCMAKE_BUILD_TYPE=Release -DJSON_BuildTests=On
+ cd cmake-build-benchmarks ; ninja
+ cd cmake-build-benchmarks ; ./json_benchmarks
##########################################################################
# fuzzing
@@ -464,14 +451,14 @@ cppcheck:
# call Clang Static Analyzer <https://clang-analyzer.llvm.org>
clang_analyze:
- rm -fr clang_analyze_build
- mkdir clang_analyze_build
- cd clang_analyze_build ; CCC_CXX=$(COMPILER_DIR)/clang++ CXX=$(COMPILER_DIR)/clang++ $(COMPILER_DIR)/scan-build cmake .. -GNinja -DJSON_BuildTests=On
- cd clang_analyze_build ; \
+ rm -fr cmake-build-clang-analyze
+ mkdir cmake-build-clang-analyze
+ cd cmake-build-clang-analyze ; CCC_CXX=$(COMPILER_DIR)/clang++ CXX=$(COMPILER_DIR)/clang++ $(COMPILER_DIR)/scan-build cmake .. -GNinja -DJSON_BuildTests=On
+ cd cmake-build-clang-analyze ; \
$(COMPILER_DIR)/scan-build \
-enable-checker alpha.core.BoolAssignment,alpha.core.CallAndMessageUnInitRefArg,alpha.core.CastSize,alpha.core.CastToStruct,alpha.core.Conversion,alpha.core.DynamicTypeChecker,alpha.core.FixedAddr,alpha.core.PointerArithm,alpha.core.PointerSub,alpha.core.SizeofPtr,alpha.core.StackAddressAsyncEscape,alpha.core.TestAfterDivZero,alpha.deadcode.UnreachableCode,core.builtin.BuiltinFunctions,core.builtin.NoReturnFunctions,core.CallAndMessage,core.DivideZero,core.DynamicTypePropagation,core.NonnilStringConstants,core.NonNullParamChecker,core.NullDereference,core.StackAddressEscape,core.UndefinedBinaryOperatorResult,core.uninitialized.ArraySubscript,core.uninitialized.Assign,core.uninitialized.Branch,core.uninitialized.CapturedBlockVariable,core.uninitialized.UndefReturn,core.VLASize,cplusplus.InnerPointer,cplusplus.Move,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,cplusplus.SelfAssignment,deadcode.DeadStores,nullability.NullableDereferenced,nullability.NullablePassedToNonnull,nullability.NullableReturnedFromNonnull,nullability.NullPassedToNonnull,nullability.NullReturnedFromNonnull \
--use-c++=$(COMPILER_DIR)/clang++ -analyze-headers -o report ninja
- open clang_analyze_build/report/*/index.html
+ open cmake-build-clang-analyze/report/*/index.html
# call cpplint <https://github.com/cpplint/cpplint>
# Note: some errors expected due to false positives
@@ -482,22 +469,22 @@ cpplint:
# call Clang-Tidy <https://clang.llvm.org/extra/clang-tidy/>
clang_tidy:
- $(COMPILER_DIR)/clang-tidy $(AMALGAMATED_FILE) -- -Iinclude -std=c++11
+ $(COMPILER_DIR)/clang-tidy $(SRCS) -- -Iinclude -std=c++11
# call PVS-Studio Analyzer <https://www.viva64.com/en/pvs-studio/>
pvs_studio:
- rm -fr pvs_studio_build
- mkdir pvs_studio_build
- cd pvs_studio_build ; cmake .. -DCMAKE_EXPORT_COMPILE_COMMANDS=On
- cd pvs_studio_build ; pvs-studio-analyzer analyze -j 10
- cd pvs_studio_build ; plog-converter -a'GA:1,2;64:1;CS' -t fullhtml PVS-Studio.log -o pvs
- open pvs_studio_build/pvs/index.html
+ rm -fr cmake-build-pvs-studio
+ mkdir cmake-build-pvs-studio
+ cd cmake-build-pvs-studio ; cmake .. -DCMAKE_EXPORT_COMPILE_COMMANDS=On -DJSON_MultipleHeaders=ON
+ cd cmake-build-pvs-studio ; pvs-studio-analyzer analyze -j 10
+ cd cmake-build-pvs-studio ; plog-converter -a'GA:1,2;64:1;CS' -t fullhtml PVS-Studio.log -o pvs
+ open cmake-build-pvs-studio/pvs/index.html
# call Infer <https://fbinfer.com> static analyzer
infer:
- rm -fr infer_build
- mkdir infer_build
- cd infer_build ; infer compile -- cmake .. ; infer run -- make -j 4
+ rm -fr cmake-build-infer
+ mkdir cmake-build-infer
+ cd cmake-build-infer ; infer compile -- cmake .. -DJSON_MultipleHeaders=ON ; infer run -- make -j 4
# call OCLint <http://oclint.org> static analyzer
oclint:
@@ -506,11 +493,11 @@ oclint:
# execute the test suite with Clang sanitizers (address and undefined behavior)
clang_sanitize:
- rm -fr clang_sanitize_build
- mkdir clang_sanitize_build
- cd clang_sanitize_build ; CXX=$(COMPILER_DIR)/clang++ cmake .. -DJSON_Sanitizer=On -DJSON_MultipleHeaders=ON -DJSON_BuildTests=On -GNinja
- cd clang_sanitize_build ; ninja
- cd clang_sanitize_build ; ctest -j10
+ rm -fr cmake-build-clang-sanitize
+ mkdir cmake-build-clang-sanitize
+ cd cmake-build-clang-sanitize ; CXX=$(COMPILER_DIR)/clang++ cmake .. -DJSON_Sanitizer=On -DJSON_MultipleHeaders=ON -DJSON_BuildTests=On -GNinja
+ cd cmake-build-clang-sanitize ; ninja
+ cd cmake-build-clang-sanitize ; ctest -j10
##########################################################################
@@ -538,7 +525,11 @@ pretty:
--preserve-date \
--suffix=none \
--formatted \
- $(SRCS) $(AMALGAMATED_FILE) test/src/*.cpp benchmarks/src/benchmarks.cpp doc/examples/*.cpp
+ $(SRCS) $(AMALGAMATED_FILE) test/src/*.cpp test/src/*.hpp benchmarks/src/benchmarks.cpp doc/examples/*.cpp
+
+# call the Clang-Format on all source files
+pretty_format:
+ for FILE in $(SRCS) $(AMALGAMATED_FILE) test/src/*.cpp test/src/*.hpp benchmarks/src/benchmarks.cpp doc/examples/*.cpp; do echo $$FILE; clang-format -i $$FILE; done
# create single header file
amalgamate: $(AMALGAMATED_FILE)
@@ -560,7 +551,7 @@ check-amalgamation:
check-single-includes:
@for x in $(SRCS); do \
echo "Checking self-sufficiency of $$x..." ; \
- echo "#include <$$x>\nint main() {}\n" | sed 's|include/||' > single_include_test.cpp; \
+ echo "#include <$$x>\nint main() {}\n" | $(SED) 's|include/||' > single_include_test.cpp; \
$(CXX) $(CXXFLAGS) -Iinclude -std=c++11 single_include_test.cpp -o single_include_test; \
rm -f single_include_test.cpp single_include_test; \
done
@@ -570,17 +561,17 @@ check-single-includes:
# CMake
##########################################################################
-# grep "^option" CMakeLists.txt test/CMakeLists.txt | sed 's/(/ /' | awk '{print $2}' | xargs
+# grep "^option" CMakeLists.txt test/CMakeLists.txt | $(SED) 's/(/ /' | awk '{print $2}' | xargs
# check if all flags of our CMake files work
check_cmake_flags_do:
$(CMAKE_BINARY) --version
- for flag in '' JSON_BuildTests JSON_Install JSON_MultipleHeaders JSON_Sanitizer JSON_Valgrind JSON_NoExceptions JSON_Coverage; do \
+ for flag in JSON_BuildTests JSON_Install JSON_MultipleHeaders JSON_Sanitizer JSON_Valgrind JSON_NoExceptions JSON_Coverage; do \
rm -fr cmake_build; \
mkdir cmake_build; \
- echo "$(CMAKE_BINARY) .. -D$$flag=On" ; \
+ echo "\n\n$(CMAKE_BINARY) .. -D$$flag=On\n" ; \
cd cmake_build ; \
- CXX=g++-8 $(CMAKE_BINARY) .. -D$$flag=On -DCMAKE_CXX_COMPILE_FEATURES="cxx_std_11;cxx_range_for" -DCMAKE_CXX_FLAGS="-std=gnu++11" ; \
+ $(CMAKE_BINARY) -Werror=dev .. -D$$flag=On -DCMAKE_CXX_COMPILE_FEATURES="cxx_std_11;cxx_range_for" -DCMAKE_CXX_FLAGS="-std=gnu++11" ; \
test -f Makefile || exit 1 ; \
cd .. ; \
done;
@@ -638,9 +629,8 @@ clean:
rm -fr json_unit json_benchmarks fuzz fuzz-testing *.dSYM test/*.dSYM oclint_report.html
rm -fr benchmarks/files/numbers/*.json
rm -fr cmake-3.1.0-Darwin64.tar.gz cmake-3.1.0-Darwin64
- rm -fr build_coverage build_benchmarks fuzz-testing clang_analyze_build pvs_studio_build infer_build clang_sanitize_build cmake_build
+ rm -fr cmake-build-coverage cmake-build-benchmarks fuzz-testing cmake-build-clang-analyze cmake-build-pvs-studio cmake-build-infer cmake-build-clang-sanitize cmake_build
$(MAKE) clean -Cdoc
- $(MAKE) clean -Ctest
##########################################################################
# Thirdparty code
@@ -649,6 +639,6 @@ clean:
update_hedley:
rm -f include/nlohmann/thirdparty/hedley/hedley.hpp include/nlohmann/thirdparty/hedley/hedley_undef.hpp
curl https://raw.githubusercontent.com/nemequ/hedley/master/hedley.h -o include/nlohmann/thirdparty/hedley/hedley.hpp
- gsed -i 's/HEDLEY_/JSON_HEDLEY_/g' include/nlohmann/thirdparty/hedley/hedley.hpp
- grep "[[:blank:]]*#[[:blank:]]*undef" include/nlohmann/thirdparty/hedley/hedley.hpp | grep -v "__" | sort | uniq | gsed 's/ //g' | gsed 's/undef/undef /g' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp
+ $(SED) -i 's/HEDLEY_/JSON_HEDLEY_/g' include/nlohmann/thirdparty/hedley/hedley.hpp
+ grep "[[:blank:]]*#[[:blank:]]*undef" include/nlohmann/thirdparty/hedley/hedley.hpp | grep -v "__" | sort | uniq | $(SED) 's/ //g' | $(SED) 's/undef/undef /g' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp
$(MAKE) amalgamate
diff --git a/README.md b/README.md
index d7492da3..07933a5b 100644
--- a/README.md
+++ b/README.md
@@ -27,6 +27,7 @@
- [Integration](#integration)
- [CMake](#cmake)
- [Package Managers](#package-managers)
+ - [Pkg-config](#pkg-config)
- [Examples](#examples)
- [JSON as first-class data type](#json-as-first-class-data-type)
- [Serialization / Deserialization](#serialization--deserialization)
@@ -230,6 +231,20 @@ Please file issues [here](https://github.com/build2-packaging/nlohmann-json) if
If you are using [`wsjcpp`](https://wsjcpp.org), you can use the command `wsjcpp install "https://github.com/nlohmann/json:develop"` to get the latest version. Note you can change the branch ":develop" to an existing tag or another branch.
+### Pkg-config
+
+If you are using bare Makefiles, you can use `pkg-config` to generate the include flags that point to where the library is installed:
+
+```sh
+pkg-config nlohmann_json --cflags
+```
+
+Users of the Meson build system will also be able to use a system wide library, which will be found by `pkg-config`:
+
+```meson
+json = dependency('nlohmann_json', required: true)
+```
+
## Examples
Beside the examples below, you may want to check the [documentation](https://nlohmann.github.io/json/) where each function contains a separate code example (e.g., check out [`emplace()`](https://nlohmann.github.io/json/classnlohmann_1_1basic__json_a5338e282d1d02bed389d852dd670d98d.html#a5338e282d1d02bed389d852dd670d98d)). All [example files](https://github.com/nlohmann/json/tree/develop/doc/examples) can be compiled and executed on their own (e.g., file [emplace.cpp](https://github.com/nlohmann/json/blob/develop/doc/examples/emplace.cpp)).
@@ -468,7 +483,7 @@ MyIterator begin(MyContainer& tgt) {
}
MyIterator end(const MyContainer&) {
- return {};
+ return {};
}
void foo() {
@@ -497,6 +512,8 @@ bool number_float(number_float_t val, const string_t& s);
// called when a string is parsed; value is passed and can be safely moved away
bool string(string_t& val);
+// called when a binary value is parsed; value is passed and can be safely moved away
+bool binary(binary_t& val);
// called when an object or array begins or ends, resp. The number of elements is passed (or -1 if not known)
bool start_object(std::size_t elements);
@@ -746,7 +763,8 @@ j_document.merge_patch(j_patch);
Supported types can be implicitly converted to JSON values.
It is recommended to **NOT USE** implicit conversions **FROM** a JSON value.
-You can find more details about this recommendation [here](https://www.github.com/nlohmann/json/issues/958).
+You can find more details about this recommendation [here](https://www.github.com/nlohmann/json/issues/958).
+You can switch off implicit conversions by defining `JSON_USE_IMPLICIT_CONVERSIONS` to `0` before including the `json.hpp` header. When using CMake, you can also achieve this by setting the option `JSON_ImplicitConversions` to `OFF`.
```cpp
// strings
@@ -869,6 +887,42 @@ Some important things:
* In function `from_json`, use function [`at()`](https://nlohmann.github.io/json/classnlohmann_1_1basic__json_a93403e803947b86f4da2d1fb3345cf2c.html#a93403e803947b86f4da2d1fb3345cf2c) to access the object values rather than `operator[]`. In case a key does not exist, `at` throws an exception that you can handle, whereas `operator[]` exhibits undefined behavior.
* You do not need to add serializers or deserializers for STL types like `std::vector`: the library already implements these.
+#### Simplify your life with macros
+
+If you just want to serialize/deserialize some structs, the `to_json`/`from_json` functions can be a lot of boilerplate.
+
+There are two macros to make your life easier as long as you (1) want to use a JSON object as serialization and (2) want to use the member variable names as object keys in that object:
+
+- `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(name, member1, member2, ...)` is to be defined inside of the namespace of the class/struct to create code for.
+- `NLOHMANN_DEFINE_TYPE_INTRUSIVE(name, member1, member2, ...)` is to be defined inside of the class/struct to create code for. This macro can also access private members.
+
+In both macros, the first parameter is the name of the class/struct, and all remaining parameters name the members.
+
+##### Examples
+
+The `to_json`/`from_json` functions for the `person` struct above can be created with:
+
+```cpp
+namespace ns {
+ NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person, name, address, age)
+}
+```
+
+Here is an example with private members, where `NLOHMANN_DEFINE_TYPE_INTRUSIVE` is needed:
+
+```cpp
+namespace ns {
+ class address {
+ private:
+ std::string street;
+ int housenumber;
+ int postcode;
+
+ public:
+ NLOHMANN_DEFINE_TYPE_INTRUSIVE(address, street, housenumber, postcode)
+ };
+}
+```
#### How do I convert third-party types?
@@ -1139,6 +1193,7 @@ Though it's 2020 already, the support for C++11 is still a bit sparse. Currently
- GCC 4.8 - 10.1 (and possibly later)
- Clang 3.4 - 10.0 (and possibly later)
+- Apple Clang 9.1 - 12.0 (and possibly later)
- Intel C++ Compiler 17.0.2 (and possibly later)
- Microsoft Visual C++ 2015 / Build Tools 14.0.25123.0 (and possibly later)
- Microsoft Visual C++ 2017 / Build Tools 15.5.180.51428 (and possibly later)
@@ -1174,6 +1229,7 @@ The following compilers are currently used in continuous integration at [Travis]
| Apple Clang 10.0.1 (clang-1001.0.46.4); Xcode 10.2.1 | macOS 10.14.4 | Travis |
| Apple Clang 11.0.0 (clang-1100.0.33.12); Xcode 11.2.1 | macOS 10.14.6 | Travis |
| Apple Clang 11.0.3 (clang-1103.0.32.59); Xcode 11.4.1 | macOS 10.15.4 | GitHub Actions |
+| Apple Clang 12.0.0 (clang-1200.0.22.7); Xcode 11.4.1 | macOS 10.15.5 | Travis |
| Clang 3.5.0 (3.5.0-4ubuntu2~trusty2) | Ubuntu 14.04.5 LTS | Travis |
| Clang 3.6.2 (3.6.2-svn240577-1~exp1) | Ubuntu 14.04.5 LTS | Travis |
| Clang 3.7.1 (3.7.1-svn253571-1~exp1) | Ubuntu 14.04.5 LTS | Travis |
@@ -1184,6 +1240,8 @@ The following compilers are currently used in continuous integration at [Travis]
| Clang 6.0.1 (6.0.1-svn334776-1~exp1~20190309042707.121) | Ubuntu 14.04.5 LTS | Travis |
| Clang 7.1.0 (7.1.0-svn353565-1~exp1~20190419134007.64) | Ubuntu 14.04.5 LTS | Travis |
| Clang 7.5.0 (Ubuntu 7.5.0-3ubuntu1~18.04) | Ubuntu 18.04.4 LTS | Travis |
+| Clang 9.0.0 (x86_64-pc-windows-msvc) | Windows-10.0.17763 | GitHub Actions |
+| Clang 10.0.0 (x86_64-pc-windows-msvc) | Windows-10.0.17763 | GitHub Actions |
| GCC 4.8.5 (Ubuntu 4.8.5-4ubuntu8~14.04.2) | Ubuntu 14.04.5 LTS | Travis |
| GCC 4.9.4 (Ubuntu 4.9.4-2ubuntu1~14.04.1) | Ubuntu 14.04.5 LTS | Travis |
| GCC 5.5.0 (Ubuntu 5.5.0-12ubuntu1~14.04) | Ubuntu 14.04.5 LTS | Travis |
@@ -1199,6 +1257,7 @@ The following compilers are currently used in continuous integration at [Travis]
| MSVC 19.16.27035.0 (15.9.21+g9802d43bc3 for .NET Framework) | Windows-10.0.14393 | AppVeyor |
| MSVC 19.25.28614.0 (Build Engine version 16.5.0+d4cbfca49 for .NET Framework) | Windows-10.0.17763 | AppVeyor |
| MSVC 19.25.28614.0 (Build Engine version 16.5.0+d4cbfca49 for .NET Framework) | Windows-10.0.17763 | GitHub Actions |
+| MSVC 19.25.28614.0 (Build Engine version 16.5.0+d4cbfca49 for .NET Framework) with ClangCL 10.0.0 | Windows-10.0.17763 | GitHub Actions |
## License
@@ -1452,6 +1511,17 @@ I deeply appreciate the help of the following people.
- [XyFreak](https://github.com/XyFreak) fixed a compiler warning.
- [TotalCaesar659](https://github.com/TotalCaesar659) fixed links in the README.
- [Tanuj Garg](https://github.com/tanuj208) improved the fuzzer coverage for UBSAN input.
+- [AODQ](https://github.com/AODQ) fixed a compiler warning.
+- [jwittbrodt](https://github.com/jwittbrodt) made `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE` inline.
+- [pfeatherstone](https://github.com/pfeatherstone) improved the upper bound of arguments of the `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`/`NLOHMANN_DEFINE_TYPE_INTRUSIVE` macros.
+- [Jan Procházka](https://github.com/jprochazk) fixed a bug in the CBOR parser for binary and string values.
+- [T0b1-iOS](https://github.com/T0b1-iOS) fixed a bug in the new hash implementation.
+- [Matthew Bauer](https://github.com/matthewbauer) adjusted the CBOR writer to create tags for binary subtypes.
+- [gatopeich](https://github.com/gatopeich) implemented an ordered map container for `nlohmann::ordered_json`.
+- [Érico Nogueira Rolim](https://github.com/ericonr) added support for pkg-config.
+- [KonanM](https://github.com/KonanM) proposed an implementation for the `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`/`NLOHMANN_DEFINE_TYPE_INTRUSIVE` macros.
+- [Guillaume Racicot](https://github.com/gracicot) implemented `string_view` support and allowed C++20 support.
+- [Alex Reinking](https://github.com/alexreinking) improved CMake support for `FetchContent`.
Thanks a lot for helping out! Please [let me know](mailto:mail@nlohmann.me) if I forgot someone.
@@ -1508,39 +1578,37 @@ The library supports **Unicode input** as follows:
### Comments in JSON
-This library does not support comments. It does so for three reasons:
+This library does not support comments by default. It does so for three reasons:
1. Comments are not part of the [JSON specification](https://tools.ietf.org/html/rfc8259). You may argue that `//` or `/* */` are allowed in JavaScript, but JSON is not JavaScript.
2. This was not an oversight: Douglas Crockford [wrote on this](https://plus.google.com/118095276221607585885/posts/RK8qyGVaGSr) in May 2012:
- > I removed comments from JSON because I saw people were using them to hold parsing directives, a practice which would have destroyed interoperability. I know that the lack of comments makes some people sad, but it shouldn't.
+ > I removed comments from JSON because I saw people were using them to hold parsing directives, a practice which would have destroyed interoperability. I know that the lack of comments makes some people sad, but it shouldn't.
> Suppose you are using JSON to keep configuration files, which you would like to annotate. Go ahead and insert all the comments you like. Then pipe it through JSMin before handing it to your JSON parser.
3. It is dangerous for interoperability if some libraries would add comment support while others don't. Please check [The Harmful Consequences of the Robustness Principle](https://tools.ietf.org/html/draft-iab-protocol-maintenance-01) on this.
-This library will not support comments in the future. If you wish to use comments, I see three options:
-
-1. Strip comments before using this library.
-2. Use a different JSON library with comment support.
-3. Use a format that natively supports comments (e.g., YAML or JSON5).
+However, you can pass set parameter `ignore_comments` to true in the `parse` function to ignore `//` or `/* */` comments. Comments will then be treated as whitespace.
### Order of object keys
-By default, the library does not preserve the **insertion order of object elements**. This is standards-compliant, as the [JSON standard](https://tools.ietf.org/html/rfc8259.html) defines objects as "an unordered collection of zero or more name/value pairs". If you do want to preserve the insertion order, you can specialize the object type with containers like [`tsl::ordered_map`](https://github.com/Tessil/ordered-map) ([integration](https://github.com/nlohmann/json/issues/546#issuecomment-304447518)) or [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map) ([integration](https://github.com/nlohmann/json/issues/485#issuecomment-333652309)).
+By default, the library does not preserve the **insertion order of object elements**. This is standards-compliant, as the [JSON standard](https://tools.ietf.org/html/rfc8259.html) defines objects as "an unordered collection of zero or more name/value pairs".
+
+If you do want to preserve the insertion order, you can try the type [`nlohmann::ordered_json`](https://github.com/nlohmann/json/issues/2179). Alternatively, you can use a more sophisticated ordered map like [`tsl::ordered_map`](https://github.com/Tessil/ordered-map) ([integration](https://github.com/nlohmann/json/issues/546#issuecomment-304447518)) or [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map) ([integration](https://github.com/nlohmann/json/issues/485#issuecomment-333652309)).
### Memory Release
-We checked with Valgrind and the Address Sanitizer (ASAN) that there are no memory leaks.
+We checked with Valgrind and the Address Sanitizer (ASAN) that there are no memory leaks.
-If you find that a parsing program with this library does not release memory, please consider the following case and it maybe unrelated to this library.
+If you find that a parsing program with this library does not release memory, please consider the following case and it maybe unrelated to this library.
**Your program is compiled with glibc.** There is a tunable threshold that glibc uses to decide whether to actually return memory to the system or whether to cache it for later reuse. If in your program you make lots of small allocations and those small allocations are not a contiguous block and are presumably below the threshold, then they will not get returned to the OS.
Here is a related issue [#1924](https://github.com/nlohmann/json/issues/1924).
### Further notes
-- The code contains numerous debug **assertions** which can be switched off by defining the preprocessor macro `NDEBUG`, see the [documentation of `assert`](https://en.cppreference.com/w/cpp/error/assert). In particular, note [`operator[]`](https://nlohmann.github.io/json/classnlohmann_1_1basic__json_a233b02b0839ef798942dd46157cc0fe6.html#a233b02b0839ef798942dd46157cc0fe6) implements **unchecked access** for const objects: If the given key is not present, the behavior is undefined (think of a dereferenced null pointer) and yields an [assertion failure](https://github.com/nlohmann/json/issues/289) if assertions are switched on. If you are not sure whether an element in an object exists, use checked access with the [`at()` function](https://nlohmann.github.io/json/classnlohmann_1_1basic__json_a73ae333487310e3302135189ce8ff5d8.html#a73ae333487310e3302135189ce8ff5d8).
+- The code contains numerous debug **assertions** which can be switched off by defining the preprocessor macro `NDEBUG`, see the [documentation of `assert`](https://en.cppreference.com/w/cpp/error/assert). In particular, note [`operator[]`](https://nlohmann.github.io/json/classnlohmann_1_1basic__json_a233b02b0839ef798942dd46157cc0fe6.html#a233b02b0839ef798942dd46157cc0fe6) implements **unchecked access** for const objects: If the given key is not present, the behavior is undefined (think of a dereferenced null pointer) and yields an [assertion failure](https://github.com/nlohmann/json/issues/289) if assertions are switched on. If you are not sure whether an element in an object exists, use checked access with the [`at()` function](https://nlohmann.github.io/json/classnlohmann_1_1basic__json_a73ae333487310e3302135189ce8ff5d8.html#a73ae333487310e3302135189ce8ff5d8). Furthermore, you can define `JSON_ASSERT(x)` to replace calls to `assert(x)`.
- As the exact type of a number is not defined in the [JSON specification](https://tools.ietf.org/html/rfc8259.html), this library tries to choose the best fitting C++ number type automatically. As a result, the type `double` may be used to store numbers which may yield [**floating-point exceptions**](https://github.com/nlohmann/json/issues/181) in certain rare situations if floating-point exceptions have been unmasked in the calling code. These exceptions are not caused by the library and need to be fixed in the calling code, such as by re-masking the exceptions prior to calling library functions.
- The code can be compiled without C++ **runtime type identification** features; that is, you can use the `-fno-rtti` compiler flag.
- **Exceptions** are used widely within the library. They can, however, be switched off with either using the compiler flag `-fno-exceptions` or by defining the symbol `JSON_NOEXCEPTION`. In this case, exceptions are replaced by `abort()` calls. You can further control this behavior by defining `JSON_THROW_USER´` (overriding `throw`), `JSON_TRY_USER` (overriding `try`), and `JSON_CATCH_USER` (overriding `catch`). Note that `JSON_THROW_USER` should leave the current scope (e.g., by throwing or aborting), as continuing after it may yield undefined behavior.
@@ -1557,4 +1625,6 @@ $ cmake --build .
$ ctest --output-on-failure
```
-For more information, have a look at the file [.travis.yml](https://github.com/nlohmann/json/blob/master/.travis.yml).
+Note that during the `ctest` stage, several JSON test files are downloaded from an [external repository](https://github.com/nlohmann/json_test_data). If policies forbid downloading artifacts during testing, you can download the files yourself and pass the directory with the test files via `-DJSON_TestDataDirectory=path` to CMake. Then, no Internet connectivity is required. See [issue #2189](https://github.com/nlohmann/json/issues/2189) for more information.
+
+In case you have downloaded the library rather than checked out the code via Git, test `cmake_fetch_content_configure`. Please execute `ctest -LE git_required` to skip these tests. See [issue #2189](https://github.com/nlohmann/json/issues/2189) for more information.
diff --git a/appveyor.yml b/appveyor.yml
index 73788956..5836f88d 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -7,6 +7,7 @@ environment:
platform: x86
CXX_FLAGS: ""
LINKER_FLAGS: ""
+ CMAKE_OPTIONS: ""
GENERATOR: Visual Studio 14 2015
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
@@ -14,6 +15,7 @@ environment:
platform: x86
CXX_FLAGS: ""
LINKER_FLAGS: ""
+ CMAKE_OPTIONS: ""
GENERATOR: Visual Studio 15 2017
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -21,6 +23,7 @@ environment:
platform: x86
CXX_FLAGS: ""
LINKER_FLAGS: ""
+ CMAKE_OPTIONS: ""
GENERATOR: Visual Studio 16 2019
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -28,6 +31,7 @@ environment:
platform: x64
CXX_FLAGS: ""
LINKER_FLAGS: ""
+ CMAKE_OPTIONS: ""
GENERATOR: Visual Studio 16 2019
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -36,6 +40,7 @@ environment:
platform: x86
CXX_FLAGS: ""
LINKER_FLAGS: ""
+ CMAKE_OPTIONS: ""
GENERATOR: Ninja
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -44,6 +49,7 @@ environment:
platform: x86
CXX_FLAGS: ""
LINKER_FLAGS: ""
+ CMAKE_OPTIONS: ""
GENERATOR: Ninja
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -51,6 +57,7 @@ environment:
platform: x86
CXX_FLAGS: ""
LINKER_FLAGS: ""
+ CMAKE_OPTIONS: ""
GENERATOR: Visual Studio 14 2015
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -59,6 +66,7 @@ environment:
name: with_win_header
CXX_FLAGS: ""
LINKER_FLAGS: ""
+ CMAKE_OPTIONS: ""
GENERATOR: Visual Studio 14 2015
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
@@ -66,6 +74,7 @@ environment:
platform: x86
CXX_FLAGS: "/permissive- /std:c++latest /utf-8"
LINKER_FLAGS: ""
+ CMAKE_OPTIONS: ""
GENERATOR: Visual Studio 15 2017
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -73,6 +82,15 @@ environment:
platform: x86
CXX_FLAGS: ""
LINKER_FLAGS: ""
+ CMAKE_OPTIONS: "-DJSON_ImplicitConversions=OFF"
+ GENERATOR: Visual Studio 16 2019
+
+ - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+ configuration: Release
+ platform: x64
+ CXX_FLAGS: ""
+ LINKER_FLAGS: ""
+ CMAKE_OPTIONS: ""
GENERATOR: Visual Studio 16 2019
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -80,6 +98,7 @@ environment:
platform: x64
CXX_FLAGS: ""
LINKER_FLAGS: ""
+ CMAKE_OPTIONS: ""
GENERATOR: Visual Studio 14 2015
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
@@ -87,6 +106,7 @@ environment:
platform: x64
CXX_FLAGS: "/permissive- /std:c++latest /Zc:__cplusplus /utf-8 /F4000000"
LINKER_FLAGS: "/STACK:4000000"
+ CMAKE_OPTIONS: ""
GENERATOR: Visual Studio 15 2017
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -94,6 +114,7 @@ environment:
platform: x64
CXX_FLAGS: ""
LINKER_FLAGS: ""
+ CMAKE_OPTIONS: ""
GENERATOR: Visual Studio 16 2019
init:
@@ -112,7 +133,7 @@ before_build:
# for with_win_header build, inject the inclusion of Windows.h to the single-header library
- ps: if ($env:name -Eq "with_win_header") { $header_path = "single_include\nlohmann\json.hpp" }
- ps: if ($env:name -Eq "with_win_header") { "#include <Windows.h>`n" + (Get-Content $header_path | Out-String) | Set-Content $header_path }
- - if "%GENERATOR%"=="Ninja" (cmake . -G "%GENERATOR%" -DCMAKE_BUILD_TYPE="%configuration%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_EXE_LINKER_FLAGS="%LINKER_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On) else (cmake . -G "%GENERATOR%" -A "%GENERATOR_PLATFORM%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_EXE_LINKER_FLAGS="%LINKER_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On)
+ - if "%GENERATOR%"=="Ninja" (cmake . -G "%GENERATOR%" -DCMAKE_BUILD_TYPE="%configuration%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_EXE_LINKER_FLAGS="%LINKER_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On "%CMAKE_OPTIONS%") else (cmake . -G "%GENERATOR%" -A "%GENERATOR_PLATFORM%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_EXE_LINKER_FLAGS="%LINKER_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On "%CMAKE_OPTIONS%")
build_script:
- cmake --build . --config "%configuration%"
diff --git a/cmake/download_test_data.cmake b/cmake/download_test_data.cmake
index fe95235f..a3f3f199 100644
--- a/cmake/download_test_data.cmake
+++ b/cmake/download_test_data.cmake
@@ -1,17 +1,22 @@
-find_package(Git)
-
set(JSON_TEST_DATA_URL https://github.com/nlohmann/json_test_data)
-set(JSON_TEST_DATA_VERSION 2.0.0)
+set(JSON_TEST_DATA_VERSION 3.0.0)
-# target to download test data
-add_custom_target(download_test_data
- COMMAND test -d json_test_data || ${GIT_EXECUTABLE} clone -c advice.detachedHead=false --branch v${JSON_TEST_DATA_VERSION} ${JSON_TEST_DATA_URL}.git --quiet --depth 1
- COMMENT "Downloading test data from ${JSON_TEST_DATA_URL} (v${JSON_TEST_DATA_VERSION})"
- WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-)
-
-# create a header with the path to the downloaded test data
-file(WRITE ${CMAKE_BINARY_DIR}/include/test_data.hpp "#define TEST_DATA_DIRECTORY \"${CMAKE_BINARY_DIR}/json_test_data\"\n")
+# if variable is set, use test data from given directory rather than downloading them
+if(JSON_TestDataDirectory)
+ message(STATUS "Using test data in ${JSON_TestDataDirectory}.")
+ add_custom_target(download_test_data)
+ file(WRITE ${CMAKE_BINARY_DIR}/include/test_data.hpp "#define TEST_DATA_DIRECTORY \"${JSON_TestDataDirectory}\"\n")
+else()
+ find_package(Git)
+ # target to download test data
+ add_custom_target(download_test_data
+ COMMAND test -d json_test_data || ${GIT_EXECUTABLE} clone -c advice.detachedHead=false --branch v${JSON_TEST_DATA_VERSION} ${JSON_TEST_DATA_URL}.git --quiet --depth 1
+ COMMENT "Downloading test data from ${JSON_TEST_DATA_URL} (v${JSON_TEST_DATA_VERSION})"
+ WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+ )
+ # create a header with the path to the downloaded test data
+ file(WRITE ${CMAKE_BINARY_DIR}/include/test_data.hpp "#define TEST_DATA_DIRECTORY \"${CMAKE_BINARY_DIR}/json_test_data\"\n")
+endif()
# determine the operating system (for debug and support purposes)
find_program(UNAME_COMMAND uname)
diff --git a/cmake/pkg-config.pc.in b/cmake/pkg-config.pc.in
new file mode 100644
index 00000000..3541abf0
--- /dev/null
+++ b/cmake/pkg-config.pc.in
@@ -0,0 +1,4 @@
+Name: ${PROJECT_NAME}
+Description: JSON for Modern C++
+Version: ${PROJECT_VERSION}
+Cflags: -I${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}
diff --git a/doc/Doxyfile b/doc/Doxyfile
index 56a41d13..e6207fb0 100644
--- a/doc/Doxyfile
+++ b/doc/Doxyfile
@@ -5,7 +5,7 @@
#---------------------------------------------------------------------------
DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = "JSON for Modern C++"
-PROJECT_NUMBER = 3.8.0
+PROJECT_NUMBER = 3.9.0
PROJECT_BRIEF =
PROJECT_LOGO =
OUTPUT_DIRECTORY = .
diff --git a/doc/Makefile b/doc/Makefile
index 07e417c1..35e8b5aa 100644
--- a/doc/Makefile
+++ b/doc/Makefile
@@ -43,7 +43,7 @@ check_output: $(EXAMPLES:.cpp=.test)
clean:
- rm -fr me.nlohmann.json.docset html $(EXAMPLES:.cpp=)
+ rm -fr me.nlohmann.json.docset html xml $(EXAMPLES:.cpp=)
##########################################################################
diff --git a/doc/avatars.png b/doc/avatars.png
index d21ddc54..e3c29989 100644
Binary files a/doc/avatars.png and b/doc/avatars.png differ
diff --git a/doc/examples/README.link b/doc/examples/README.link
index 0589c59d..786b27be 100644
--- a/doc/examples/README.link
+++ b/doc/examples/README.link
@@ -1 +1 @@
-<a target="_blank" href="https://wandbox.org/permlink/EezQxM0Nzi8tTUEe"><b>online</b></a>
\ No newline at end of file
+<a target="_blank" href="https://wandbox.org/permlink/shE8T6phAQiEzAad"><b>online</b></a>
\ No newline at end of file
diff --git a/doc/examples/meta.output b/doc/examples/meta.output
index aa47599b..ffadccbe 100644
--- a/doc/examples/meta.output
+++ b/doc/examples/meta.output
@@ -2,16 +2,16 @@
"compiler": {
"c++": "201103",
"family": "clang",
- "version": "11.0.3 (clang-1103.0.32.62)"
+ "version": "12.0.0 (clang-1200.0.22.19)"
},
- "copyright": "(C) 2013-2017 Niels Lohmann",
+ "copyright": "(C) 2013-2020 Niels Lohmann",
"name": "JSON for Modern C++",
"platform": "apple",
"url": "https://github.com/nlohmann/json",
"version": {
"major": 3,
- "minor": 8,
+ "minor": 9,
"patch": 0,
- "string": "3.8.0"
+ "string": "3.9.0"
}
}
diff --git a/doc/index.md b/doc/index.md
index fd5cf88d..e990e7a3 100644
--- a/doc/index.md
+++ b/doc/index.md
@@ -332,4 +332,4 @@ Note that this table only lists those exceptions thrown due to the type. For ins
@author [Niels Lohmann](http://nlohmann.me)
@see https://github.com/nlohmann/json to download the source code
-@version 3.8.0
+@version 3.9.0
diff --git a/doc/json.gif b/doc/json.gif
index c9557b91..d3dfb91c 100644
Binary files a/doc/json.gif and b/doc/json.gif differ
diff --git a/doc/mkdocs/docs/api/basic_json/dump.md b/doc/mkdocs/docs/api/basic_json/dump.md
new file mode 100644
index 00000000..9ea6e356
--- /dev/null
+++ b/doc/mkdocs/docs/api/basic_json/dump.md
@@ -0,0 +1,74 @@
+# basic_json::dump
+
+```cpp
+string_t dump(const int indent = -1,
+ const char indent_char = ' ',
+ const bool ensure_ascii = false,
+ const error_handler_t error_handler = error_handler_t::strict) const
+```
+
+Serialization function for JSON values. The function tries to mimic
+Python's `json.dumps()` function, and currently supports its `indent`
+and `ensure_ascii` parameters.
+
+## Parameters
+
+`indent` (in)
+: If `indent` is nonnegative, then array elements and object
+ members will be pretty-printed with that indent level. An indent level of
+ `0` will only insert newlines. `-1` (the default) selects the most compact
+ representation.
+
+`indent_char` (in)
+: The character to use for indentation if `indent` is
+ greater than `0`. The default is ` ` (space).
+
+`ensure_ascii` (in)
+: If `ensure_ascii` is true, all non-ASCII characters
+ in the output are escaped with `\uXXXX` sequences, and the result consists
+ of ASCII characters only.
+
+`error_handler` (in)
+: how to react on decoding errors; there are three
+ possible values: `strict` (throws and exception in case a decoding error
+ occurs; default), `replace` (replace invalid UTF-8 sequences with U+FFFD),
+ and `ignore` (ignore invalid UTF-8 sequences during serialization; all
+ bytes are copied to the output unchanged).
+
+## Return value
+
+string containing the serialization of the JSON value
+
+## Exception safety
+
+Strong guarantee: if an exception is thrown, there are no
+changes to any JSON value.
+
+## Complexity
+
+Linear.
+
+## Notes
+
+Binary values are serialized as object containing two keys:
+
+- "bytes": an array of bytes as integers
+- "subtype": the subtype as integer or `#!json null` if the binary has no subtype
+
+## Example
+
+??? example
+
+ The following example shows the effect of different `indent`,
+ `indent_char`, and `ensure_ascii` parameters to the result of the
+ serialization.
+
+ ```cpp
+ --8<-- "examples/dump.cpp"
+ ```
+
+ Output:
+
+ ```json
+ --8<-- "examples/dump.output"
+ ```
diff --git a/doc/mkdocs/docs/api/basic_json/index.md b/doc/mkdocs/docs/api/basic_json/index.md
new file mode 100644
index 00000000..496cd68b
--- /dev/null
+++ b/doc/mkdocs/docs/api/basic_json/index.md
@@ -0,0 +1,253 @@
+# basic_json
+
+!!! note
+
+ This page is under construction.
+
+Defined in header `<json.hpp>`
+
+```cpp
+template<template<typename, typename, typename...> class ObjectType,
+ template<typename, typename...> class ArrayType,
+ class StringType, class BooleanType, class NumberIntegerType,
+ class NumberUnsignedType, class NumberFloatType,
+ template<typename> class AllocatorType,
+ template<typename, typename = void> class JSONSerializer,
+ class BinaryType>
+class basic_json
+```
+
+## Specializations
+
+- json
+- ordered_json
+
+## Template parameters
+
+- ObjectType
+- ArrayType
+- StringType
+- BooleanType
+- NumberIntegerType
+- NumberUnsignedType
+- NumberFloatType
+- AllocatorType
+- JSONSerializer
+- BinaryType
+
+## Iterator invalidation
+
+## Member types
+
+- value_t
+- json_pointer
+- json_serializer
+- error_handler_t
+- cbor_tag_handler_t
+- initializer_list_t
+- input_format_t
+- json_sax_t
+
+### Exceptions
+
+- exception
+- parse_error
+- invalid_iterator
+- type_error
+- out_of_range
+- other_error
+
+### Container types
+
+- value_type
+- reference
+- const_reference
+- difference_type
+- size_type
+- allocator_type
+- pointer
+- const_pointer
+- iterator
+- const_iterator
+- reverse_iterator
+- const_reverse_iterator
+
+### JSON value data types
+
+- object_comparator_t
+- object_t
+- array_t
+- string_t
+- boolean_t
+- number_integer_t
+- number_unsigned_t
+- number_float_t
+- binary_t
+
+### Parser callback
+
+- parse_event_t
+- parser_callback_t
+
+## Member functions
+
+- (constructor)
+- (destructor)
+- binary (static) - explicitly create a binary array
+- array (static) - explicitly create an array
+- object (static) - explicitly create an object
+- operator= - copy assignment
+
+### Object inspection
+
+Functions to inspect the type of a JSON value.
+
+- type - return the type of the JSON value
+- is_primitive - return whether type is primitive
+- is_structured - return whether type is structured
+- is_null - return whether value is null
+- is_boolean - return whether value is a boolean
+- is_number - return whether value is a number
+- is_number_integer - return whether value is an integer number
+- is_number_unsigned - return whether value is an unsigned integer number
+- is_number_float - return whether value is a floating-point number
+- is_object - return whether value is an object
+- is_array - return whether value is an array
+- is_string - return whether value is a string
+- is_binary - return whether value is a binary array
+- is_discarded - return whether value is discarded
+- operator value_t - return the type of the JSON value
+
+### Value access
+
+Direct access to the stored value of a JSON value.
+
+- get - get a value
+- get_to - get a value
+- get_ptr - get a pointer value
+- get_ref - get a reference value
+- operator ValueType - get a value
+- get_binary - get a binary value
+
+### Element access
+
+Access to the JSON value
+
+- at - access specified array element with bounds checking
+- at - access specified object element with bounds checking
+- operator[] - access specified array element
+- operator[] - access specified object element
+- value - access specified object element with default value
+- front - access the first element
+- back - access the last element
+- erase - remove elements
+
+### Lookup
+
+- find - find an element in a JSON object
+- count - returns the number of occurrences of a key in a JSON object
+- contains - check the existence of an element in a JSON object
+
+### Iterators
+
+- begin - returns an iterator to the first element
+- cbegin - returns a const iterator to the first element
+- end - returns an iterator to one past the last element
+- cend - returns a const iterator to one past the last element
+- rbegin - returns an iterator to the reverse-beginning
+- rend - returns an iterator to the reverse-end
+- crbegin - returns a const iterator to the reverse-beginning
+- crend - returns a const iterator to the reverse-end
+- items - wrapper to access iterator member functions in range-based for
+
+### Capacity
+
+- empty - checks whether the container is empty
+- size - returns the number of elements
+- max_size - returns the maximum possible number of elements
+
+### Modifiers
+
+- clear - clears the contents
+- push_back - add an object to an array
+- operator+= - add an object to an array
+- push_back - add an object to an object
+- operator+= - add an object to an object
+- emplace_back - add an object to an array
+- emplace - add an object to an object if key does not exist
+- insert - inserts element
+- update - updates a JSON object from another object, overwriting existing keys
+- swap - exchanges the values
+
+### Lexicographical comparison operators
+
+- operator== - comparison: equal
+- operator!= - comparison: not equal
+- operator< - comparison: less than
+- operator<= - comparison: less than or equal
+- operator> - comparison: greater than
+- operator>= - comparison: greater than or equal
+
+### Serialization
+
+- [**dump**](dump.md) - serialization
+- to_string - user-defined to_string function for JSON values
+
+### Deserialization
+
+- [**parse**](parse.md) - deserialize from a compatible input
+- accept - check if the input is valid JSON
+- sax_parse - generate SAX events
+
+### Convenience functions
+
+- type_name - return the type as string
+
+### JSON Pointer functions
+
+- at - access specified object element with bounds checking via JSON Pointer
+- operator[] - access specified element via JSON Pointer
+- value - access specified object element with default value via JSON Pointer
+- flatten - return flattened JSON value
+- unflatten - unflatten a previously flattened JSON value
+
+### JSON Patch functions
+
+- patch - applies a JSON patch
+- diff (static) - creates a diff as a JSON patch
+
+### JSON Merge Patch functions
+
+- merge_patch - applies a JSON Merge Patch
+
+## Static functions
+
+- [**meta**](meta.md) - returns version information on the library
+- get_allocator - returns the allocator associated with the container
+
+### Binary formats
+
+- to_cbor - create a CBOR serialization of a given JSON value
+- to_msgpack - create a MessagePack serialization of a given JSON value
+- to_ubjson - create a UBJSON serialization of a given JSON value
+- to_bson - create a BSON serialization of a given JSON value
+- from_cbor - create a JSON value from an input in CBOR format
+- from_msgpack - create a JSON value from an input in MessagePack format
+- from_ubjson - create a JSON value from an input in UBJSON format
+- from_bson - create a JSON value from an input in BSON format
+
+## Non-member functions
+
+- operator<<(std::ostream&) - serialize to stream
+- operator>>(std::istream&) - deserialize from stream
+
+## Literals
+
+- operator""_json
+- operator""_json_pointer
+
+## Helper classes
+
+- std::hash<nlohmann::json\>
+- std::less<nlohmann::value_t\>
+- std::swap<nlohmann::json\>
diff --git a/doc/mkdocs/docs/api/basic_json/meta.md b/doc/mkdocs/docs/api/basic_json/meta.md
new file mode 100644
index 00000000..fd577545
--- /dev/null
+++ b/doc/mkdocs/docs/api/basic_json/meta.md
@@ -0,0 +1,45 @@
+# basic_json::meta
+
+```cpp
+static basic_json meta();
+```
+
+This function returns a JSON object with information about the library,
+including the version number and information on the platform and compiler.
+
+## Return value
+
+JSON object holding version information
+
+key | description
+----------- | ---------------
+`compiler` | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version).
+`copyright` | The copyright line for the library as string.
+`name` | The name of the library as string.
+`platform` | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.
+`url` | The URL of the project as string.
+`version` | The version of the library. It is an object with the following keys: `major`, `minor`, and `patch` as defined by [Semantic Versioning](http://semver.org), and `string` (the version string).
+
+## Exception safety
+
+Strong guarantee: if an exception is thrown, there are no
+changes to any JSON value.
+
+## Complexity
+
+Constant.
+
+## Example
+
+The following code shows an example output of the `meta()`
+function.
+
+```cpp
+--8<-- "examples/meta.cpp"
+```
+
+Output:
+
+```json
+--8<-- "examples/meta.output"
+```
diff --git a/doc/mkdocs/docs/api/basic_json/parse.md b/doc/mkdocs/docs/api/basic_json/parse.md
new file mode 100644
index 00000000..f89df426
--- /dev/null
+++ b/doc/mkdocs/docs/api/basic_json/parse.md
@@ -0,0 +1,146 @@
+# basic_json::parse
+
+```cpp
+// (1)
+template<typename InputType>
+static basic_json parse(InputType&& i,
+ const parser_callback_t cb = nullptr,
+ const bool allow_exceptions = true,
+ const bool ignore_comments = false)
+
+// (2)
+template<typename IteratorType>
+static basic_json parse(IteratorType first,
+ IteratorType last,
+ const parser_callback_t cb = nullptr,
+ const bool allow_exceptions = true,
+ const bool ignore_comments = false)
+```
+
+1. Deserialize from a compatible input.
+2. Deserialize from a pair of character iterators
+
+ The value_type of the iterator must be a integral type with size of 1, 2 or
+ 4 bytes, which will be interpreted respectively as UTF-8, UTF-16 and UTF-32.
+
+## Template parameters
+
+`InputType`
+: A compatible input, for instance:
+
+ - an `std::istream` object
+ - a `FILE` pointer
+ - a C-style array of characters
+ - a pointer to a null-terminated string of single byte characters
+ - an object `obj` for which `begin(obj)` and `end(obj)` produces a valid pair of
+ iterators.
+
+`IteratorType`
+: Description
+
+## Parameters
+
+`i` (in)
+: Input to parse from.
+
+`cb` (in)
+: a parser callback function of type `parser_callback_t`
+ which is used to control the deserialization by filtering unwanted values
+ (optional)
+
+`allow_exceptions` (in)
+: whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)
+
+`ignore_comments` (in)
+: whether comments should be ignored and treated
+ like whitespace (`#!cpp true`) or yield a parse error (`#!cpp false`); (optional, `#!cpp false` by
+ default)
+
+`first` (in)
+: iterator to start of character range
+
+`last` (in)
+: iterator to end of character range
+
+## Return value
+
+Deserialized JSON value; in case of a parse error and `allow_exceptions`
+set to `#!cpp false`, the return value will be `value_t::discarded`.
+
+## Exception safety
+
+## Complexity
+
+Linear in the length of the input. The parser is a predictive
+LL(1) parser. The complexity can be higher if the parser callback function
+`cb` or reading from (1) the input `i` or (2) the iterator range [`first`, `last`] has a super-linear complexity.
+
+## Notes
+
+(1) A UTF-8 byte order mark is silently ignored.
+
+## Examples
+
+??? example
+
+ The example below demonstrates the `parse()` function reading
+ from an array.
+
+ ```cpp
+ --8<-- "examples/parse__array__parser_callback_t.cpp"
+ ```
+
+ Output:
+
+ ```json
+ --8<-- "examples/parse__array__parser_callback_t.output"
+ ```
+
+??? example
+
+ The example below demonstrates the `parse()` function with
+ and without callback function.
+
+ ```cpp
+ --8<-- "examples/parse__string__parser_callback_t.cpp"
+ ```
+
+ Output:
+
+ ```json
+ --8<-- "examples/parse__string__parser_callback_t.output"
+ ```
+
+??? example
+
+ The example below demonstrates the `parse()` function with
+ and without callback function.
+
+ ```cpp
+ --8<-- "examples/parse__istream__parser_callback_t.cpp"
+ ```
+
+ Output:
+
+ ```json
+ --8<-- "examples/parse__istream__parser_callback_t.output"
+ ```
+
+??? example
+
+ The example below demonstrates the `parse()` function reading
+ from a contiguous container.
+
+ ```cpp
+ --8<-- "examples/parse__contiguouscontainer__parser_callback_t.cpp"
+ ```
+
+ Output:
+
+ ```json
+ --8<-- "examples/parse__contiguouscontainer__parser_callback_t.output"
+ ```
+
+## History
+
+(1) version 2.0.3 (contiguous containers); version 3.9.0 allowed to ignore comments.
diff --git a/doc/mkdocs/docs/features/arbitrary_types.md b/doc/mkdocs/docs/features/arbitrary_types.md
index 3d238317..23913bba 100644
--- a/doc/mkdocs/docs/features/arbitrary_types.md
+++ b/doc/mkdocs/docs/features/arbitrary_types.md
@@ -81,6 +81,47 @@ Some important things:
* You do not need to add serializers or deserializers for STL types like `std::vector`: the library already implements these.
+## Simplify your life with macros
+
+If you just want to serialize/deserialize some structs, the `to_json`/`from_json` functions can be a lot of boilerplate.
+
+There are two macros to make your life easier as long as you (1) want to use a JSON object as serialization and (2) want to use the member variable names as object keys in that object:
+
+- `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(name, member1, member2, ...)` is to be defined inside of the namespace of the class/struct to create code for.
+- `NLOHMANN_DEFINE_TYPE_INTRUSIVE(name, member1, member2, ...)` is to be defined inside of the class/struct to create code for. This macro can also access private members.
+
+In both macros, the first parameter is the name of the class/struct, and all remaining parameters name the members.
+
+!!! note
+
+ At most 64 member variables can be passed to `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE` or `NLOHMANN_DEFINE_TYPE_INTRUSIVE`.
+
+??? example
+
+ The `to_json`/`from_json` functions for the `person` struct above can be created with:
+
+ ```cpp
+ namespace ns {
+ NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person, name, address, age)
+ }
+ ```
+
+ Here is an example with private members, where `NLOHMANN_DEFINE_TYPE_INTRUSIVE` is needed:
+
+ ```cpp
+ namespace ns {
+ class address {
+ private:
+ std::string street;
+ int housenumber;
+ int postcode;
+
+ public:
+ NLOHMANN_DEFINE_TYPE_INTRUSIVE(address, street, housenumber, postcode)
+ };
+ }
+ ```
+
## How do I convert third-party types?
This requires a bit more advanced technique. But first, let's see how this conversion mechanism works:
diff --git a/doc/mkdocs/docs/features/binary_formats/cbor.md b/doc/mkdocs/docs/features/binary_formats/cbor.md
index daea3a51..daa29be8 100644
--- a/doc/mkdocs/docs/features/binary_formats/cbor.md
+++ b/doc/mkdocs/docs/features/binary_formats/cbor.md
@@ -64,7 +64,6 @@ binary | *size*: 4294967296..18446744073709551615 | byte string (8 by
If NaN or Infinity are stored inside a JSON number, they are serialized properly. This behavior differs from the normal JSON serialization which serializes NaN or Infinity to `null`.
-
!!! info "Unused CBOR types"
The following CBOR types are not used in the conversion:
@@ -77,13 +76,16 @@ binary | *size*: 4294967296..18446744073709551615 | byte string (8 by
- bignum (0xC2..0xC3)
- decimal fraction (0xC4)
- bigfloat (0xC5)
- - tagged items (0xC6..0xD4, 0xD8..0xDB)
- expected conversions (0xD5..0xD7)
- simple values (0xE0..0xF3, 0xF8)
- undefined (0xF7)
- half-precision floats (0xF9)
- break (0xFF)
+!!! info "Tagged items"
+
+ Binary subtypes will be serialized as tagged items. See [binary values](../binary_values.md#cbor) for an example.
+
??? example
```cpp
@@ -150,7 +152,6 @@ Double-Precision Float | number_float | 0xFB
- bignum (0xC2..0xC3)
- decimal fraction (0xC4)
- bigfloat (0xC5)
- - tagged items (0xC6..0xD4, 0xD8..0xDB)
- expected conversions (0xD5..0xD7)
- simple values (0xE0..0xF3, 0xF8)
- undefined (0xF7)
@@ -159,6 +160,10 @@ Double-Precision Float | number_float | 0xFB
CBOR allows map keys of any type, whereas JSON only allows strings as keys in object values. Therefore, CBOR maps with keys other than UTF-8 strings are rejected.
+!!! warning "Tagged items"
+
+ Tagged items will throw a parse error by default. However, they can be ignored by passing `cbor_tag_handler_t::ignore` to function `from_cbor`.
+
??? example
```cpp
diff --git a/doc/mkdocs/docs/features/binary_formats/messagepack.md b/doc/mkdocs/docs/features/binary_formats/messagepack.md
index ed061056..3e041bb7 100644
--- a/doc/mkdocs/docs/features/binary_formats/messagepack.md
+++ b/doc/mkdocs/docs/features/binary_formats/messagepack.md
@@ -31,7 +31,8 @@ number_unsigned | 128..255 | uint 8 | 0xCC
number_unsigned | 256..65535 | uint 16 | 0xCD
number_unsigned | 65536..4294967295 | uint 32 | 0xCE
number_unsigned | 4294967296..18446744073709551615 | uint 64 | 0xCF
-number_float | *any value* | float 64 | 0xCB
+number_float | *any value representable by a float* | float 32 | 0xCA
+number_float | *any value NOT representable by a float* | float 64 | 0xCB
string | *length*: 0..31 | fixstr | 0xA0..0xBF
string | *length*: 32..255 | str 8 | 0xD9
string | *length*: 256..65535 | str 16 | 0xDA
@@ -61,10 +62,6 @@ binary | *size*: 65536..4294967295 | bin 32 | 0xC6
- arrays with more than 4294967295 elements
- objects with more than 4294967295 elements
-!!! info "Unused MessagePack types"
-
- The following MessagePack types are not used in the conversion: float 32 (0xCA)
-
!!! info "NaN/infinity handling"
If NaN or Infinity are stored inside a JSON number, they are serialized properly. function which serializes NaN or Infinity to `null`.
diff --git a/doc/mkdocs/docs/features/binary_formats/ubjson.md b/doc/mkdocs/docs/features/binary_formats/ubjson.md
index cb01cfde..050b4ec5 100644
--- a/doc/mkdocs/docs/features/binary_formats/ubjson.md
+++ b/doc/mkdocs/docs/features/binary_formats/ubjson.md
@@ -28,6 +28,7 @@ number_unsigned | 128..255 | uint8 | `U`
number_unsigned | 256..32767 | int16 | `I`
number_unsigned | 32768..2147483647 | int32 | `l`
number_unsigned | 2147483648..9223372036854775807 | int64 | `L`
+number_unsigned | 2147483649..18446744073709551615 | high-precision | `H`
number_float | *any value* | float64 | `D`
string | *with shortest length indicator* | string | `S`
array | *see notes on optimized format* | array | `[`
@@ -44,7 +45,6 @@ object | *see notes on optimized format* | map | `{`
The following values can **not** be converted to a UBJSON value:
- strings with more than 9223372036854775807 bytes (theoretical)
- - unsigned integer numbers above 9223372036854775807
!!! info "Unused UBJSON markers"
diff --git a/doc/mkdocs/docs/features/binary_values.md b/doc/mkdocs/docs/features/binary_values.md
index e268a5b5..4716aac7 100644
--- a/doc/mkdocs/docs/features/binary_values.md
+++ b/doc/mkdocs/docs/features/binary_values.md
@@ -158,14 +158,14 @@ JSON does not have a binary type, and this library does not introduce a new type
### CBOR
-[CBOR](binary_formats/cbor.md) supports binary values, but no subtypes. Any binary value will be serialized as byte strings. The library will choose the smallest representation using the length of the byte array.
+[CBOR](binary_formats/cbor.md) supports binary values, but no subtypes. Subtypes will be serialized as tags. Any binary value will be serialized as byte strings. The library will choose the smallest representation using the length of the byte array.
??? example
Code:
```cpp
- // create a binary value of subtype 42 (will be ignored by CBOR)
+ // create a binary value of subtype 42
json j;
j["binary"] = json::binary({0xCA, 0xFE, 0xBA, 0xBE}, 42);
@@ -173,17 +173,18 @@ JSON does not have a binary type, and this library does not introduce a new type
auto v = json::to_cbor(j);
```
- `v` is a `std::vector<std::uint8t>` with the following 13 elements:
+ `v` is a `std::vector<std::uint8t>` with the following 15 elements:
```c
0xA1 // map(1)
0x66 // text(6)
0x62 0x69 0x6E 0x61 0x72 0x79 // "binary"
+ 0xD8 0x2A // tag(42)
0x44 // bytes(4)
0xCA 0xFE 0xBA 0xBE // content
```
- Note the subtype (42) is **not** serialized, and deserializing `v` would yield the following value:
+ Note that the subtype is serialized as tag. However, parsing tagged values yield a parse error unless `json::cbor_tag_handler_t::ignore` is passed to `json::from_cbor`.
```json
{
diff --git a/doc/mkdocs/docs/features/comments.md b/doc/mkdocs/docs/features/comments.md
new file mode 100644
index 00000000..f82029ee
--- /dev/null
+++ b/doc/mkdocs/docs/features/comments.md
@@ -0,0 +1,83 @@
+# Comments
+
+This library does not support comments *by default*. It does so for three reasons:
+
+1. Comments are not part of the [JSON specification](https://tools.ietf.org/html/rfc8259). You may argue that `//` or `/* */` are allowed in JavaScript, but JSON is not JavaScript.
+2. This was not an oversight: Douglas Crockford [wrote on this](https://plus.google.com/118095276221607585885/posts/RK8qyGVaGSr) in May 2012:
+
+ > I removed comments from JSON because I saw people were using them to hold parsing directives, a practice which would have destroyed interoperability. I know that the lack of comments makes some people sad, but it shouldn't.
+
+ > Suppose you are using JSON to keep configuration files, which you would like to annotate. Go ahead and insert all the comments you like. Then pipe it through JSMin before handing it to your JSON parser.
+
+3. It is dangerous for interoperability if some libraries would add comment support while others don't. Please check [The Harmful Consequences of the Robustness Principle](https://tools.ietf.org/html/draft-iab-protocol-maintenance-01) on this.
+
+However, you can pass set parameter `ignore_comments` to `#!c true` in the parse function to ignore `//` or `/* */` comments. Comments will then be treated as whitespace.
+
+!!! example
+
+ Consider the following JSON with comments.
+
+ ```json
+ {
+ // update in 2006: removed Pluto
+ "planets": ["Mercury", "Venus", "Earth", "Mars",
+ "Jupiter", "Uranus", "Neptune" /*, "Pluto" */]
+ }
+ ```
+
+ When calling `parse` without additional argument, a parse error exception is thrown. If `skip_comments` is set to `#! true`, the comments are skipped during parsing:
+
+ ```cpp
+ #include <iostream>
+ #include "json.hpp"
+
+ using json = nlohmann::json;
+
+ int main()
+ {
+ std::string s = R"(
+ {
+ // update in 2006: removed Pluto
+ "planets": ["Mercury", "Venus", "Earth", "Mars",
+ "Jupiter", "Uranus", "Neptune" /*, "Pluto" */]
+ }
+ )";
+
+ try
+ {
+ json j = json::parse(s);
+ }
+ catch (json::exception &e)
+ {
+ std::cout << e.what() << std::endl;
+ }
+
+ json j = json::parse(s,
+ /* callback */ nullptr,
+ /* allow exceptions */ true,
+ /* skip_comments */ true);
+ std::cout << j.dump(2) << '\n';
+ }
+ ```
+
+ Output:
+
+ ```
+ [json.exception.parse_error.101] parse error at line 3, column 9:
+ syntax error while parsing object key - invalid literal;
+ last read: '<U+000A> {<U+000A> /'; expected string literal
+ ```
+
+ ```json
+ {
+ "planets": [
+ "Mercury",
+ "Venus",
+ "Earth",
+ "Mars",
+ "Jupiter",
+ "Uranus",
+ "Neptune"
+ ]
+ }
+ ```
\ No newline at end of file
diff --git a/doc/mkdocs/docs/features/element_access/checked_access.md b/doc/mkdocs/docs/features/element_access/checked_access.md
new file mode 100644
index 00000000..095dff2d
--- /dev/null
+++ b/doc/mkdocs/docs/features/element_access/checked_access.md
@@ -0,0 +1,77 @@
+# Checked access: at
+
+## Overview
+
+The `#!cpp at()` member function performs checked access; that is, it returns a reference to the desired value if it exists and throws a [`basic_json::out_of_range` exception](../../home/exceptions.md#out-of-range) otherwise.
+
+??? example
+
+ Consider the following JSON value:
+
+ ```json
+ {
+ "name": "Mary Smith",
+ "age": 42,
+ "hobbies": ["hiking", "reading"]
+ }
+ ```
+
+ Assume the value is parsed to a `json` variable `j`.
+
+ | expression | value |
+ | ---------- | ----- |
+ | `#!cpp j` | `#!json {"name": "Mary Smith", "age": 42, "hobbies": ["hiking", "reading"]}` |
+ | `#!cpp j.at("name")` | `#!json "Mary Smith"` |
+ | `#!cpp j.at("age")` | `#!json 42` |
+ | `#!cpp j.at("hobbies")` | `#!json ["hiking", "reading"]` |
+ | `#!cpp j.at("hobbies").at(0)` | `#!json "hiking"` |
+ | `#!cpp j.at("hobbies").at(1)` | `#!json "reading"` |
+
+The return value is a reference, so it can be modify the original value.
+
+??? example
+
+ ```cpp
+ j.at("name") = "John Smith";
+ ```
+
+ This code produces the following JSON value:
+
+ ```json
+ {
+ "name": "John Smith",
+ "age": 42,
+ "hobbies": ["hiking", "reading"]
+ }
+ ```
+
+When accessing an invalid index (i.e., and index greater than or equal to the array size) or the passed object key is non-existing, an exception is thrown.
+
+??? example
+
+ ```cpp
+ j.at("hobbies").at(3) = "cooking";
+ ```
+
+ This code produces the following exception:
+
+ ```
+ [json.exception.out_of_range.401] array index 3 is out of range
+ ```
+
+## Notes
+
+
+!!! failure "Exceptions"
+
+ - `at` can only be used with objects (with a string argument) or with arrays (with a numeric argument). For other types, a [`basic_json::type_error`](../../home/exceptions.md#jsonexceptiontype_error304) is thrown.
+ - [`basic_json::out_of_range` exception](../../home/exceptions.md#out-of-range) exceptions are thrown if the provided key is not found in an object or the provided index is invalid.
+
+## Summary
+
+| scenario | non-const value | const value |
+| -------- | ------------- | ----------- |
+| access to existing object key | reference to existing value is returned | const reference to existing value is returned |
+| access to valid array index | reference to existing value is returned | const reference to existing value is returned |
+| access to non-existing object key | `basic_json::out_of_range` exception is thrown | `basic_json::out_of_range` exception is thrown |
+| access to invalid array index | `basic_json::out_of_range` exception is thrown | `basic_json::out_of_range` exception is thrown |
diff --git a/doc/mkdocs/docs/features/element_access/default_value.md b/doc/mkdocs/docs/features/element_access/default_value.md
new file mode 100644
index 00000000..02b4fea3
--- /dev/null
+++ b/doc/mkdocs/docs/features/element_access/default_value.md
@@ -0,0 +1,32 @@
+# Access with default value: value
+
+## Overview
+
+In many situations such as configuration files, missing values are not exceptional, but may be treated as if a default value was present.
+
+??? example
+
+ Consider the following JSON value:
+
+ ```json
+ {
+ "logOutput": "result.log",
+ "append": true
+ }
+ ```
+
+ Assume the value is parsed to a `json` variable `j`.
+
+ | expression | value |
+ | ---------- | ----- |
+ | `#!cpp j` | `#!json {"logOutput": "result.log", "append": true}` |
+ | `#!cpp j.value("logOutput", "logfile.log")` | `#!json "result.log"` |
+ | `#!cpp j.value("append", true)` | `#!json true` |
+ | `#!cpp j.value("append", false)` | `#!json true` |
+ | `#!cpp j.value("logLevel", "verbose")` | `#!json "verbose"` |
+
+## Note
+
+!!! failure "Exceptions"
+
+ - `value` can only be used with objects. For other types, a [`basic_json::type_error`](../../home/exceptions.md#jsonexceptiontype_error306) is thrown.
diff --git a/doc/mkdocs/docs/features/element_access/index.md b/doc/mkdocs/docs/features/element_access/index.md
new file mode 100644
index 00000000..1755fe8c
--- /dev/null
+++ b/doc/mkdocs/docs/features/element_access/index.md
@@ -0,0 +1,9 @@
+# Overview
+
+There are many ways elements in a JSON value can be accessed:
+
+- unchecked access via [`operator[]`](unchecked_access.md)
+- checked access via [`at`](checked_access.md)
+- access with default value via [`value`](default_value.md)
+- iterators
+- JSON pointers
diff --git a/doc/mkdocs/docs/features/element_access/unchecked_access.md b/doc/mkdocs/docs/features/element_access/unchecked_access.md
new file mode 100644
index 00000000..f8667c81
--- /dev/null
+++ b/doc/mkdocs/docs/features/element_access/unchecked_access.md
@@ -0,0 +1,102 @@
+# Unchecked access: operator[]
+
+## Overview
+
+Elements in a JSON object and a JSON array can be accessed via `#!cpp operator[]` similar to a `#!cpp std::map` and a `#!cpp std::vector`, respectively.
+
+??? example
+
+ Consider the following JSON value:
+
+ ```json
+ {
+ "name": "Mary Smith",
+ "age": 42,
+ "hobbies": ["hiking", "reading"]
+ }
+ ```
+
+ Assume the value is parsed to a `json` variable `j`.
+
+ | expression | value |
+ | ---------- | ----- |
+ | `#!cpp j` | `#!json {"name": "Mary Smith", "age": 42, "hobbies": ["hiking", "reading"]}` |
+ | `#!cpp j["name"]` | `#!json "Mary Smith"` |
+ | `#!cpp j["age"]` | `#!json 42` |
+ | `#!cpp j["hobbies"]` | `#!json ["hiking", "reading"]` |
+ | `#!cpp j["hobbies"][0]` | `#!json "hiking"` |
+ | `#!cpp j["hobbies"][1]` | `#!json "reading"` |
+
+The return value is a reference, so it can be modify the original value. In case the passed object key is non-existing, a `#!json null` value is inserted which can be immediately be overwritten.
+
+??? example
+
+ ```cpp
+ j["name"] = "John Smith";
+ j["maidenName"] = "Jones";
+ ```
+
+ This code produces the following JSON value:
+
+ ```json
+ {
+ "name": "John Smith",
+ "maidenName": "Jones",
+ "age": 42,
+ "hobbies": ["hiking", "reading"]
+ }
+ ```
+
+When accessing an invalid index (i.e., and index greater than or equal to the array size), the JSON array is resized such that the passed index is the new maximal index. Intermediate values are filled with `#!json null`.
+
+??? example
+
+ ```cpp
+ j["hobbies"][0] = "running";
+ j["hobbies"][3] = "cooking";
+ ```
+
+ This code produces the following JSON value:
+
+ ```json
+ {
+ "name": "John Smith",
+ "maidenName": "Jones",
+ "age": 42,
+ "hobbies": ["running", "reading", null, "cooking"]
+ }
+ ```
+
+## Notes
+
+!!! info "Design rationale"
+
+ The library behaves differently to `#!cpp std::vector` and `#!cpp std::map`:
+
+ - `#!cpp std::vector::operator[]` never inserts a new element.
+ - `#!cpp std::map::operator[]` is not available for const values.
+
+ The type `#!cpp json` wraps all JSON value types. It would be impossible to remove `operator[]` for const objects. At the same time, inserting elements for non-const objects is really convenient as it avoids awkward `insert` calls. To this end, we decided to have an inserting non-const behavior for both arrays and objects.
+
+!!! info
+
+ The access is unchecked. In case the passed object key does not exist or the passed array index is invalid, no exception is thrown.
+
+!!! danger
+
+ - It is **undefined behavior** to access a const object with a non-existing key.
+ - It is **undefined behavior** to access a const array with an invalid index.
+ - In debug mode, an **assertion** will fire in both cases. You can disable assertions by defining the preprocessor symbol `#!cpp NDEBUG` or redefine the macro [`JSON_ASSERT(x)`](../macros.md#json_assertx).
+
+!!! failure "Exceptions"
+
+ `operator[]` can only be used with objects (with a string argument) or with arrays (with a numeric argument). For other types, a [`basic_json::type_error`](../../home/exceptions.md#jsonexceptiontype_error305) is thrown.
+
+## Summary
+
+| scenario | non-const value | const value |
+| -------- | ------------- | ----------- |
+| access to existing object key | reference to existing value is returned | const reference to existing value is returned |
+| access to valid array index | reference to existing value is returned | const reference to existing value is returned |
+| access to non-existing object key | reference to newly inserted `#!json null` value is returned | **undefined behavior**; assertion in debug mode |
+| access to invalid array index | reference to newly inserted `#!json null` value is returned; any index between previous maximal index and passed index are filled with `#!json null` | **undefined behavior**; assertion in debug mode |
diff --git a/doc/mkdocs/docs/features/macros.md b/doc/mkdocs/docs/features/macros.md
new file mode 100644
index 00000000..696438d2
--- /dev/null
+++ b/doc/mkdocs/docs/features/macros.md
@@ -0,0 +1,79 @@
+# Supported Macros
+
+Some aspects of the library can be configured by defining preprocessor macros before including the `json.hpp` header.
+
+## `JSON_ASSERT(x)`
+
+The default value is `#!cpp assert(x)`.
+
+## `JSON_CATCH_USER(exception)`
+
+This macro overrides `#!cpp catch` calls inside the library. The argument is the type of the exception to catch. As of version 3.8.0, the library only catches `std::out_of_range` exceptions internally to rethrow them as [`json::out_of_range`](../home/exceptions.md#out-of-range) exceptions. The macro is always followed by a scope.
+
+See [Switch off exceptions](../home/exceptions.md#switch-off-exceptions) for an example.
+
+## `JSON_NOEXCEPTION`
+
+Exceptions can be switched off by defining the symbol `JSON_NOEXCEPTION`.
+When defining `JSON_NOEXCEPTION`, `#!cpp try` is replaced by `#!cpp if (true)`,
+`#!cpp catch` is replaced by `#!cpp if (false)`, and `#!cpp throw` is replaced by `#!cpp std::abort()`.
+
+The same effect is achieved by setting the compiler flag `-fno-exceptions`.
+
+## `JSON_SKIP_UNSUPPORTED_COMPILER_CHECK`
+
+When defined, the library will not create a compile error when a known unsupported compiler is detected. This allows to use the library with compilers that do not fully support C++11 and may only work if unsupported features are not used.
+
+## `JSON_THROW_USER(exception)`
+
+This macro overrides `#!cpp throw` calls inside the library. The argument is the exception to be thrown. Note that `JSON_THROW_USER` should leave the current scope (e.g., by throwing or aborting), as continuing after it may yield undefined behavior.
+
+See [Switch off exceptions](../home/exceptions.md#switch-off-exceptions) for an example.
+
+## `JSON_TRY_USER`
+
+This macro overrides `#!cpp try` calls inside the library. It has no arguments and is always followed by a scope.
+
+See [Switch off exceptions](../home/exceptions.md#switch-off-exceptions) for an example.
+
+## `JSON_USE_IMPLICIT_CONVERSIONS`
+
+When defined to `0`, implicit conversions are switched off. By default, implicit conversions are switched on.
+
+??? example
+
+ This is an example for an implicit conversion:
+
+ ```cpp
+ json j = "Hello, world!";
+ std::string s = j;
+ ```
+
+ When `JSON_USE_IMPLICIT_CONVERSIONS` is defined to `0`, the code above does no longer compile. Instead, it must be written like this:
+
+ ```cpp
+ json j = "Hello, world!";
+ auto s = j.get<std::string>();
+ ```
+
+## `NLOHMANN_DEFINE_TYPE_INTRUSIVE(type, member...)`
+
+This macro can be used to simplify the serialization/deserialization of types if (1) want to use a JSON object as serialization and (2) want to use the member variable names as object keys in that object.
+
+The macro is to be defined inside of the class/struct to create code for. Unlike [`NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`](#nlohmann_define_type_non_intrusivetype-member), it can access private members.
+The first parameter is the name of the class/struct, and all remaining parameters name the members.
+
+See [Simplify your life with macros](arbitrary_types.md#simplify-your-life-with-macros) for an example.
+
+## `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(type, member...)`
+
+This macro can be used to simplify the serialization/deserialization of types if (1) want to use a JSON object as serialization and (2) want to use the member variable names as object keys in that object.
+
+The macro is to be defined inside of the namespace of the class/struct to create code for. Private members cannot be accessed. Use [`NLOHMANN_DEFINE_TYPE_INTRUSIVE`](#nlohmann_define_type_intrusivetype-member) in these scenarios.
+The first parameter is the name of the class/struct, and all remaining parameters name the members.
+
+See [Simplify your life with macros](arbitrary_types.md#simplify-your-life-with-macros) for an example.
+
+## `NLOHMANN_JSON_SERIALIZE_ENUM(type, ...)`
+
+This macro simplifies the serialization/deserialization of enum types. See [Specializing enum conversion](enum_conversion.md) for more information.
diff --git a/doc/mkdocs/docs/features/object_order.md b/doc/mkdocs/docs/features/object_order.md
new file mode 100644
index 00000000..86bb253b
--- /dev/null
+++ b/doc/mkdocs/docs/features/object_order.md
@@ -0,0 +1,67 @@
+# Object Order
+
+The [JSON standard](https://tools.ietf.org/html/rfc8259.html) defines objects as "an unordered collection of zero or more name/value pairs". As such, an implementation does not need to preserve any specific order of object keys.
+
+The default type `nlohmann::json` uses a `std::map` to store JSON objects, and thus stores object keys **sorted alphabetically**.
+
+??? example
+
+ ```cpp
+ #include <iostream>
+ #include "json.hpp"
+
+ using json = nlohmann::json;
+
+ int main()
+ {
+ json j;
+ j["one"] = 1;
+ j["two"] = 2;
+ j["three"] = 3;
+
+ std::cout << j.dump(2) << '\n';
+ }
+ ```
+
+ Output:
+
+ ```json
+ {
+ "one": 1,
+ "three": 3,
+ "two": 2
+ }
+ ```
+
+If you do want to preserve the **insertion order**, you can try the type [`nlohmann::ordered_json`](https://github.com/nlohmann/json/issues/2179).
+
+??? example
+
+ ```cpp
+ #include <iostream>
+ #include <nlohmann/json.hpp>
+
+ using ordered_json = nlohmann::ordered_json;
+
+ int main()
+ {
+ ordered_json j;
+ j["one"] = 1;
+ j["two"] = 2;
+ j["three"] = 3;
+
+ std::cout << j.dump(2) << '\n';
+ }
+ ```
+
+ Output:
+
+ ```json
+ {
+ "one": 1,
+ "two": 2,
+ "three": 3
+ }
+ ```
+
+Alternatively, you can use a more sophisticated ordered map like [`tsl::ordered_map`](https://github.com/Tessil/ordered-map) ([integration](https://github.com/nlohmann/json/issues/546#issuecomment-304447518)) or [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map) ([integration](https://github.com/nlohmann/json/issues/485#issuecomment-333652309)).
diff --git a/doc/mkdocs/docs/features/parsing/sax_interface.md b/doc/mkdocs/docs/features/parsing/sax_interface.md
index ef83a532..73153482 100644
--- a/doc/mkdocs/docs/features/parsing/sax_interface.md
+++ b/doc/mkdocs/docs/features/parsing/sax_interface.md
@@ -14,6 +14,7 @@ interface json::sax_t {
+ {abstract} bool number_float(number_float_t val, const string_t& s)
+ {abstract} bool string(string_t& val)
+ + {abstract} bool binary(binary_t& val)
+ {abstract} bool start_object(std::size_t elements)
+ {abstract} bool end_object()
@@ -41,6 +42,8 @@ bool number_float(number_float_t val, const string_t& s);
// called when a string is parsed; value is passed and can be safely moved away
bool string(string_t& val);
+// called when a binary value is parsed; value is passed and can be safely moved away
+bool binary(binary& val);
// called when an object or array begins or ends, resp. The number of elements is passed (or -1 if not known)
bool start_object(std::size_t elements);
diff --git a/doc/mkdocs/docs/home/exceptions.md b/doc/mkdocs/docs/home/exceptions.md
index 92dfb43b..e1e1d13b 100644
--- a/doc/mkdocs/docs/home/exceptions.md
+++ b/doc/mkdocs/docs/home/exceptions.md
@@ -32,6 +32,24 @@ Exceptions are used widely within the library. They can, however, be switched of
Note that `JSON_THROW_USER` should leave the current scope (e.g., by throwing or aborting), as continuing after it may yield undefined behavior.
+??? example
+
+ The code below switches off exceptions and creates a log entry with a detailed error message in case of errors.
+
+ ```cpp
+ #include <iostream>
+
+ #define JSON_TRY_USER if(true)
+ #define JSON_CATCH_USER(exception) if(false)
+ #define JSON_THROW_USER(exception) \
+ {std::clog << "Error in " << __FILE__ << ":" << __LINE__ \
+ << " (function " << __FUNCTION__ << ") - " \
+ << (exception).what() << std::endl; \
+ std::abort();}
+
+ #include <nlohmann/json.hpp>
+ ```
+
## Parse errors
This exception is thrown by the library when a parse error occurs. Parse errors
@@ -261,6 +279,16 @@ The parsing of the corresponding BSON record type is not implemented (yet).
[json.exception.parse_error.114] parse error at byte 5: Unsupported BSON record type 0xFF
```
+### json.exception.parse_error.115
+
+A UBJSON high-precision number could not be parsed.
+
+!!! failure "Example message"
+
+ ```
+ [json.exception.parse_error.115] parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1A
+ ```
+
## Iterator errors
This exception is thrown if iterators passed to a library function do not match
@@ -747,6 +775,10 @@ UBJSON and BSON only support integer numbers up to 9223372036854775807.
number overflow serializing '9223372036854775808'
```
+!!! note
+
+ Since version 3.9.0, integer numbers beyond int64 are serialized as high-precision UBJSON numbers, and this exception does not further occur.
+
### json.exception.out_of_range.408
The size (following `#`) of an UBJSON array or object exceeds the maximal capacity.
diff --git a/doc/mkdocs/docs/home/faq.md b/doc/mkdocs/docs/home/faq.md
index a9b5af08..af63cfb6 100644
--- a/doc/mkdocs/docs/home/faq.md
+++ b/doc/mkdocs/docs/home/faq.md
@@ -2,31 +2,6 @@
## Limitations
-### Comments
-
-!!! question "Questions"
-
- - Why does the library not support comments?
- - Can you add support for JSON5/JSONC/HOCON so that comments are supported?
-
-This library does not support comments. It does so for three reasons:
-
-1. Comments are not part of the [JSON specification](https://tools.ietf.org/html/rfc8259). You may argue that `//` or `/* */` are allowed in JavaScript, but JSON is not JavaScript.
-2. This was not an oversight: Douglas Crockford [wrote on this](https://plus.google.com/118095276221607585885/posts/RK8qyGVaGSr) in May 2012:
-
- > I removed comments from JSON because I saw people were using them to hold parsing directives, a practice which would have destroyed interoperability. I know that the lack of comments makes some people sad, but it shouldn't.
-
- > Suppose you are using JSON to keep configuration files, which you would like to annotate. Go ahead and insert all the comments you like. Then pipe it through JSMin before handing it to your JSON parser.
-
-3. It is dangerous for interoperability if some libraries would add comment support while others don't. Please check [The Harmful Consequences of the Robustness Principle](https://tools.ietf.org/html/draft-iab-protocol-maintenance-01) on this.
-
-This library will not support comments in the future. If you wish to use comments, I see three options:
-
-1. Strip comments before using this library.
-2. Use a different JSON library with comment support.
-3. Use a format that natively supports comments (e.g., YAML or JSON5).
-
-
### Relaxed parsing
!!! question
@@ -69,18 +44,6 @@ No, this is not possible. See <https://github.com/nlohmann/json/issues/932> for
## Serialization issues
-### Order of object keys
-
-!!! question "Questions"
-
- - Why are object keys sorted?
- - Why is the insertion order of object keys not preserved?
-
-By default, the library does not preserve the **insertion order of object elements**. This is standards-compliant, as the [JSON standard](https://tools.ietf.org/html/rfc8259.html) defines objects as "an unordered collection of zero or more name/value pairs".
-
-If you do want to preserve the insertion order, you can specialize the object type with containers like [`tsl::ordered_map`](https://github.com/Tessil/ordered-map) ([integration](https://github.com/nlohmann/json/issues/546#issuecomment-304447518)) or [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map) ([integration](https://github.com/nlohmann/json/issues/485#issuecomment-333652309)).
-
-
### Number precision
!!! question
diff --git a/doc/mkdocs/docs/home/license.md b/doc/mkdocs/docs/home/license.md
index 9211eddd..f7d0aa82 100644
--- a/doc/mkdocs/docs/home/license.md
+++ b/doc/mkdocs/docs/home/license.md
@@ -4,7 +4,7 @@
The class is licensed under the [MIT License](http://opensource.org/licenses/MIT):
-Copyright © 2013-2019 [Niels Lohmann](http://nlohmann.me)
+Copyright © 2013-2020 [Niels Lohmann](http://nlohmann.me)
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
diff --git a/doc/mkdocs/docs/hooks.py b/doc/mkdocs/docs/hooks.py
index a04a7c53..8fee8397 100644
--- a/doc/mkdocs/docs/hooks.py
+++ b/doc/mkdocs/docs/hooks.py
@@ -3,5 +3,8 @@ import os.path
def copy_doxygen(*args, **kwargs):
- shutil.copytree('../html', os.path.join(kwargs['config']['site_dir'], 'doxygen'))
- print('Copy Doxygen complete')
+ doxygen_dir = os.path.join(kwargs['config']['site_dir'], 'doxygen')
+ if not os.path.isdir(doxygen_dir) or not os.listdir(doxygen_dir):
+ print('Copy Doxygen files...')
+ shutil.copytree('../html', doxygen_dir)
+ print('Copy Doxygen complete')
diff --git a/doc/mkdocs/mkdocs.yml b/doc/mkdocs/mkdocs.yml
index 5d6e3b4e..2837e8ca 100644
--- a/doc/mkdocs/mkdocs.yml
+++ b/doc/mkdocs/mkdocs.yml
@@ -44,16 +44,24 @@ nav:
- features/binary_formats/messagepack.md
- features/binary_formats/ubjson.md
- features/binary_values.md
+ - features/comments.md
+ - Element Access:
+ - features/element_access/index.md
+ - features/element_access/unchecked_access.md
+ - features/element_access/checked_access.md
+ - features/element_access/default_value.md
- features/iterators.md
- features/json_pointer.md
- features/json_patch.md
- features/merge_patch.md
- - features/enum_conversion.md
+ - features/object_order.md
- Parsing:
- - features/parsing/index.md
- - features/parsing/parse_exceptions.md
- - features/parsing/parser_callbacks.md
- - features/parsing/sax_interface.md
+ - features/parsing/index.md
+ - features/parsing/parse_exceptions.md
+ - features/parsing/parser_callbacks.md
+ - features/parsing/sax_interface.md
+ - features/enum_conversion.md
+ - features/macros.md
- features/types.md
- Integration:
- integration/index.md
@@ -61,6 +69,12 @@ nav:
- integration/package_managers.md
- Doxygen:
- doxygen/index.html
+ - API:
+ - basic_json:
+ - api/basic_json/index.md
+ - api/basic_json/dump.md
+ - api/basic_json/meta.md
+ - api/basic_json/parse.md
# Extras
extra:
@@ -79,6 +93,7 @@ extra:
# Extensions
markdown_extensions:
- admonition
+ - def_list
- codehilite:
guess_lang: false
- toc:
diff --git a/include/nlohmann/adl_serializer.hpp b/include/nlohmann/adl_serializer.hpp
index eeaa1425..4af1c4bb 100644
--- a/include/nlohmann/adl_serializer.hpp
+++ b/include/nlohmann/adl_serializer.hpp
@@ -37,7 +37,7 @@ struct adl_serializer
@param[in,out] j JSON value to write to
@param[in] val value to read from
*/
- template <typename BasicJsonType, typename ValueType>
+ template<typename BasicJsonType, typename ValueType>
static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(
noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
-> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)), void())
diff --git a/include/nlohmann/detail/boolean_operators.hpp b/include/nlohmann/detail/boolean_operators.hpp
deleted file mode 100644
index 06335866..00000000
--- a/include/nlohmann/detail/boolean_operators.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-
-// Header <ciso646> is removed in C++20.
-// See <https://github.com/nlohmann/json/issues/2089> for more information.
-
-#if __cplusplus <= 201703L
- #include <ciso646> // and, not, or
-#endif
diff --git a/include/nlohmann/detail/conversions/from_json.hpp b/include/nlohmann/detail/conversions/from_json.hpp
index e8731f22..438b84a2 100644
--- a/include/nlohmann/detail/conversions/from_json.hpp
+++ b/include/nlohmann/detail/conversions/from_json.hpp
@@ -12,7 +12,6 @@
#include <utility> // pair, declval
#include <valarray> // valarray
-#include <nlohmann/detail/boolean_operators.hpp>
#include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/meta/cpp_future.hpp>
@@ -26,7 +25,7 @@ namespace detail
template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_null()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
{
JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
}
@@ -34,10 +33,10 @@ void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
}
// overloads for basic_json template parameters
-template<typename BasicJsonType, typename ArithmeticType,
- enable_if_t<std::is_arithmetic<ArithmeticType>::value and
- not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
- int> = 0>
+template < typename BasicJsonType, typename ArithmeticType,
+ enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
+ !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+ int > = 0 >
void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
{
switch (static_cast<value_t>(j))
@@ -66,7 +65,7 @@ void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_boolean()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
{
JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
}
@@ -76,7 +75,7 @@ void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
{
JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
}
@@ -86,13 +85,13 @@ void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
template <
typename BasicJsonType, typename ConstructibleStringType,
enable_if_t <
- is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value and
- not std::is_same<typename BasicJsonType::string_t,
- ConstructibleStringType>::value,
+ is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
+ !std::is_same<typename BasicJsonType::string_t,
+ ConstructibleStringType>::value,
int > = 0 >
void from_json(const BasicJsonType& j, ConstructibleStringType& s)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
{
JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
}
@@ -129,10 +128,10 @@ void from_json(const BasicJsonType& j, EnumType& e)
// forward_list doesn't have an insert method
template<typename BasicJsonType, typename T, typename Allocator,
- enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
+ enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
@@ -146,18 +145,22 @@ void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
// valarray doesn't have an insert method
template<typename BasicJsonType, typename T,
- enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
+ enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
void from_json(const BasicJsonType& j, std::valarray<T>& l)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
l.resize(j.size());
- std::copy(j.begin(), j.end(), std::begin(l));
+ std::transform(j.begin(), j.end(), std::begin(l),
+ [](const BasicJsonType & elem)
+ {
+ return elem.template get<T>();
+ });
}
-template <typename BasicJsonType, typename T, std::size_t N>
+template<typename BasicJsonType, typename T, std::size_t N>
auto from_json(const BasicJsonType& j, T (&arr)[N])
-> decltype(j.template get<T>(), void())
{
@@ -173,7 +176,7 @@ void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_
arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
}
-template <typename BasicJsonType, typename T, std::size_t N>
+template<typename BasicJsonType, typename T, std::size_t N>
auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
priority_tag<2> /*unused*/)
-> decltype(j.template get<T>(), void())
@@ -205,7 +208,7 @@ auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, p
arr = std::move(ret);
}
-template <typename BasicJsonType, typename ConstructibleArrayType>
+template<typename BasicJsonType, typename ConstructibleArrayType>
void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
priority_tag<0> /*unused*/)
{
@@ -223,20 +226,20 @@ void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
arr = std::move(ret);
}
-template <typename BasicJsonType, typename ConstructibleArrayType,
- enable_if_t <
- is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value and
- not is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value and
- not is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value and
- not std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value and
- not is_basic_json<ConstructibleArrayType>::value,
- int > = 0 >
+template < typename BasicJsonType, typename ConstructibleArrayType,
+ enable_if_t <
+ is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
+ !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
+ !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+ !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
+ !is_basic_json<ConstructibleArrayType>::value,
+ int > = 0 >
auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
j.template get<typename ConstructibleArrayType::value_type>(),
void())
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " +
std::string(j.type_name())));
@@ -245,10 +248,10 @@ void())
from_json_array_impl(j, arr, priority_tag<3> {});
}
-template <typename BasicJsonType>
+template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_binary()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
{
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name())));
}
@@ -260,7 +263,7 @@ template<typename BasicJsonType, typename ConstructibleObjectType,
enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
{
JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
}
@@ -282,14 +285,14 @@ void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
// (BooleanType, etc..); note: Is it really necessary to provide explicit
// overloads for boolean_t etc. in case of a custom BooleanType which is not
// an arithmetic type?
-template<typename BasicJsonType, typename ArithmeticType,
- enable_if_t <
- std::is_arithmetic<ArithmeticType>::value and
- not std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value and
- not std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value and
- not std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value and
- not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
- int> = 0>
+template < typename BasicJsonType, typename ArithmeticType,
+ enable_if_t <
+ std::is_arithmetic<ArithmeticType>::value&&
+ !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
+ !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
+ !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
+ !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+ int > = 0 >
void from_json(const BasicJsonType& j, ArithmeticType& val)
{
switch (static_cast<value_t>(j))
@@ -338,19 +341,19 @@ void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
}
-template <typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
- typename = enable_if_t<not std::is_constructible<
- typename BasicJsonType::string_t, Key>::value>>
+template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
+ typename = enable_if_t < !std::is_constructible <
+ typename BasicJsonType::string_t, Key >::value >>
void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
m.clear();
for (const auto& p : j)
{
- if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
}
@@ -358,19 +361,19 @@ void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>&
}
}
-template <typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
- typename = enable_if_t<not std::is_constructible<
- typename BasicJsonType::string_t, Key>::value>>
+template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+ typename = enable_if_t < !std::is_constructible <
+ typename BasicJsonType::string_t, Key >::value >>
void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
m.clear();
for (const auto& p : j)
{
- if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
}
diff --git a/include/nlohmann/detail/conversions/to_chars.hpp b/include/nlohmann/detail/conversions/to_chars.hpp
index 5851fd0a..c632ff2b 100644
--- a/include/nlohmann/detail/conversions/to_chars.hpp
+++ b/include/nlohmann/detail/conversions/to_chars.hpp
@@ -1,14 +1,12 @@
#pragma once
#include <array> // array
-#include <cassert> // assert
#include <cmath> // signbit, isfinite
#include <cstdint> // intN_t, uintN_t
#include <cstring> // memcpy, memmove
#include <limits> // numeric_limits
#include <type_traits> // conditional
-#include <nlohmann/detail/boolean_operators.hpp>
#include <nlohmann/detail/macro_scope.hpp>
namespace nlohmann
@@ -38,7 +36,7 @@ For a detailed description of the algorithm see:
namespace dtoa_impl
{
-template <typename Target, typename Source>
+template<typename Target, typename Source>
Target reinterpret_bits(const Source source)
{
static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
@@ -63,8 +61,8 @@ struct diyfp // f * 2^e
*/
static diyfp sub(const diyfp& x, const diyfp& y) noexcept
{
- assert(x.e == y.e);
- assert(x.f >= y.f);
+ JSON_ASSERT(x.e == y.e);
+ JSON_ASSERT(x.f >= y.f);
return {x.f - y.f, x.e};
}
@@ -140,7 +138,7 @@ struct diyfp // f * 2^e
*/
static diyfp normalize(diyfp x) noexcept
{
- assert(x.f != 0);
+ JSON_ASSERT(x.f != 0);
while ((x.f >> 63u) == 0)
{
@@ -159,8 +157,8 @@ struct diyfp // f * 2^e
{
const int delta = x.e - target_exponent;
- assert(delta >= 0);
- assert(((x.f << delta) >> delta) == x.f);
+ JSON_ASSERT(delta >= 0);
+ JSON_ASSERT(((x.f << delta) >> delta) == x.f);
return {x.f << delta, target_exponent};
}
@@ -179,11 +177,11 @@ boundaries.
@pre value must be finite and positive
*/
-template <typename FloatType>
+template<typename FloatType>
boundaries compute_boundaries(FloatType value)
{
- assert(std::isfinite(value));
- assert(value > 0);
+ JSON_ASSERT(std::isfinite(value));
+ JSON_ASSERT(value > 0);
// Convert the IEEE representation into a diyfp.
//
@@ -232,7 +230,7 @@ boundaries compute_boundaries(FloatType value)
// -----------------+------+------+-------------+-------------+--- (B)
// v- m- v m+ v+
- const bool lower_boundary_is_closer = F == 0 and E > 1;
+ const bool lower_boundary_is_closer = F == 0 && E > 1;
const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
const diyfp m_minus = lower_boundary_is_closer
? diyfp(4 * v.f - 1, v.e - 2) // (B)
@@ -463,18 +461,18 @@ inline cached_power get_cached_power_for_binary_exponent(int e)
// k = ceil((kAlpha - e - 1) * 0.30102999566398114)
// for |e| <= 1500, but doesn't require floating-point operations.
// NB: log_10(2) ~= 78913 / 2^18
- assert(e >= -1500);
- assert(e <= 1500);
+ JSON_ASSERT(e >= -1500);
+ JSON_ASSERT(e <= 1500);
const int f = kAlpha - e - 1;
const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
- assert(index >= 0);
- assert(static_cast<std::size_t>(index) < kCachedPowers.size());
+ JSON_ASSERT(index >= 0);
+ JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
- assert(kAlpha <= cached.e + e + 64);
- assert(kGamma >= cached.e + e + 64);
+ JSON_ASSERT(kAlpha <= cached.e + e + 64);
+ JSON_ASSERT(kGamma >= cached.e + e + 64);
return cached;
}
@@ -542,10 +540,10 @@ inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
std::uint64_t rest, std::uint64_t ten_k)
{
- assert(len >= 1);
- assert(dist <= delta);
- assert(rest <= delta);
- assert(ten_k > 0);
+ JSON_ASSERT(len >= 1);
+ JSON_ASSERT(dist <= delta);
+ JSON_ASSERT(rest <= delta);
+ JSON_ASSERT(ten_k > 0);
// <--------------------------- delta ---->
// <---- dist --------->
@@ -567,10 +565,10 @@ inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t d
// integer arithmetic.
while (rest < dist
- and delta - rest >= ten_k
- and (rest + ten_k < dist or dist - rest > rest + ten_k - dist))
+ && delta - rest >= ten_k
+ && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
{
- assert(buf[len - 1] != '0');
+ JSON_ASSERT(buf[len - 1] != '0');
buf[len - 1]--;
rest += ten_k;
}
@@ -598,8 +596,8 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// Grisu2 generates the digits of M+ from left to right and stops as soon as
// V is in [M-,M+].
- assert(M_plus.e >= kAlpha);
- assert(M_plus.e <= kGamma);
+ JSON_ASSERT(M_plus.e >= kAlpha);
+ JSON_ASSERT(M_plus.e <= kGamma);
std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
@@ -620,7 +618,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
//
// Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
- assert(p1 > 0);
+ JSON_ASSERT(p1 > 0);
std::uint32_t pow10;
const int k = find_largest_pow10(p1, pow10);
@@ -656,7 +654,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
// = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
//
- assert(d <= 9);
+ JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
@@ -743,7 +741,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
//
// and stop as soon as 10^-m * r * 2^e <= delta * 2^e
- assert(p2 > delta);
+ JSON_ASSERT(p2 > delta);
int m = 0;
for (;;)
@@ -754,7 +752,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
//
- assert(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
+ JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
p2 *= 10;
const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
@@ -763,7 +761,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
// = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
- assert(d <= 9);
+ JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
@@ -824,8 +822,8 @@ JSON_HEDLEY_NON_NULL(1)
inline void grisu2(char* buf, int& len, int& decimal_exponent,
diyfp m_minus, diyfp v, diyfp m_plus)
{
- assert(m_plus.e == m_minus.e);
- assert(m_plus.e == v.e);
+ JSON_ASSERT(m_plus.e == m_minus.e);
+ JSON_ASSERT(m_plus.e == v.e);
// --------(-----------------------+-----------------------)-------- (A)
// m- v m+
@@ -879,15 +877,15 @@ v = buf * 10^decimal_exponent
len is the length of the buffer (number of decimal digits)
The buffer must be large enough, i.e. >= max_digits10.
*/
-template <typename FloatType>
+template<typename FloatType>
JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{
static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
"internal error: not enough precision");
- assert(std::isfinite(value));
- assert(value > 0);
+ JSON_ASSERT(std::isfinite(value));
+ JSON_ASSERT(value > 0);
// If the neighbors (and boundaries) of 'value' are always computed for double-precision
// numbers, all float's can be recovered using strtod (and strtof). However, the resulting
@@ -923,8 +921,8 @@ JSON_HEDLEY_NON_NULL(1)
JSON_HEDLEY_RETURNS_NON_NULL
inline char* append_exponent(char* buf, int e)
{
- assert(e > -1000);
- assert(e < 1000);
+ JSON_ASSERT(e > -1000);
+ JSON_ASSERT(e < 1000);
if (e < 0)
{
@@ -976,8 +974,8 @@ JSON_HEDLEY_RETURNS_NON_NULL
inline char* format_buffer(char* buf, int len, int decimal_exponent,
int min_exp, int max_exp)
{
- assert(min_exp < 0);
- assert(max_exp > 0);
+ JSON_ASSERT(min_exp < 0);
+ JSON_ASSERT(max_exp > 0);
const int k = len;
const int n = len + decimal_exponent;
@@ -986,7 +984,7 @@ inline char* format_buffer(char* buf, int len, int decimal_exponent,
// k is the length of the buffer (number of decimal digits)
// n is the position of the decimal point relative to the start of the buffer.
- if (k <= n and n <= max_exp)
+ if (k <= n && n <= max_exp)
{
// digits[000]
// len <= max_exp + 2
@@ -998,19 +996,19 @@ inline char* format_buffer(char* buf, int len, int decimal_exponent,
return buf + (static_cast<size_t>(n) + 2);
}
- if (0 < n and n <= max_exp)
+ if (0 < n && n <= max_exp)
{
// dig.its
// len <= max_digits10 + 1
- assert(k > n);
+ JSON_ASSERT(k > n);
std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
buf[n] = '.';
return buf + (static_cast<size_t>(k) + 1U);
}
- if (min_exp < n and n <= 0)
+ if (min_exp < n && n <= 0)
{
// 0.[000]digits
// len <= 2 + (-min_exp - 1) + max_digits10
@@ -1055,13 +1053,13 @@ format. Returns an iterator pointing past-the-end of the decimal representation.
@note The buffer must be large enough.
@note The result is NOT null-terminated.
*/
-template <typename FloatType>
+template<typename FloatType>
JSON_HEDLEY_NON_NULL(1, 2)
JSON_HEDLEY_RETURNS_NON_NULL
char* to_chars(char* first, const char* last, FloatType value)
{
static_cast<void>(last); // maybe unused - fix warning
- assert(std::isfinite(value));
+ JSON_ASSERT(std::isfinite(value));
// Use signbit(value) instead of (value < 0) since signbit works for -0.
if (std::signbit(value))
@@ -1079,7 +1077,7 @@ char* to_chars(char* first, const char* last, FloatType value)
return first;
}
- assert(last - first >= std::numeric_limits<FloatType>::max_digits10);
+ JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
// Compute v = buffer * 10^decimal_exponent.
// The decimal digits are stored in the buffer, which needs to be interpreted
@@ -1089,16 +1087,16 @@ char* to_chars(char* first, const char* last, FloatType value)
int decimal_exponent = 0;
dtoa_impl::grisu2(first, len, decimal_exponent, value);
- assert(len <= std::numeric_limits<FloatType>::max_digits10);
+ JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
// Format the buffer like printf("%.*g", prec, value)
constexpr int kMinExp = -4;
// Use digits10 here to increase compatibility with version 2.
constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
- assert(last - first >= kMaxExp + 2);
- assert(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
- assert(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
+ JSON_ASSERT(last - first >= kMaxExp + 2);
+ JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
+ JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
}
diff --git a/include/nlohmann/detail/conversions/to_json.hpp b/include/nlohmann/detail/conversions/to_json.hpp
index cae779c5..b45004fd 100644
--- a/include/nlohmann/detail/conversions/to_json.hpp
+++ b/include/nlohmann/detail/conversions/to_json.hpp
@@ -9,7 +9,6 @@
#include <valarray> // valarray
#include <vector> // vector
-#include <nlohmann/detail/boolean_operators.hpp>
#include <nlohmann/detail/iterators/iteration_proxy.hpp>
#include <nlohmann/detail/meta/cpp_future.hpp>
#include <nlohmann/detail/meta/type_traits.hpp>
@@ -56,9 +55,9 @@ struct external_constructor<value_t::string>
j.assert_invariant();
}
- template<typename BasicJsonType, typename CompatibleStringType,
- enable_if_t<not std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
- int> = 0>
+ template < typename BasicJsonType, typename CompatibleStringType,
+ enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
+ int > = 0 >
static void construct(BasicJsonType& j, const CompatibleStringType& str)
{
j.m_type = value_t::string;
@@ -144,9 +143,9 @@ struct external_constructor<value_t::array>
j.assert_invariant();
}
- template<typename BasicJsonType, typename CompatibleArrayType,
- enable_if_t<not std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
- int> = 0>
+ template < typename BasicJsonType, typename CompatibleArrayType,
+ enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
+ int > = 0 >
static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
{
using std::begin;
@@ -203,8 +202,8 @@ struct external_constructor<value_t::object>
j.assert_invariant();
}
- template<typename BasicJsonType, typename CompatibleObjectType,
- enable_if_t<not std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int> = 0>
+ template < typename BasicJsonType, typename CompatibleObjectType,
+ enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
{
using std::begin;
@@ -275,20 +274,20 @@ void to_json(BasicJsonType& j, const std::vector<bool>& e)
external_constructor<value_t::array>::construct(j, e);
}
-template <typename BasicJsonType, typename CompatibleArrayType,
- enable_if_t<is_compatible_array_type<BasicJsonType,
- CompatibleArrayType>::value and
- not is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value and
- not is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value and
- not std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value and
- not is_basic_json<CompatibleArrayType>::value,
- int> = 0>
+template < typename BasicJsonType, typename CompatibleArrayType,
+ enable_if_t < is_compatible_array_type<BasicJsonType,
+ CompatibleArrayType>::value&&
+ !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
+ !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
+ !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
+ !is_basic_json<CompatibleArrayType>::value,
+ int > = 0 >
void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
{
external_constructor<value_t::array>::construct(j, arr);
}
-template <typename BasicJsonType>
+template<typename BasicJsonType>
void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
{
external_constructor<value_t::binary>::construct(j, bin);
@@ -307,8 +306,8 @@ void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
external_constructor<value_t::array>::construct(j, std::move(arr));
}
-template<typename BasicJsonType, typename CompatibleObjectType,
- enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value and not is_basic_json<CompatibleObjectType>::value, int> = 0>
+template < typename BasicJsonType, typename CompatibleObjectType,
+ enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
{
external_constructor<value_t::object>::construct(j, obj);
@@ -322,9 +321,9 @@ void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
template <
typename BasicJsonType, typename T, std::size_t N,
- enable_if_t<not std::is_constructible<typename BasicJsonType::string_t,
- const T(&)[N]>::value,
- int> = 0 >
+ enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
+ const T(&)[N]>::value,
+ int > = 0 >
void to_json(BasicJsonType& j, const T(&arr)[N])
{
external_constructor<value_t::array>::construct(j, arr);
@@ -337,8 +336,8 @@ void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
}
// for https://github.com/nlohmann/json/pull/1134
-template < typename BasicJsonType, typename T,
- enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
+template<typename BasicJsonType, typename T,
+ enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
void to_json(BasicJsonType& j, const T& b)
{
j = { {b.key(), b.value()} };
diff --git a/include/nlohmann/detail/exceptions.hpp b/include/nlohmann/detail/exceptions.hpp
index ed836188..dd92897d 100644
--- a/include/nlohmann/detail/exceptions.hpp
+++ b/include/nlohmann/detail/exceptions.hpp
@@ -97,6 +97,7 @@ json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vect
json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xF8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read.
json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read.
json.exception.parse_error.114 | parse error: Unsupported BSON record type 0x0F | The parsing of the corresponding BSON record type is not implemented (yet).
+json.exception.parse_error.115 | parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1A | A UBJSON high-precision number could not be parsed.
@note For an input with n bytes, 1 is the index of the first character and n+1
is the index of the terminating null byte or the end of file. This also
@@ -285,7 +286,7 @@ json.exception.out_of_range.403 | key 'foo' not found | The provided key was not
json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved.
json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value.
json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF.
-json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON and BSON only support integer numbers up to 9223372036854775807. |
+json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON and BSON only support integer numbers up to 9223372036854775807. (until version 3.8.0) |
json.exception.out_of_range.408 | excessive array size: 8658170730974374167 | The size (following `#`) of an UBJSON array or object exceeds the maximal capacity. |
json.exception.out_of_range.409 | BSON key cannot contain code point U+0000 (at byte 2) | Key identifiers to be serialized to BSON cannot contain code point U+0000, since the key is stored as zero-terminated c-string |
diff --git a/include/nlohmann/detail/hash.hpp b/include/nlohmann/detail/hash.hpp
new file mode 100644
index 00000000..4094cc94
--- /dev/null
+++ b/include/nlohmann/detail/hash.hpp
@@ -0,0 +1,117 @@
+#pragma once
+
+#include <cstddef> // size_t, uint8_t
+#include <functional> // hash
+
+namespace nlohmann
+{
+namespace detail
+{
+
+// boost::hash_combine
+inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
+{
+ seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
+ return seed;
+}
+
+/*!
+@brief hash a JSON value
+
+The hash function tries to rely on std::hash where possible. Furthermore, the
+type of the JSON value is taken into account to have different hash values for
+null, 0, 0U, and false, etc.
+
+@tparam BasicJsonType basic_json specialization
+@param j JSON value to hash
+@return hash value of j
+*/
+template<typename BasicJsonType>
+std::size_t hash(const BasicJsonType& j)
+{
+ using string_t = typename BasicJsonType::string_t;
+ using number_integer_t = typename BasicJsonType::number_integer_t;
+ using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+ using number_float_t = typename BasicJsonType::number_float_t;
+
+ const auto type = static_cast<std::size_t>(j.type());
+ switch (j.type())
+ {
+ case BasicJsonType::value_t::null:
+ case BasicJsonType::value_t::discarded:
+ {
+ return combine(type, 0);
+ }
+
+ case BasicJsonType::value_t::object:
+ {
+ auto seed = combine(type, j.size());
+ for (const auto& element : j.items())
+ {
+ const auto h = std::hash<string_t> {}(element.key());
+ seed = combine(seed, h);
+ seed = combine(seed, hash(element.value()));
+ }
+ return seed;
+ }
+
+ case BasicJsonType::value_t::array:
+ {
+ auto seed = combine(type, j.size());
+ for (const auto& element : j)
+ {
+ seed = combine(seed, hash(element));
+ }
+ return seed;
+ }
+
+ case BasicJsonType::value_t::string:
+ {
+ const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
+ return combine(type, h);
+ }
+
+ case BasicJsonType::value_t::boolean:
+ {
+ const auto h = std::hash<bool> {}(j.template get<bool>());
+ return combine(type, h);
+ }
+
+ case BasicJsonType::value_t::number_integer:
+ {
+ const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
+ return combine(type, h);
+ }
+
+ case nlohmann::detail::value_t::number_unsigned:
+ {
+ const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
+ return combine(type, h);
+ }
+
+ case nlohmann::detail::value_t::number_float:
+ {
+ const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
+ return combine(type, h);
+ }
+
+ case nlohmann::detail::value_t::binary:
+ {
+ auto seed = combine(type, j.get_binary().size());
+ const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
+ seed = combine(seed, h);
+ seed = combine(seed, j.get_binary().subtype());
+ for (const auto byte : j.get_binary())
+ {
+ seed = combine(seed, std::hash<std::uint8_t> {}(byte));
+ }
+ return seed;
+ }
+
+ default: // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
+ }
+}
+
+} // namespace detail
+} // namespace nlohmann
diff --git a/include/nlohmann/detail/input/binary_reader.hpp b/include/nlohmann/detail/input/binary_reader.hpp
index 93667e8f..4c94d1cc 100644
--- a/include/nlohmann/detail/input/binary_reader.hpp
+++ b/include/nlohmann/detail/input/binary_reader.hpp
@@ -2,7 +2,6 @@
#include <algorithm> // generate_n
#include <array> // array
-#include <cassert> // assert
#include <cmath> // ldexp
#include <cstddef> // size_t
#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
@@ -16,6 +15,7 @@
#include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/input/input_adapters.hpp>
#include <nlohmann/detail/input/json_sax.hpp>
+#include <nlohmann/detail/input/lexer.hpp>
#include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/meta/is_sax.hpp>
#include <nlohmann/detail/value_t.hpp>
@@ -25,6 +25,13 @@ namespace nlohmann
namespace detail
{
+/// how to treat CBOR tags
+enum class cbor_tag_handler_t
+{
+ error, ///< throw a parse_error exception in case of a tag
+ ignore ///< ignore tags
+};
+
/*!
@brief determine system byte order
@@ -79,13 +86,15 @@ class binary_reader
@param[in] format the binary format to parse
@param[in] sax_ a SAX event processor
@param[in] strict whether to expect the input to be consumed completed
+ @param[in] tag_handler how to treat CBOR tags
@return
*/
JSON_HEDLEY_NON_NULL(3)
bool sax_parse(const input_format_t format,
json_sax_t* sax_,
- const bool strict = true)
+ const bool strict = true,
+ const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
{
sax = sax_;
bool result = false;
@@ -97,7 +106,7 @@ class binary_reader
break;
case input_format_t::cbor:
- result = parse_cbor_internal();
+ result = parse_cbor_internal(true, tag_handler);
break;
case input_format_t::msgpack:
@@ -109,11 +118,11 @@ class binary_reader
break;
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
// strict mode: next byte must be EOF
- if (result and strict)
+ if (result && strict)
{
if (format == input_format_t::ubjson)
{
@@ -145,15 +154,15 @@ class binary_reader
*/
bool parse_bson_internal()
{
- std::int32_t document_size;
+ std::int32_t document_size{};
get_number<std::int32_t, true>(input_format_t::bson, document_size);
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_list(/*is_array*/false)))
+ if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
{
return false;
}
@@ -174,7 +183,7 @@ class binary_reader
while (true)
{
get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::bson, "cstring")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
{
return false;
}
@@ -184,8 +193,6 @@ class binary_reader
}
*out++ = static_cast<typename string_t::value_type>(current);
}
-
- return true;
}
/*!
@@ -208,7 +215,7 @@ class binary_reader
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string")));
}
- return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) and get() != std::char_traits<char_type>::eof();
+ return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
}
/*!
@@ -230,7 +237,7 @@ class binary_reader
}
// All BSON binary values have a subtype
- std::uint8_t subtype;
+ std::uint8_t subtype{};
get_number<std::uint8_t>(input_format_t::bson, subtype);
result.set_subtype(subtype);
@@ -254,15 +261,15 @@ class binary_reader
{
case 0x01: // double
{
- double number;
- return get_number<double, true>(input_format_t::bson, number) and sax->number_float(static_cast<number_float_t>(number), "");
+ double number{};
+ return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
}
case 0x02: // string
{
- std::int32_t len;
+ std::int32_t len{};
string_t value;
- return get_number<std::int32_t, true>(input_format_t::bson, len) and get_bson_string(len, value) and sax->string(value);
+ return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
}
case 0x03: // object
@@ -277,9 +284,9 @@ class binary_reader
case 0x05: // binary
{
- std::int32_t len;
+ std::int32_t len{};
binary_t value;
- return get_number<std::int32_t, true>(input_format_t::bson, len) and get_bson_binary(len, value) and sax->binary(value);
+ return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
}
case 0x08: // boolean
@@ -294,14 +301,14 @@ class binary_reader
case 0x10: // int32
{
- std::int32_t value;
- return get_number<std::int32_t, true>(input_format_t::bson, value) and sax->number_integer(value);
+ std::int32_t value{};
+ return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
}
case 0x12: // int64
{
- std::int64_t value;
- return get_number<std::int64_t, true>(input_format_t::bson, value) and sax->number_integer(value);
+ std::int64_t value{};
+ return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
}
default: // anything else not supported (yet)
@@ -331,23 +338,23 @@ class binary_reader
while (auto element_type = get())
{
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::bson, "element list")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
{
return false;
}
const std::size_t element_type_parse_position = chars_read;
- if (JSON_HEDLEY_UNLIKELY(not get_bson_cstr(key)))
+ if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
{
return false;
}
- if (not is_array and not sax->key(key))
+ if (!is_array && !sax->key(key))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_internal(element_type, element_type_parse_position)))
+ if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
{
return false;
}
@@ -365,15 +372,15 @@ class binary_reader
*/
bool parse_bson_array()
{
- std::int32_t document_size;
+ std::int32_t document_size{};
get_number<std::int32_t, true>(input_format_t::bson, document_size);
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_list(/*is_array*/true)))
+ if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
{
return false;
}
@@ -387,12 +394,14 @@ class binary_reader
/*!
@param[in] get_char whether a new character should be retrieved from the
- input (true, default) or whether the last read
- character should be considered instead
+ input (true) or whether the last read character should
+ be considered instead (false)
+ @param[in] tag_handler how CBOR tags should be treated
@return whether a valid CBOR value was passed to the SAX parser
*/
- bool parse_cbor_internal(const bool get_char = true)
+ bool parse_cbor_internal(const bool get_char,
+ const cbor_tag_handler_t tag_handler)
{
switch (get_char ? get() : current)
{
@@ -429,26 +438,26 @@ class binary_reader
case 0x18: // Unsigned integer (one-byte uint8_t follows)
{
- std::uint8_t number;
- return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
+ std::uint8_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
}
case 0x19: // Unsigned integer (two-byte uint16_t follows)
{
- std::uint16_t number;
- return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
+ std::uint16_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
}
case 0x1A: // Unsigned integer (four-byte uint32_t follows)
{
- std::uint32_t number;
- return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
+ std::uint32_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
}
case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
{
- std::uint64_t number;
- return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
+ std::uint64_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
}
// Negative integer -1-0x00..-1-0x17 (-1..-24)
@@ -480,26 +489,26 @@ class binary_reader
case 0x38: // Negative integer (one-byte uint8_t follows)
{
- std::uint8_t number;
- return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
+ std::uint8_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
}
case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
{
- std::uint16_t number;
- return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
+ std::uint16_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
}
case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
{
- std::uint32_t number;
- return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
+ std::uint32_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
}
case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
{
- std::uint64_t number;
- return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1)
+ std::uint64_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
- static_cast<number_integer_t>(number));
}
@@ -535,7 +544,7 @@ class binary_reader
case 0x5F: // Binary data (indefinite length)
{
binary_t b;
- return get_cbor_binary(b) and sax->binary(b);
+ return get_cbor_binary(b) && sax->binary(b);
}
// UTF-8 string (0x00..0x17 bytes follow)
@@ -570,7 +579,7 @@ class binary_reader
case 0x7F: // UTF-8 string (indefinite length)
{
string_t s;
- return get_cbor_string(s) and sax->string(s);
+ return get_cbor_string(s) && sax->string(s);
}
// array (0x00..0x17 data items follow)
@@ -598,34 +607,34 @@ class binary_reader
case 0x95:
case 0x96:
case 0x97:
- return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
+ return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
case 0x98: // array (one-byte uint8_t for n follows)
{
- std::uint8_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
+ std::uint8_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
}
case 0x99: // array (two-byte uint16_t for n follow)
{
- std::uint16_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
+ std::uint16_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
}
case 0x9A: // array (four-byte uint32_t for n follow)
{
- std::uint32_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
+ std::uint32_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
}
case 0x9B: // array (eight-byte uint64_t for n follow)
{
- std::uint64_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
+ std::uint64_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
}
case 0x9F: // array (indefinite length)
- return get_cbor_array(std::size_t(-1));
+ return get_cbor_array(std::size_t(-1), tag_handler);
// map (0x00..0x17 pairs of data items follow)
case 0xA0:
@@ -652,34 +661,101 @@ class binary_reader
case 0xB5:
case 0xB6:
case 0xB7:
- return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
+ return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
case 0xB8: // map (one-byte uint8_t for n follows)
{
- std::uint8_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
+ std::uint8_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
}
case 0xB9: // map (two-byte uint16_t for n follow)
{
- std::uint16_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
+ std::uint16_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
}
case 0xBA: // map (four-byte uint32_t for n follow)
{
- std::uint32_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
+ std::uint32_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
}
case 0xBB: // map (eight-byte uint64_t for n follow)
{
- std::uint64_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
+ std::uint64_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
}
case 0xBF: // map (indefinite length)
- return get_cbor_object(std::size_t(-1));
+ return get_cbor_object(std::size_t(-1), tag_handler);
+
+ case 0xC6: // tagged item
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD8: // tagged item (1 bytes follow)
+ case 0xD9: // tagged item (2 bytes follow)
+ case 0xDA: // tagged item (4 bytes follow)
+ case 0xDB: // tagged item (8 bytes follow)
+ {
+ switch (tag_handler)
+ {
+ case cbor_tag_handler_t::error:
+ {
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
+ }
+
+ case cbor_tag_handler_t::ignore:
+ {
+ switch (current)
+ {
+ case 0xD8:
+ {
+ std::uint8_t len{};
+ get_number(input_format_t::cbor, len);
+ break;
+ }
+ case 0xD9:
+ {
+ std::uint16_t len{};
+ get_number(input_format_t::cbor, len);
+ break;
+ }
+ case 0xDA:
+ {
+ std::uint32_t len{};
+ get_number(input_format_t::cbor, len);
+ break;
+ }
+ case 0xDB:
+ {
+ std::uint64_t len{};
+ get_number(input_format_t::cbor, len);
+ break;
+ }
+ default:
+ break;
+ }
+ return parse_cbor_internal(true, tag_handler);
+ }
+
+ default: // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
+ }
+ }
case 0xF4: // false
return sax->boolean(false);
@@ -693,12 +769,12 @@ class binary_reader
case 0xF9: // Half-Precision Float (two-byte IEEE 754)
{
const auto byte1_raw = get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
{
return false;
}
const auto byte2_raw = get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
{
return false;
}
@@ -719,8 +795,8 @@ class binary_reader
{
const int exp = (half >> 10u) & 0x1Fu;
const unsigned int mant = half & 0x3FFu;
- assert(0 <= exp and exp <= 32);
- assert(mant <= 1024);
+ JSON_ASSERT(0 <= exp&& exp <= 32);
+ JSON_ASSERT(mant <= 1024);
switch (exp)
{
case 0:
@@ -740,14 +816,14 @@ class binary_reader
case 0xFA: // Single-Precision Float (four-byte IEEE 754)
{
- float number;
- return get_number(input_format_t::cbor, number) and sax->number_float(static_cast<number_float_t>(number), "");
+ float number{};
+ return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
}
case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
{
- double number;
- return get_number(input_format_t::cbor, number) and sax->number_float(static_cast<number_float_t>(number), "");
+ double number{};
+ return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
}
default: // anything else (0xFF is handled inside the other types)
@@ -771,7 +847,7 @@ class binary_reader
*/
bool get_cbor_string(string_t& result)
{
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "string")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
{
return false;
}
@@ -809,26 +885,26 @@ class binary_reader
case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
{
- std::uint8_t len;
- return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
+ std::uint8_t len{};
+ return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
}
case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
{
- std::uint16_t len;
- return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
+ std::uint16_t len{};
+ return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
}
case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
{
- std::uint32_t len;
- return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
+ std::uint32_t len{};
+ return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
}
case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
{
- std::uint64_t len;
- return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
+ std::uint64_t len{};
+ return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
}
case 0x7F: // UTF-8 string (indefinite length)
@@ -836,7 +912,7 @@ class binary_reader
while (get() != 0xFF)
{
string_t chunk;
- if (not get_cbor_string(chunk))
+ if (!get_cbor_string(chunk))
{
return false;
}
@@ -866,7 +942,7 @@ class binary_reader
*/
bool get_cbor_binary(binary_t& result)
{
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "binary")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
{
return false;
}
@@ -904,29 +980,29 @@ class binary_reader
case 0x58: // Binary data (one-byte uint8_t for n follows)
{
- std::uint8_t len;
- return get_number(input_format_t::cbor, len) and
+ std::uint8_t len{};
+ return get_number(input_format_t::cbor, len) &&
get_binary(input_format_t::cbor, len, result);
}
case 0x59: // Binary data (two-byte uint16_t for n follow)
{
- std::uint16_t len;
- return get_number(input_format_t::cbor, len) and
+ std::uint16_t len{};
+ return get_number(input_format_t::cbor, len) &&
get_binary(input_format_t::cbor, len, result);
}
case 0x5A: // Binary data (four-byte uint32_t for n follow)
{
- std::uint32_t len;
- return get_number(input_format_t::cbor, len) and
+ std::uint32_t len{};
+ return get_number(input_format_t::cbor, len) &&
get_binary(input_format_t::cbor, len, result);
}
case 0x5B: // Binary data (eight-byte uint64_t for n follow)
{
- std::uint64_t len;
- return get_number(input_format_t::cbor, len) and
+ std::uint64_t len{};
+ return get_number(input_format_t::cbor, len) &&
get_binary(input_format_t::cbor, len, result);
}
@@ -935,7 +1011,7 @@ class binary_reader
while (get() != 0xFF)
{
binary_t chunk;
- if (not get_cbor_binary(chunk))
+ if (!get_cbor_binary(chunk))
{
return false;
}
@@ -955,11 +1031,13 @@ class binary_reader
/*!
@param[in] len the length of the array or std::size_t(-1) for an
array of indefinite size
+ @param[in] tag_handler how CBOR tags should be treated
@return whether array creation completed
*/
- bool get_cbor_array(const std::size_t len)
+ bool get_cbor_array(const std::size_t len,
+ const cbor_tag_handler_t tag_handler)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(len)))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
{
return false;
}
@@ -968,7 +1046,7 @@ class binary_reader
{
for (std::size_t i = 0; i < len; ++i)
{
- if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
+ if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
{
return false;
}
@@ -978,7 +1056,7 @@ class binary_reader
{
while (get() != 0xFF)
{
- if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal(false)))
+ if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
{
return false;
}
@@ -991,11 +1069,13 @@ class binary_reader
/*!
@param[in] len the length of the object or std::size_t(-1) for an
object of indefinite size
+ @param[in] tag_handler how CBOR tags should be treated
@return whether object creation completed
*/
- bool get_cbor_object(const std::size_t len)
+ bool get_cbor_object(const std::size_t len,
+ const cbor_tag_handler_t tag_handler)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(len)))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
{
return false;
}
@@ -1006,12 +1086,12 @@ class binary_reader
for (std::size_t i = 0; i < len; ++i)
{
get();
- if (JSON_HEDLEY_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
+ if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
+ if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
{
return false;
}
@@ -1022,12 +1102,12 @@ class binary_reader
{
while (get() != 0xFF)
{
- if (JSON_HEDLEY_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
+ if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
+ if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
{
return false;
}
@@ -1260,7 +1340,7 @@ class binary_reader
case 0xDB: // str 32
{
string_t s;
- return get_msgpack_string(s) and sax->string(s);
+ return get_msgpack_string(s) && sax->string(s);
}
case 0xC0: // nil
@@ -1285,91 +1365,91 @@ class binary_reader
case 0xD8: // fixext 16
{
binary_t b;
- return get_msgpack_binary(b) and sax->binary(b);
+ return get_msgpack_binary(b) && sax->binary(b);
}
case 0xCA: // float 32
{
- float number;
- return get_number(input_format_t::msgpack, number) and sax->number_float(static_cast<number_float_t>(number), "");
+ float number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
}
case 0xCB: // float 64
{
- double number;
- return get_number(input_format_t::msgpack, number) and sax->number_float(static_cast<number_float_t>(number), "");
+ double number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
}
case 0xCC: // uint 8
{
- std::uint8_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
+ std::uint8_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
}
case 0xCD: // uint 16
{
- std::uint16_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
+ std::uint16_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
}
case 0xCE: // uint 32
{
- std::uint32_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
+ std::uint32_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
}
case 0xCF: // uint 64
{
- std::uint64_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
+ std::uint64_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
}
case 0xD0: // int 8
{
- std::int8_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
+ std::int8_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
}
case 0xD1: // int 16
{
- std::int16_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
+ std::int16_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
}
case 0xD2: // int 32
{
- std::int32_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
+ std::int32_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
}
case 0xD3: // int 64
{
- std::int64_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
+ std::int64_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
}
case 0xDC: // array 16
{
- std::uint16_t len;
- return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
+ std::uint16_t len{};
+ return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
}
case 0xDD: // array 32
{
- std::uint32_t len;
- return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
+ std::uint32_t len{};
+ return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
}
case 0xDE: // map 16
{
- std::uint16_t len;
- return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
+ std::uint16_t len{};
+ return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
}
case 0xDF: // map 32
{
- std::uint32_t len;
- return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
+ std::uint32_t len{};
+ return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
}
// negative fixint
@@ -1427,7 +1507,7 @@ class binary_reader
*/
bool get_msgpack_string(string_t& result)
{
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::msgpack, "string")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
{
return false;
}
@@ -1473,20 +1553,20 @@ class binary_reader
case 0xD9: // str 8
{
- std::uint8_t len;
- return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
+ std::uint8_t len{};
+ return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
}
case 0xDA: // str 16
{
- std::uint16_t len;
- return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
+ std::uint16_t len{};
+ return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
}
case 0xDB: // str 32
{
- std::uint32_t len;
- return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
+ std::uint32_t len{};
+ return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
}
default:
@@ -1520,92 +1600,92 @@ class binary_reader
{
case 0xC4: // bin 8
{
- std::uint8_t len;
- return get_number(input_format_t::msgpack, len) and
+ std::uint8_t len{};
+ return get_number(input_format_t::msgpack, len) &&
get_binary(input_format_t::msgpack, len, result);
}
case 0xC5: // bin 16
{
- std::uint16_t len;
- return get_number(input_format_t::msgpack, len) and
+ std::uint16_t len{};
+ return get_number(input_format_t::msgpack, len) &&
get_binary(input_format_t::msgpack, len, result);
}
case 0xC6: // bin 32
{
- std::uint32_t len;
- return get_number(input_format_t::msgpack, len) and
+ std::uint32_t len{};
+ return get_number(input_format_t::msgpack, len) &&
get_binary(input_format_t::msgpack, len, result);
}
case 0xC7: // ext 8
{
- std::uint8_t len;
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, len) and
- get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, len, result) and
+ std::uint8_t len{};
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, len) &&
+ get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, len, result) &&
assign_and_return_true(subtype);
}
case 0xC8: // ext 16
{
- std::uint16_t len;
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, len) and
- get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, len, result) and
+ std::uint16_t len{};
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, len) &&
+ get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, len, result) &&
assign_and_return_true(subtype);
}
case 0xC9: // ext 32
{
- std::uint32_t len;
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, len) and
- get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, len, result) and
+ std::uint32_t len{};
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, len) &&
+ get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, len, result) &&
assign_and_return_true(subtype);
}
case 0xD4: // fixext 1
{
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, 1, result) and
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, 1, result) &&
assign_and_return_true(subtype);
}
case 0xD5: // fixext 2
{
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, 2, result) and
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, 2, result) &&
assign_and_return_true(subtype);
}
case 0xD6: // fixext 4
{
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, 4, result) and
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, 4, result) &&
assign_and_return_true(subtype);
}
case 0xD7: // fixext 8
{
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, 8, result) and
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, 8, result) &&
assign_and_return_true(subtype);
}
case 0xD8: // fixext 16
{
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, 16, result) and
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, 16, result) &&
assign_and_return_true(subtype);
}
@@ -1620,14 +1700,14 @@ class binary_reader
*/
bool get_msgpack_array(const std::size_t len)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(len)))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
{
return false;
}
for (std::size_t i = 0; i < len; ++i)
{
- if (JSON_HEDLEY_UNLIKELY(not parse_msgpack_internal()))
+ if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
{
return false;
}
@@ -1642,7 +1722,7 @@ class binary_reader
*/
bool get_msgpack_object(const std::size_t len)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(len)))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
{
return false;
}
@@ -1651,12 +1731,12 @@ class binary_reader
for (std::size_t i = 0; i < len; ++i)
{
get();
- if (JSON_HEDLEY_UNLIKELY(not get_msgpack_string(key) or not sax->key(key)))
+ if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_msgpack_internal()))
+ if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
{
return false;
}
@@ -1703,7 +1783,7 @@ class binary_reader
get(); // TODO(niels): may we ignore N here?
}
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
{
return false;
}
@@ -1712,32 +1792,32 @@ class binary_reader
{
case 'U':
{
- std::uint8_t len;
- return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+ std::uint8_t len{};
+ return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
}
case 'i':
{
- std::int8_t len;
- return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+ std::int8_t len{};
+ return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
}
case 'I':
{
- std::int16_t len;
- return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+ std::int16_t len{};
+ return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
}
case 'l':
{
- std::int32_t len;
- return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+ std::int32_t len{};
+ return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
}
case 'L':
{
- std::int64_t len;
- return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+ std::int64_t len{};
+ return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
}
default:
@@ -1756,8 +1836,8 @@ class binary_reader
{
case 'U':
{
- std::uint8_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+ std::uint8_t number{};
+ if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
{
return false;
}
@@ -1767,8 +1847,8 @@ class binary_reader
case 'i':
{
- std::int8_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+ std::int8_t number{};
+ if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
{
return false;
}
@@ -1778,8 +1858,8 @@ class binary_reader
case 'I':
{
- std::int16_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+ std::int16_t number{};
+ if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
{
return false;
}
@@ -1789,8 +1869,8 @@ class binary_reader
case 'l':
{
- std::int32_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+ std::int32_t number{};
+ if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
{
return false;
}
@@ -1800,8 +1880,8 @@ class binary_reader
case 'L':
{
- std::int64_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+ std::int64_t number{};
+ if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
{
return false;
}
@@ -1837,7 +1917,7 @@ class binary_reader
if (current == '$')
{
result.second = get(); // must not ignore 'N', because 'N' maybe the type
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "type")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "type")))
{
return false;
}
@@ -1845,7 +1925,7 @@ class binary_reader
get_ignore_noop();
if (JSON_HEDLEY_UNLIKELY(current != '#'))
{
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
{
return false;
}
@@ -1885,50 +1965,55 @@ class binary_reader
case 'U':
{
- std::uint8_t number;
- return get_number(input_format_t::ubjson, number) and sax->number_unsigned(number);
+ std::uint8_t number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
}
case 'i':
{
- std::int8_t number;
- return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
+ std::int8_t number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
}
case 'I':
{
- std::int16_t number;
- return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
+ std::int16_t number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
}
case 'l':
{
- std::int32_t number;
- return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
+ std::int32_t number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
}
case 'L':
{
- std::int64_t number;
- return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
+ std::int64_t number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
}
case 'd':
{
- float number;
- return get_number(input_format_t::ubjson, number) and sax->number_float(static_cast<number_float_t>(number), "");
+ float number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
}
case 'D':
{
- double number;
- return get_number(input_format_t::ubjson, number) and sax->number_float(static_cast<number_float_t>(number), "");
+ double number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+ }
+
+ case 'H':
+ {
+ return get_ubjson_high_precision_number();
}
case 'C': // char
{
get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "char")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "char")))
{
return false;
}
@@ -1944,7 +2029,7 @@ class binary_reader
case 'S': // string
{
string_t s;
- return get_ubjson_string(s) and sax->string(s);
+ return get_ubjson_string(s) && sax->string(s);
}
case '[': // array
@@ -1967,14 +2052,14 @@ class binary_reader
bool get_ubjson_array()
{
std::pair<std::size_t, char_int_type> size_and_type;
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_size_type(size_and_type)))
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
{
return false;
}
if (size_and_type.first != string_t::npos)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(size_and_type.first)))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
{
return false;
}
@@ -1985,7 +2070,7 @@ class binary_reader
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_value(size_and_type.second)))
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
{
return false;
}
@@ -1996,7 +2081,7 @@ class binary_reader
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
- if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
+ if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
{
return false;
}
@@ -2005,14 +2090,14 @@ class binary_reader
}
else
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
{
return false;
}
while (current != ']')
{
- if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal(false)))
+ if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
{
return false;
}
@@ -2029,7 +2114,7 @@ class binary_reader
bool get_ubjson_object()
{
std::pair<std::size_t, char_int_type> size_and_type;
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_size_type(size_and_type)))
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
{
return false;
}
@@ -2037,7 +2122,7 @@ class binary_reader
string_t key;
if (size_and_type.first != string_t::npos)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(size_and_type.first)))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
{
return false;
}
@@ -2046,11 +2131,11 @@ class binary_reader
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_value(size_and_type.second)))
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
{
return false;
}
@@ -2061,11 +2146,11 @@ class binary_reader
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
+ if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
{
return false;
}
@@ -2075,18 +2160,18 @@ class binary_reader
}
else
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
{
return false;
}
while (current != '}')
{
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key, false) or not sax->key(key)))
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
+ if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
{
return false;
}
@@ -2101,6 +2186,55 @@ class binary_reader
// Note, no reader for UBJSON binary types is implemented because they do
// not exist
+ bool get_ubjson_high_precision_number()
+ {
+ // get size of following number string
+ std::size_t size{};
+ auto res = get_ubjson_size_value(size);
+ if (JSON_HEDLEY_UNLIKELY(!res))
+ {
+ return res;
+ }
+
+ // get number string
+ std::vector<char> number_vector;
+ for (std::size_t i = 0; i < size; ++i)
+ {
+ get();
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "number")))
+ {
+ return false;
+ }
+ number_vector.push_back(static_cast<char>(current));
+ }
+
+ // parse number string
+ auto number_ia = detail::input_adapter(std::forward<decltype(number_vector)>(number_vector));
+ auto number_lexer = detail::lexer<BasicJsonType, decltype(number_ia)>(std::move(number_ia), false);
+ const auto result_number = number_lexer.scan();
+ const auto number_string = number_lexer.get_token_string();
+ const auto result_remainder = number_lexer.scan();
+
+ using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
+
+ if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
+ {
+ return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
+ }
+
+ switch (result_number)
+ {
+ case token_type::value_integer:
+ return sax->number_integer(number_lexer.get_number_integer());
+ case token_type::value_unsigned:
+ return sax->number_unsigned(number_lexer.get_number_unsigned());
+ case token_type::value_float:
+ return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
+ default:
+ return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
+ }
+ }
+
///////////////////////
// Utility functions //
///////////////////////
@@ -2155,7 +2289,7 @@ class binary_reader
for (std::size_t i = 0; i < sizeof(NumberType); ++i)
{
get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "number")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
{
return false;
}
@@ -2196,15 +2330,16 @@ class binary_reader
string_t& result)
{
bool success = true;
- std::generate_n(std::back_inserter(result), len, [this, &success, &format]()
+ for (NumberType i = 0; i < len; i++)
{
get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "string")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
{
success = false;
+ break;
}
- return std::char_traits<char_type>::to_char_type(current);
- });
+ result.push_back(static_cast<typename string_t::value_type>(current));
+ };
return success;
}
@@ -2228,15 +2363,16 @@ class binary_reader
binary_t& result)
{
bool success = true;
- std::generate_n(std::back_inserter(result), len, [this, &success, &format]()
+ for (NumberType i = 0; i < len; i++)
{
get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "binary")))
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
{
success = false;
+ break;
}
- return static_cast<std::uint8_t>(current);
- });
+ result.push_back(static_cast<std::uint8_t>(current));
+ }
return success;
}
@@ -2297,7 +2433,7 @@ class binary_reader
break;
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
return error_msg + " " + context + ": " + detail;
diff --git a/include/nlohmann/detail/input/input_adapters.hpp b/include/nlohmann/detail/input/input_adapters.hpp
index ed9db0f6..63921ca5 100644
--- a/include/nlohmann/detail/input/input_adapters.hpp
+++ b/include/nlohmann/detail/input/input_adapters.hpp
@@ -1,7 +1,6 @@
#pragma once
#include <array> // array
-#include <cassert> // assert
#include <cstddef> // size_t
#include <cstdio> //FILE *
#include <cstring> // strlen
@@ -37,7 +36,7 @@ class file_input_adapter
using char_type = char;
JSON_HEDLEY_NON_NULL(2)
- explicit file_input_adapter(std::FILE* f) noexcept
+ explicit file_input_adapter(std::FILE* f) noexcept
: m_file(f)
{}
@@ -76,7 +75,7 @@ class input_stream_adapter
{
// clear stream flags; we use underlying streambuf I/O, do not
// maintain ifstream flags, except eof
- if (is)
+ if (is != nullptr)
{
is->clear(is->rdstate() & std::ios::eofbit);
}
@@ -91,7 +90,7 @@ class input_stream_adapter
input_stream_adapter& operator=(input_stream_adapter&) = delete;
input_stream_adapter& operator=(input_stream_adapter&& rhs) = delete;
- input_stream_adapter(input_stream_adapter&& rhs) : is(rhs.is), sb(rhs.sb)
+ input_stream_adapter(input_stream_adapter&& rhs) noexcept : is(rhs.is), sb(rhs.sb)
{
rhs.is = nullptr;
rhs.sb = nullptr;
@@ -251,7 +250,7 @@ struct wide_string_input_helper<BaseInputAdapter, 2>
utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
utf8_bytes_filled = 2;
}
- else if (0xD800 > wc or wc >= 0xE000)
+ else if (0xD800 > wc || wc >= 0xE000)
{
utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
@@ -260,7 +259,7 @@ struct wide_string_input_helper<BaseInputAdapter, 2>
}
else
{
- if (JSON_HEDLEY_UNLIKELY(not input.empty()))
+ if (JSON_HEDLEY_UNLIKELY(!input.empty()))
{
const auto wc2 = static_cast<unsigned int>(input.get_character());
const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
@@ -297,13 +296,13 @@ class wide_string_input_adapter
{
fill_buffer<sizeof(WideCharType)>();
- assert(utf8_bytes_filled > 0);
- assert(utf8_bytes_index == 0);
+ JSON_ASSERT(utf8_bytes_filled > 0);
+ JSON_ASSERT(utf8_bytes_index == 0);
}
// use buffer
- assert(utf8_bytes_filled > 0);
- assert(utf8_bytes_index < utf8_bytes_filled);
+ JSON_ASSERT(utf8_bytes_filled > 0);
+ JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
return utf8_bytes[utf8_bytes_index++];
}
@@ -403,15 +402,15 @@ using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const
// Null-delimited strings, and the like.
template < typename CharT,
typename std::enable_if <
- std::is_pointer<CharT>::value and
- not std::is_array<CharT>::value and
- std::is_integral<typename std::remove_pointer<CharT>::type>::value and
+ std::is_pointer<CharT>::value&&
+ !std::is_array<CharT>::value&&
+ std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
sizeof(typename std::remove_pointer<CharT>::type) == 1,
int >::type = 0 >
contiguous_bytes_input_adapter input_adapter(CharT b)
{
auto length = std::strlen(reinterpret_cast<const char*>(b));
- auto ptr = reinterpret_cast<const char*>(b);
+ const auto* ptr = reinterpret_cast<const char*>(b);
return input_adapter(ptr, ptr + length);
}
@@ -427,12 +426,12 @@ auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N))
class span_input_adapter
{
public:
- template<typename CharT,
- typename std::enable_if<
- std::is_pointer<CharT>::value and
- std::is_integral<typename std::remove_pointer<CharT>::type>::value and
- sizeof(typename std::remove_pointer<CharT>::type) == 1,
- int>::type = 0>
+ template < typename CharT,
+ typename std::enable_if <
+ std::is_pointer<CharT>::value&&
+ std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+ sizeof(typename std::remove_pointer<CharT>::type) == 1,
+ int >::type = 0 >
span_input_adapter(CharT b, std::size_t l)
: ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
diff --git a/include/nlohmann/detail/input/json_sax.hpp b/include/nlohmann/detail/input/json_sax.hpp
index 66b08bff..223acd60 100644
--- a/include/nlohmann/detail/input/json_sax.hpp
+++ b/include/nlohmann/detail/input/json_sax.hpp
@@ -1,6 +1,5 @@
#pragma once
-#include <cassert> // assert
#include <cstddef>
#include <string> // string
#include <utility> // move
@@ -218,7 +217,7 @@ class json_sax_dom_parser
{
ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
- if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+ if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len)));
@@ -244,7 +243,7 @@ class json_sax_dom_parser
{
ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
- if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+ if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len)));
@@ -259,30 +258,15 @@ class json_sax_dom_parser
return true;
}
+ template<class Exception>
bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
- const detail::exception& ex)
+ const Exception& ex)
{
errored = true;
+ static_cast<void>(ex);
if (allow_exceptions)
{
- // determine the proper exception type from the id
- switch ((ex.id / 100) % 100)
- {
- case 1:
- JSON_THROW(*static_cast<const detail::parse_error*>(&ex));
- case 4:
- JSON_THROW(*static_cast<const detail::out_of_range*>(&ex));
- // LCOV_EXCL_START
- case 2:
- JSON_THROW(*static_cast<const detail::invalid_iterator*>(&ex));
- case 3:
- JSON_THROW(*static_cast<const detail::type_error*>(&ex));
- case 5:
- JSON_THROW(*static_cast<const detail::other_error*>(&ex));
- default:
- assert(false);
- // LCOV_EXCL_STOP
- }
+ JSON_THROW(ex);
}
return false;
}
@@ -309,7 +293,7 @@ class json_sax_dom_parser
return &root;
}
- assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
+ JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
if (ref_stack.back()->is_array())
{
@@ -317,8 +301,8 @@ class json_sax_dom_parser
return &(ref_stack.back()->m_value.array->back());
}
- assert(ref_stack.back()->is_object());
- assert(object_element);
+ JSON_ASSERT(ref_stack.back()->is_object());
+ JSON_ASSERT(object_element);
*object_element = BasicJsonType(std::forward<Value>(v));
return object_element;
}
@@ -414,7 +398,7 @@ class json_sax_dom_callback_parser
ref_stack.push_back(val.second);
// check object limit
- if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+ if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len)));
}
@@ -431,7 +415,7 @@ class json_sax_dom_callback_parser
key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later
- if (keep and ref_stack.back())
+ if (keep && ref_stack.back())
{
object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
}
@@ -441,18 +425,18 @@ class json_sax_dom_callback_parser
bool end_object()
{
- if (ref_stack.back() and not callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
+ if (ref_stack.back() && !callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
{
// discard object
*ref_stack.back() = discarded;
}
- assert(not ref_stack.empty());
- assert(not keep_stack.empty());
+ JSON_ASSERT(!ref_stack.empty());
+ JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
- if (not ref_stack.empty() and ref_stack.back() and ref_stack.back()->is_structured())
+ if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
{
// remove discarded value
for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
@@ -477,7 +461,7 @@ class json_sax_dom_callback_parser
ref_stack.push_back(val.second);
// check array limit
- if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+ if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len)));
}
@@ -492,20 +476,20 @@ class json_sax_dom_callback_parser
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
- if (not keep)
+ if (!keep)
{
// discard array
*ref_stack.back() = discarded;
}
}
- assert(not ref_stack.empty());
- assert(not keep_stack.empty());
+ JSON_ASSERT(!ref_stack.empty());
+ JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
// remove discarded value
- if (not keep and not ref_stack.empty() and ref_stack.back()->is_array())
+ if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
{
ref_stack.back()->m_value.array->pop_back();
}
@@ -513,30 +497,15 @@ class json_sax_dom_callback_parser
return true;
}
+ template<class Exception>
bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
- const detail::exception& ex)
+ const Exception& ex)
{
errored = true;
+ static_cast<void>(ex);
if (allow_exceptions)
{
- // determine the proper exception type from the id
- switch ((ex.id / 100) % 100)
- {
- case 1:
- JSON_THROW(*static_cast<const detail::parse_error*>(&ex));
- case 4:
- JSON_THROW(*static_cast<const detail::out_of_range*>(&ex));
- // LCOV_EXCL_START
- case 2:
- JSON_THROW(*static_cast<const detail::invalid_iterator*>(&ex));
- case 3:
- JSON_THROW(*static_cast<const detail::type_error*>(&ex));
- case 5:
- JSON_THROW(*static_cast<const detail::other_error*>(&ex));
- default:
- assert(false);
- // LCOV_EXCL_STOP
- }
+ JSON_THROW(ex);
}
return false;
}
@@ -565,11 +534,11 @@ class json_sax_dom_callback_parser
template<typename Value>
std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
- assert(not keep_stack.empty());
+ JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
- if (not keep_stack.back())
+ if (!keep_stack.back())
{
return {false, nullptr};
}
@@ -578,10 +547,10 @@ class json_sax_dom_callback_parser
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
- const bool keep = skip_callback or callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
+ const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
- if (not keep)
+ if (!keep)
{
return {false, nullptr};
}
@@ -594,13 +563,13 @@ class json_sax_dom_callback_parser
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
- if (not ref_stack.back())
+ if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
- assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
+ JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
@@ -610,18 +579,18 @@ class json_sax_dom_callback_parser
}
// object
- assert(ref_stack.back()->is_object());
+ JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
- assert(not key_keep_stack.empty());
+ JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
- if (not store_element)
+ if (!store_element)
{
return {false, nullptr};
}
- assert(object_element);
+ JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
}
diff --git a/include/nlohmann/detail/input/lexer.hpp b/include/nlohmann/detail/input/lexer.hpp
index 0ff0c736..60eb3526 100644
--- a/include/nlohmann/detail/input/lexer.hpp
+++ b/include/nlohmann/detail/input/lexer.hpp
@@ -112,8 +112,11 @@ class lexer : public lexer_base<BasicJsonType>
public:
using token_type = typename lexer_base<BasicJsonType>::token_type;
- explicit lexer(InputAdapterType&& adapter)
- : ia(std::move(adapter)), decimal_point_char(static_cast<char_int_type>(get_decimal_point())) {}
+ explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false)
+ : ia(std::move(adapter))
+ , ignore_comments(ignore_comments_)
+ , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
+ {}
// delete because of pointer members
lexer(const lexer&) = delete;
@@ -131,8 +134,8 @@ class lexer : public lexer_base<BasicJsonType>
JSON_HEDLEY_PURE
static char get_decimal_point() noexcept
{
- const auto loc = localeconv();
- assert(loc != nullptr);
+ const auto* loc = localeconv();
+ JSON_ASSERT(loc != nullptr);
return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
}
@@ -158,7 +161,7 @@ class lexer : public lexer_base<BasicJsonType>
int get_codepoint()
{
// this function only makes sense after reading `\u`
- assert(current == 'u');
+ JSON_ASSERT(current == 'u');
int codepoint = 0;
const auto factors = { 12u, 8u, 4u, 0u };
@@ -166,15 +169,15 @@ class lexer : public lexer_base<BasicJsonType>
{
get();
- if (current >= '0' and current <= '9')
+ if (current >= '0' && current <= '9')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
}
- else if (current >= 'A' and current <= 'F')
+ else if (current >= 'A' && current <= 'F')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
}
- else if (current >= 'a' and current <= 'f')
+ else if (current >= 'a' && current <= 'f')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
}
@@ -184,7 +187,7 @@ class lexer : public lexer_base<BasicJsonType>
}
}
- assert(0x0000 <= codepoint and codepoint <= 0xFFFF);
+ JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
return codepoint;
}
@@ -205,13 +208,13 @@ class lexer : public lexer_base<BasicJsonType>
*/
bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{
- assert(ranges.size() == 2 or ranges.size() == 4 or ranges.size() == 6);
+ JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
- if (JSON_HEDLEY_LIKELY(*range <= current and current <= *(++range)))
+ if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
{
add(current);
}
@@ -246,7 +249,7 @@ class lexer : public lexer_base<BasicJsonType>
reset();
// we entered the function by reading an open quote
- assert(current == '\"');
+ JSON_ASSERT(current == '\"');
while (true)
{
@@ -317,10 +320,10 @@ class lexer : public lexer_base<BasicJsonType>
}
// check if code point is a high surrogate
- if (0xD800 <= codepoint1 and codepoint1 <= 0xDBFF)
+ if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
{
// expect next \uxxxx entry
- if (JSON_HEDLEY_LIKELY(get() == '\\' and get() == 'u'))
+ if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
{
const int codepoint2 = get_codepoint();
@@ -331,7 +334,7 @@ class lexer : public lexer_base<BasicJsonType>
}
// check if codepoint2 is a low surrogate
- if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF))
+ if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
{
// overwrite codepoint
codepoint = static_cast<int>(
@@ -358,7 +361,7 @@ class lexer : public lexer_base<BasicJsonType>
}
else
{
- if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 and codepoint1 <= 0xDFFF))
+ if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
{
error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
return token_type::parse_error;
@@ -366,7 +369,7 @@ class lexer : public lexer_base<BasicJsonType>
}
// result of the above calculation yields a proper codepoint
- assert(0x00 <= codepoint and codepoint <= 0x10FFFF);
+ JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
// translate codepoint into bytes
if (codepoint < 0x80)
@@ -733,7 +736,7 @@ class lexer : public lexer_base<BasicJsonType>
case 0xDE:
case 0xDF:
{
- if (JSON_HEDLEY_UNLIKELY(not next_byte_in_range({0x80, 0xBF})))
+ if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
{
return token_type::parse_error;
}
@@ -743,7 +746,7 @@ class lexer : public lexer_base<BasicJsonType>
// U+0800..U+0FFF: bytes E0 A0..BF 80..BF
case 0xE0:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
+ if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -767,7 +770,7 @@ class lexer : public lexer_base<BasicJsonType>
case 0xEE:
case 0xEF:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
+ if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -777,7 +780,7 @@ class lexer : public lexer_base<BasicJsonType>
// U+D000..U+D7FF: bytes ED 80..9F 80..BF
case 0xED:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
+ if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -787,7 +790,7 @@ class lexer : public lexer_base<BasicJsonType>
// U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
case 0xF0:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+ if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -799,7 +802,7 @@ class lexer : public lexer_base<BasicJsonType>
case 0xF2:
case 0xF3:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+ if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -809,7 +812,7 @@ class lexer : public lexer_base<BasicJsonType>
// U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
case 0xF4:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
+ if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -826,6 +829,77 @@ class lexer : public lexer_base<BasicJsonType>
}
}
+ /*!
+ * @brief scan a comment
+ * @return whether comment could be scanned successfully
+ */
+ bool scan_comment()
+ {
+ switch (get())
+ {
+ // single-line comments skip input until a newline or EOF is read
+ case '/':
+ {
+ while (true)
+ {
+ switch (get())
+ {
+ case '\n':
+ case '\r':
+ case std::char_traits<char_type>::eof():
+ case '\0':
+ return true;
+
+ default:
+ break;
+ }
+ }
+ }
+
+ // multi-line comments skip input until */ is read
+ case '*':
+ {
+ while (true)
+ {
+ switch (get())
+ {
+ case std::char_traits<char_type>::eof():
+ case '\0':
+ {
+ error_message = "invalid comment; missing closing '*/'";
+ return false;
+ }
+
+ case '*':
+ {
+ switch (get())
+ {
+ case '/':
+ return true;
+
+ default:
+ {
+ unget();
+ break;
+ }
+ }
+ }
+
+ default:
+ break;
+ }
+ }
+ }
+
+ // unexpected character after reading '/'
+ default:
+ {
+ error_message = "invalid comment; expecting '/' or '*' after '/'";
+ return false;
+ }
+ }
+ }
+
JSON_HEDLEY_NON_NULL(2)
static void strtof(float& f, const char* str, char** endptr) noexcept
{
@@ -924,7 +998,7 @@ class lexer : public lexer_base<BasicJsonType>
// all other characters are rejected outside scan_number()
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
scan_number_minus:
@@ -1171,7 +1245,7 @@ scan_number_done:
const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
// we checked the number format before
- assert(endptr == token_buffer.data() + token_buffer.size());
+ JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
if (errno == 0)
{
@@ -1187,7 +1261,7 @@ scan_number_done:
const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
// we checked the number format before
- assert(endptr == token_buffer.data() + token_buffer.size());
+ JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
if (errno == 0)
{
@@ -1204,7 +1278,7 @@ scan_number_done:
strtof(value_float, token_buffer.data(), &endptr);
// we checked the number format before
- assert(endptr == token_buffer.data() + token_buffer.size());
+ JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
return token_type::value_float;
}
@@ -1218,7 +1292,7 @@ scan_number_done:
token_type scan_literal(const char_type* literal_text, const std::size_t length,
token_type return_type)
{
- assert(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
+ JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
for (std::size_t i = 1; i < length; ++i)
{
if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
@@ -1310,7 +1384,7 @@ scan_number_done:
if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
{
- assert(not token_string.empty());
+ JSON_ASSERT(!token_string.empty());
token_string.pop_back();
}
}
@@ -1406,7 +1480,7 @@ scan_number_done:
if (get() == 0xEF)
{
// check if we completely parse the BOM
- return get() == 0xBB and get() == 0xBF;
+ return get() == 0xBB && get() == 0xBF;
}
// the first character is not the beginning of the BOM; unget it to
@@ -1415,21 +1489,38 @@ scan_number_done:
return true;
}
+ void skip_whitespace()
+ {
+ do
+ {
+ get();
+ }
+ while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
+ }
+
token_type scan()
{
// initially, skip the BOM
- if (position.chars_read_total == 0 and not skip_bom())
+ if (position.chars_read_total == 0 && !skip_bom())
{
error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
return token_type::parse_error;
}
// read next character and ignore whitespace
- do
+ skip_whitespace();
+
+ // ignore comments
+ if (ignore_comments && current == '/')
{
- get();
+ if (!scan_comment())
+ {
+ return token_type::parse_error;
+ }
+
+ // skip following whitespace
+ skip_whitespace();
}
- while (current == ' ' or current == '\t' or current == '\n' or current == '\r');
switch (current)
{
@@ -1499,6 +1590,9 @@ scan_number_done:
/// input adapter
InputAdapterType ia;
+ /// whether comments should be ignored (true) or signaled as errors (false)
+ const bool ignore_comments = false;
+
/// the current character
char_int_type current = std::char_traits<char_type>::eof();
diff --git a/include/nlohmann/detail/input/parser.hpp b/include/nlohmann/detail/input/parser.hpp
index 0546b88c..ffe483aa 100644
--- a/include/nlohmann/detail/input/parser.hpp
+++ b/include/nlohmann/detail/input/parser.hpp
@@ -1,6 +1,5 @@
#pragma once
-#include <cassert> // assert
#include <cmath> // isfinite
#include <cstdint> // uint8_t
#include <functional> // function
@@ -63,8 +62,11 @@ class parser
/// a parser reading from an input adapter
explicit parser(InputAdapterType&& adapter,
const parser_callback_t<BasicJsonType> cb = nullptr,
- const bool allow_exceptions_ = true)
- : callback(cb), m_lexer(std::move(adapter)), allow_exceptions(allow_exceptions_)
+ const bool allow_exceptions_ = true,
+ const bool skip_comments = false)
+ : callback(cb)
+ , m_lexer(std::move(adapter), skip_comments)
+ , allow_exceptions(allow_exceptions_)
{
// read first token
get_token();
@@ -89,7 +91,7 @@ class parser
result.assert_invariant();
// in strict mode, input must be completely read
- if (strict and (get_token() != token_type::end_of_input))
+ if (strict && (get_token() != token_type::end_of_input))
{
sdp.parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
@@ -118,7 +120,7 @@ class parser
result.assert_invariant();
// in strict mode, input must be completely read
- if (strict and (get_token() != token_type::end_of_input))
+ if (strict && (get_token() != token_type::end_of_input))
{
sdp.parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
@@ -147,7 +149,7 @@ class parser
return sax_parse(&sax_acceptor, strict);
}
- template <typename SAX>
+ template<typename SAX>
JSON_HEDLEY_NON_NULL(2)
bool sax_parse(SAX* sax, const bool strict = true)
{
@@ -155,7 +157,7 @@ class parser
const bool result = sax_parse_internal(sax);
// strict mode: next byte must be EOF
- if (result and strict and (get_token() != token_type::end_of_input))
+ if (result && strict && (get_token() != token_type::end_of_input))
{
return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
@@ -167,7 +169,7 @@ class parser
}
private:
- template <typename SAX>
+ template<typename SAX>
JSON_HEDLEY_NON_NULL(2)
bool sax_parse_internal(SAX* sax)
{
@@ -179,14 +181,14 @@ class parser
while (true)
{
- if (not skip_to_state_evaluation)
+ if (!skip_to_state_evaluation)
{
// invariant: get_token() was called before each iteration
switch (last_token)
{
case token_type::begin_object:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
{
return false;
}
@@ -194,7 +196,7 @@ class parser
// closing } -> we are done
if (get_token() == token_type::end_object)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
+ if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
{
return false;
}
@@ -209,7 +211,7 @@ class parser
parse_error::create(101, m_lexer.get_position(),
exception_message(token_type::value_string, "object key")));
}
- if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
+ if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
{
return false;
}
@@ -233,7 +235,7 @@ class parser
case token_type::begin_array:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
{
return false;
}
@@ -241,7 +243,7 @@ class parser
// closing ] -> we are done
if (get_token() == token_type::end_array)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
+ if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
{
return false;
}
@@ -259,14 +261,14 @@ class parser
{
const auto res = m_lexer.get_number_float();
- if (JSON_HEDLEY_UNLIKELY(not std::isfinite(res)))
+ if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
{
return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
}
- if (JSON_HEDLEY_UNLIKELY(not sax->number_float(res, m_lexer.get_string())))
+ if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
{
return false;
}
@@ -276,7 +278,7 @@ class parser
case token_type::literal_false:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->boolean(false)))
+ if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
{
return false;
}
@@ -285,7 +287,7 @@ class parser
case token_type::literal_null:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->null()))
+ if (JSON_HEDLEY_UNLIKELY(!sax->null()))
{
return false;
}
@@ -294,7 +296,7 @@ class parser
case token_type::literal_true:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->boolean(true)))
+ if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
{
return false;
}
@@ -303,7 +305,7 @@ class parser
case token_type::value_integer:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->number_integer(m_lexer.get_number_integer())))
+ if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
{
return false;
}
@@ -312,7 +314,7 @@ class parser
case token_type::value_string:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->string(m_lexer.get_string())))
+ if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
{
return false;
}
@@ -321,7 +323,7 @@ class parser
case token_type::value_unsigned:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->number_unsigned(m_lexer.get_number_unsigned())))
+ if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
{
return false;
}
@@ -371,7 +373,7 @@ class parser
// closing ]
if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
{
- if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
+ if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
{
return false;
}
@@ -380,7 +382,7 @@ class parser
// new value, we need to evaluate the new state first.
// By setting skip_to_state_evaluation to false, we
// are effectively jumping to the beginning of this if.
- assert(not states.empty());
+ JSON_ASSERT(!states.empty());
states.pop_back();
skip_to_state_evaluation = true;
continue;
@@ -405,7 +407,7 @@ class parser
exception_message(token_type::value_string, "object key")));
}
- if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
+ if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
{
return false;
}
@@ -427,7 +429,7 @@ class parser
// closing }
if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
{
- if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
+ if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
{
return false;
}
@@ -436,7 +438,7 @@ class parser
// new value, we need to evaluate the new state first.
// By setting skip_to_state_evaluation to false, we
// are effectively jumping to the beginning of this if.
- assert(not states.empty());
+ JSON_ASSERT(!states.empty());
states.pop_back();
skip_to_state_evaluation = true;
continue;
@@ -460,7 +462,7 @@ class parser
{
std::string error_msg = "syntax error ";
- if (not context.empty())
+ if (!context.empty())
{
error_msg += "while parsing " + context + " ";
}
diff --git a/include/nlohmann/detail/iterators/internal_iterator.hpp b/include/nlohmann/detail/iterators/internal_iterator.hpp
index 742df483..2c81f723 100644
--- a/include/nlohmann/detail/iterators/internal_iterator.hpp
+++ b/include/nlohmann/detail/iterators/internal_iterator.hpp
@@ -18,8 +18,6 @@ template<typename BasicJsonType> struct internal_iterator
typename BasicJsonType::object_t::iterator object_iterator {};
/// iterator for JSON arrays
typename BasicJsonType::array_t::iterator array_iterator {};
- /// iterator for JSON binary arrays
- typename BasicJsonType::binary_t::container_type::iterator binary_iterator {};
/// generic iterator for all other types
primitive_iterator_t primitive_iterator {};
};
diff --git a/include/nlohmann/detail/iterators/iter_impl.hpp b/include/nlohmann/detail/iterators/iter_impl.hpp
index 0b79202a..e9a394d4 100644
--- a/include/nlohmann/detail/iterators/iter_impl.hpp
+++ b/include/nlohmann/detail/iterators/iter_impl.hpp
@@ -3,7 +3,6 @@
#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
#include <type_traits> // conditional, is_const, remove_const
-#include <nlohmann/detail/boolean_operators.hpp>
#include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/iterators/internal_iterator.hpp>
#include <nlohmann/detail/iterators/primitive_iterator.hpp>
@@ -85,7 +84,7 @@ class iter_impl
*/
explicit iter_impl(pointer object) noexcept : m_object(object)
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -171,7 +170,7 @@ class iter_impl
*/
void set_begin() noexcept
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -208,7 +207,7 @@ class iter_impl
*/
void set_end() noexcept
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -239,19 +238,19 @@ class iter_impl
*/
reference operator*() const
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
case value_t::object:
{
- assert(m_it.object_iterator != m_object->m_value.object->end());
+ JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
return m_it.object_iterator->second;
}
case value_t::array:
{
- assert(m_it.array_iterator != m_object->m_value.array->end());
+ JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
return *m_it.array_iterator;
}
@@ -276,19 +275,19 @@ class iter_impl
*/
pointer operator->() const
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
case value_t::object:
{
- assert(m_it.object_iterator != m_object->m_value.object->end());
+ JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
return &(m_it.object_iterator->second);
}
case value_t::array:
{
- assert(m_it.array_iterator != m_object->m_value.array->end());
+ JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
return &*m_it.array_iterator;
}
@@ -321,7 +320,7 @@ class iter_impl
*/
iter_impl& operator++()
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -364,7 +363,7 @@ class iter_impl
*/
iter_impl& operator--()
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -402,7 +401,7 @@ class iter_impl
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
}
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -423,7 +422,7 @@ class iter_impl
*/
bool operator!=(const iter_impl& other) const
{
- return not operator==(other);
+ return !operator==(other);
}
/*!
@@ -438,7 +437,7 @@ class iter_impl
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
}
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -459,7 +458,7 @@ class iter_impl
*/
bool operator<=(const iter_impl& other) const
{
- return not other.operator < (*this);
+ return !other.operator < (*this);
}
/*!
@@ -468,7 +467,7 @@ class iter_impl
*/
bool operator>(const iter_impl& other) const
{
- return not operator<=(other);
+ return !operator<=(other);
}
/*!
@@ -477,7 +476,7 @@ class iter_impl
*/
bool operator>=(const iter_impl& other) const
{
- return not operator<(other);
+ return !operator<(other);
}
/*!
@@ -486,7 +485,7 @@ class iter_impl
*/
iter_impl& operator+=(difference_type i)
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -557,7 +556,7 @@ class iter_impl
*/
difference_type operator-(const iter_impl& other) const
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -578,7 +577,7 @@ class iter_impl
*/
reference operator[](difference_type n) const
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -609,7 +608,7 @@ class iter_impl
*/
const typename object_t::key_type& key() const
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
if (JSON_HEDLEY_LIKELY(m_object->is_object()))
{
diff --git a/include/nlohmann/detail/iterators/iteration_proxy.hpp b/include/nlohmann/detail/iterators/iteration_proxy.hpp
index c61d9629..74b4eb34 100644
--- a/include/nlohmann/detail/iterators/iteration_proxy.hpp
+++ b/include/nlohmann/detail/iterators/iteration_proxy.hpp
@@ -15,9 +15,11 @@ namespace detail
template<typename string_type>
void int_to_string( string_type& target, std::size_t value )
{
- target = std::to_string(value);
+ // For ADL
+ using std::to_string;
+ target = to_string(value);
}
-template <typename IteratorType> class iteration_proxy_value
+template<typename IteratorType> class iteration_proxy_value
{
public:
using difference_type = std::ptrdiff_t;
@@ -72,7 +74,7 @@ template <typename IteratorType> class iteration_proxy_value
/// return key of the iterator
const string_type& key() const
{
- assert(anchor.m_object != nullptr);
+ JSON_ASSERT(anchor.m_object != nullptr);
switch (anchor.m_object->type())
{
@@ -131,7 +133,7 @@ template<typename IteratorType> class iteration_proxy
// Structured Bindings Support
// For further reference see https://blog.tartanllama.xyz/structured-bindings/
// And see https://github.com/nlohmann/json/pull/1391
-template <std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
+template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
{
return i.key();
@@ -139,7 +141,7 @@ auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decl
// Structured Bindings Support
// For further reference see https://blog.tartanllama.xyz/structured-bindings/
// And see https://github.com/nlohmann/json/pull/1391
-template <std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
+template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
{
return i.value();
@@ -158,11 +160,11 @@ namespace std
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmismatched-tags"
#endif
-template <typename IteratorType>
+template<typename IteratorType>
class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
: public std::integral_constant<std::size_t, 2> {};
-template <std::size_t N, typename IteratorType>
+template<std::size_t N, typename IteratorType>
class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
{
public:
diff --git a/include/nlohmann/detail/iterators/iterator_traits.hpp b/include/nlohmann/detail/iterators/iterator_traits.hpp
index 4cced80c..da563618 100644
--- a/include/nlohmann/detail/iterators/iterator_traits.hpp
+++ b/include/nlohmann/detail/iterators/iterator_traits.hpp
@@ -9,10 +9,10 @@ namespace nlohmann
{
namespace detail
{
-template <typename It, typename = void>
+template<typename It, typename = void>
struct iterator_types {};
-template <typename It>
+template<typename It>
struct iterator_types <
It,
void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
@@ -27,18 +27,18 @@ struct iterator_types <
// 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 <typename T, typename = void>
+template<typename T, typename = void>
struct iterator_traits
{
};
-template <typename T>
+template<typename T>
struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
: iterator_types<T>
{
};
-template <typename T>
+template<typename T>
struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
{
using iterator_category = std::random_access_iterator_tag;
diff --git a/include/nlohmann/detail/json_pointer.hpp b/include/nlohmann/detail/json_pointer.hpp
index 421c5ec8..78bc3a3a 100644
--- a/include/nlohmann/detail/json_pointer.hpp
+++ b/include/nlohmann/detail/json_pointer.hpp
@@ -1,8 +1,8 @@
#pragma once
#include <algorithm> // all_of
-#include <cassert> // assert
#include <cctype> // isdigit
+#include <limits> // max
#include <numeric> // accumulate
#include <string> // string
#include <utility> // move
@@ -325,12 +325,17 @@ class json_pointer
@return integer representation of @a s
+ @throw parse_error.106 if an array index begins with '0'
+ @throw parse_error.109 if an array index begins not with a digit
@throw out_of_range.404 if string @a s could not be converted to an integer
+ @throw out_of_range.410 if an array index exceeds size_type
*/
- static int array_index(const std::string& s)
+ static typename BasicJsonType::size_type array_index(const std::string& s)
{
+ using size_type = typename BasicJsonType::size_type;
+
// error condition (cf. RFC 6901, Sect. 4)
- if (JSON_HEDLEY_UNLIKELY(s.size() > 1 and s[0] == '0'))
+ if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
{
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + s +
@@ -338,16 +343,16 @@ class json_pointer
}
// error condition (cf. RFC 6901, Sect. 4)
- if (JSON_HEDLEY_UNLIKELY(s.size() > 1 and not (s[0] >= '1' and s[0] <= '9')))
+ if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
{
JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number"));
}
std::size_t processed_chars = 0;
- int res = 0;
+ unsigned long long res = 0;
JSON_TRY
{
- res = std::stoi(s, &processed_chars);
+ res = std::stoull(s, &processed_chars);
}
JSON_CATCH(std::out_of_range&)
{
@@ -360,7 +365,14 @@ class json_pointer
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
}
- return res;
+ // only triggered on special platforms (like 32bit), see also
+ // https://github.com/nlohmann/json/pull/2203
+ if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))
+ {
+ JSON_THROW(detail::out_of_range::create(410, "array index " + s + " exceeds size_type")); // LCOV_EXCL_LINE
+ }
+
+ return static_cast<size_type>(res);
}
json_pointer top() const
@@ -385,7 +397,6 @@ class json_pointer
*/
BasicJsonType& get_and_create(BasicJsonType& j) const
{
- using size_type = typename BasicJsonType::size_type;
auto result = &j;
// in case no reference tokens exist, return a reference to the JSON value
@@ -419,7 +430,7 @@ class json_pointer
case detail::value_t::array:
{
// create an entry in the array
- result = &result->operator[](static_cast<size_type>(array_index(reference_token)));
+ result = &result->operator[](array_index(reference_token));
break;
}
@@ -458,7 +469,6 @@ class json_pointer
*/
BasicJsonType& get_unchecked(BasicJsonType* ptr) const
{
- using size_type = typename BasicJsonType::size_type;
for (const auto& reference_token : reference_tokens)
{
// convert null values to arrays or objects before continuing
@@ -473,7 +483,7 @@ class json_pointer
});
// change value to array for numbers or "-" or to object otherwise
- *ptr = (nums or reference_token == "-")
+ *ptr = (nums || reference_token == "-")
? detail::value_t::array
: detail::value_t::object;
}
@@ -497,8 +507,7 @@ class json_pointer
else
{
// convert array index to number; unchecked access
- ptr = &ptr->operator[](
- static_cast<size_type>(array_index(reference_token)));
+ ptr = &ptr->operator[](array_index(reference_token));
}
break;
}
@@ -519,7 +528,6 @@ class json_pointer
*/
BasicJsonType& get_checked(BasicJsonType* ptr) const
{
- using size_type = typename BasicJsonType::size_type;
for (const auto& reference_token : reference_tokens)
{
switch (ptr->type())
@@ -542,7 +550,7 @@ class json_pointer
}
// note: at performs range check
- ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
+ ptr = &ptr->at(array_index(reference_token));
break;
}
@@ -569,7 +577,6 @@ class json_pointer
*/
const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
{
- using size_type = typename BasicJsonType::size_type;
for (const auto& reference_token : reference_tokens)
{
switch (ptr->type())
@@ -592,8 +599,7 @@ class json_pointer
}
// use unchecked array access
- ptr = &ptr->operator[](
- static_cast<size_type>(array_index(reference_token)));
+ ptr = &ptr->operator[](array_index(reference_token));
break;
}
@@ -613,7 +619,6 @@ class json_pointer
*/
const BasicJsonType& get_checked(const BasicJsonType* ptr) const
{
- using size_type = typename BasicJsonType::size_type;
for (const auto& reference_token : reference_tokens)
{
switch (ptr->type())
@@ -636,7 +641,7 @@ class json_pointer
}
// note: at performs range check
- ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
+ ptr = &ptr->at(array_index(reference_token));
break;
}
@@ -654,14 +659,13 @@ class json_pointer
*/
bool contains(const BasicJsonType* ptr) const
{
- using size_type = typename BasicJsonType::size_type;
for (const auto& reference_token : reference_tokens)
{
switch (ptr->type())
{
case detail::value_t::object:
{
- if (not ptr->contains(reference_token))
+ if (!ptr->contains(reference_token))
{
// we did not find the key in the object
return false;
@@ -678,21 +682,21 @@ class json_pointer
// "-" always fails the range check
return false;
}
- if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 and not ("0" <= reference_token and reference_token <= "9")))
+ if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
{
// invalid char
return false;
}
if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
{
- if (JSON_HEDLEY_UNLIKELY(not ('1' <= reference_token[0] and reference_token[0] <= '9')))
+ if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
{
// first char should be between '1' and '9'
return false;
}
for (std::size_t i = 1; i < reference_token.size(); i++)
{
- if (JSON_HEDLEY_UNLIKELY(not ('0' <= reference_token[i] and reference_token[i] <= '9')))
+ if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
{
// other char should be between '0' and '9'
return false;
@@ -700,7 +704,7 @@ class json_pointer
}
}
- const auto idx = static_cast<size_type>(array_index(reference_token));
+ const auto idx = array_index(reference_token);
if (idx >= ptr->size())
{
// index out of range
@@ -776,11 +780,11 @@ class json_pointer
pos != std::string::npos;
pos = reference_token.find_first_of('~', pos + 1))
{
- assert(reference_token[pos] == '~');
+ JSON_ASSERT(reference_token[pos] == '~');
// ~ must be followed by 0 or 1
- if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 or
- (reference_token[pos + 1] != '0' and
+ if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
+ (reference_token[pos + 1] != '0' &&
reference_token[pos + 1] != '1')))
{
JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
@@ -811,7 +815,7 @@ class json_pointer
static void replace_substring(std::string& s, const std::string& f,
const std::string& t)
{
- assert(not f.empty());
+ JSON_ASSERT(!f.empty());
for (auto pos = s.find(f); // find first occurrence of f
pos != std::string::npos; // make sure f was found
s.replace(pos, f.size(), t), // replace with t, and
@@ -906,7 +910,7 @@ class json_pointer
static BasicJsonType
unflatten(const BasicJsonType& value)
{
- if (JSON_HEDLEY_UNLIKELY(not value.is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
{
JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
}
@@ -916,7 +920,7 @@ class json_pointer
// iterate the JSON object values
for (const auto& element : *value.m_value.object)
{
- if (JSON_HEDLEY_UNLIKELY(not element.second.is_primitive()))
+ if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
{
JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
}
@@ -962,7 +966,7 @@ class json_pointer
friend bool operator!=(json_pointer const& lhs,
json_pointer const& rhs) noexcept
{
- return not (lhs == rhs);
+ return !(lhs == rhs);
}
/// the reference tokens
diff --git a/include/nlohmann/detail/json_ref.hpp b/include/nlohmann/detail/json_ref.hpp
index c8dec733..c9bf6cb2 100644
--- a/include/nlohmann/detail/json_ref.hpp
+++ b/include/nlohmann/detail/json_ref.hpp
@@ -16,23 +16,30 @@ class json_ref
using value_type = BasicJsonType;
json_ref(value_type&& value)
- : owned_value(std::move(value)), value_ref(&owned_value), is_rvalue(true)
+ : owned_value(std::move(value))
+ , value_ref(&owned_value)
+ , is_rvalue(true)
{}
json_ref(const value_type& value)
- : value_ref(const_cast<value_type*>(&value)), is_rvalue(false)
+ : value_ref(const_cast<value_type*>(&value))
+ , is_rvalue(false)
{}
json_ref(std::initializer_list<json_ref> init)
- : owned_value(init), value_ref(&owned_value), is_rvalue(true)
+ : owned_value(init)
+ , value_ref(&owned_value)
+ , is_rvalue(true)
{}
template <
class... Args,
enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
json_ref(Args && ... args)
- : owned_value(std::forward<Args>(args)...), value_ref(&owned_value),
- is_rvalue(true) {}
+ : owned_value(std::forward<Args>(args)...)
+ , value_ref(&owned_value)
+ , is_rvalue(true)
+ {}
// class should be movable only
json_ref(json_ref&&) = default;
@@ -63,7 +70,7 @@ class json_ref
private:
mutable value_type owned_value = nullptr;
value_type* value_ref = nullptr;
- const bool is_rvalue;
+ const bool is_rvalue = true;
};
} // namespace detail
} // namespace nlohmann
diff --git a/include/nlohmann/detail/macro_scope.hpp b/include/nlohmann/detail/macro_scope.hpp
index 25e6b76e..8c9f6329 100644
--- a/include/nlohmann/detail/macro_scope.hpp
+++ b/include/nlohmann/detail/macro_scope.hpp
@@ -20,7 +20,11 @@
#endif
// C++ language standard detection
-#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+#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)
@@ -73,6 +77,12 @@
#define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
#endif
+// allow to override assert
+#if !defined(JSON_ASSERT)
+ #include <cassert> // assert
+ #define JSON_ASSERT(x) assert(x)
+#endif
+
/*!
@brief macro to briefly define a mapping between an enum and JSON
@def NLOHMANN_JSON_SERIALIZE_ENUM
@@ -120,3 +130,167 @@
basic_json<ObjectType, ArrayType, StringType, BooleanType, \
NumberIntegerType, NumberUnsignedType, NumberFloatType, \
AllocatorType, JSONSerializer, BinaryType>
+
+// 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);
+
+/*!
+@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__)) }
+
+/*!
+@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__)) }
+
+#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
diff --git a/include/nlohmann/detail/macro_unscope.hpp b/include/nlohmann/detail/macro_unscope.hpp
index 80b293e7..eb706511 100644
--- a/include/nlohmann/detail/macro_unscope.hpp
+++ b/include/nlohmann/detail/macro_unscope.hpp
@@ -9,6 +9,7 @@
#endif
// clean up
+#undef JSON_ASSERT
#undef JSON_INTERNAL_CATCH
#undef JSON_CATCH
#undef JSON_THROW
@@ -17,5 +18,6 @@
#undef JSON_HAS_CPP_17
#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
#undef NLOHMANN_BASIC_JSON_TPL
+#undef JSON_EXPLICIT
#include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
diff --git a/include/nlohmann/detail/meta/cpp_future.hpp b/include/nlohmann/detail/meta/cpp_future.hpp
index 11f88acc..dd929ee1 100644
--- a/include/nlohmann/detail/meta/cpp_future.hpp
+++ b/include/nlohmann/detail/meta/cpp_future.hpp
@@ -3,8 +3,6 @@
#include <cstddef> // size_t
#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
-#include <nlohmann/detail/boolean_operators.hpp>
-
namespace nlohmann
{
namespace detail
diff --git a/include/nlohmann/detail/meta/detected.hpp b/include/nlohmann/detail/meta/detected.hpp
index e5ca5eb2..7b5a0035 100644
--- a/include/nlohmann/detail/meta/detected.hpp
+++ b/include/nlohmann/detail/meta/detected.hpp
@@ -19,39 +19,39 @@ struct nonesuch
void operator=(nonesuch&&) = delete;
};
-template <class Default,
- class AlwaysVoid,
- template <class...> class Op,
- class... Args>
+template<class Default,
+ class AlwaysVoid,
+ template<class...> class Op,
+ class... Args>
struct detector
{
using value_t = std::false_type;
using type = Default;
};
-template <class Default, template <class...> class Op, class... Args>
+template<class Default, template<class...> class Op, class... Args>
struct detector<Default, void_t<Op<Args...>>, Op, Args...>
{
using value_t = std::true_type;
using type = Op<Args...>;
};
-template <template <class...> class Op, class... Args>
+template<template<class...> class Op, class... Args>
using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
-template <template <class...> class Op, class... Args>
+template<template<class...> class Op, class... Args>
using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
-template <class Default, template <class...> class Op, class... Args>
+template<class Default, template<class...> class Op, class... Args>
using detected_or = detector<Default, void, Op, Args...>;
-template <class Default, template <class...> class Op, class... Args>
+template<class Default, template<class...> class Op, class... Args>
using detected_or_t = typename detected_or<Default, Op, Args...>::type;
-template <class Expected, template <class...> class Op, class... Args>
+template<class Expected, template<class...> class Op, class... Args>
using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
-template <class To, template <class...> class Op, class... Args>
+template<class To, template<class...> class Op, class... Args>
using is_detected_convertible =
std::is_convertible<detected_t<Op, Args...>, To>;
} // namespace detail
diff --git a/include/nlohmann/detail/meta/is_sax.hpp b/include/nlohmann/detail/meta/is_sax.hpp
index 88295bec..e1e48a0b 100644
--- a/include/nlohmann/detail/meta/is_sax.hpp
+++ b/include/nlohmann/detail/meta/is_sax.hpp
@@ -11,53 +11,57 @@ namespace nlohmann
{
namespace detail
{
-template <typename T>
+template<typename T>
using null_function_t = decltype(std::declval<T&>().null());
-template <typename T>
+template<typename T>
using boolean_function_t =
decltype(std::declval<T&>().boolean(std::declval<bool>()));
-template <typename T, typename Integer>
+template<typename T, typename Integer>
using number_integer_function_t =
decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
-template <typename T, typename Unsigned>
+template<typename T, typename Unsigned>
using number_unsigned_function_t =
decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
-template <typename T, typename Float, typename String>
+template<typename T, typename Float, typename String>
using number_float_function_t = decltype(std::declval<T&>().number_float(
std::declval<Float>(), std::declval<const String&>()));
-template <typename T, typename String>
+template<typename T, typename String>
using string_function_t =
decltype(std::declval<T&>().string(std::declval<String&>()));
-template <typename T>
+template<typename T, typename Binary>
+using binary_function_t =
+ decltype(std::declval<T&>().binary(std::declval<Binary&>()));
+
+template<typename T>
using start_object_function_t =
decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
-template <typename T, typename String>
+template<typename T, typename String>
using key_function_t =
decltype(std::declval<T&>().key(std::declval<String&>()));
-template <typename T>
+template<typename T>
using end_object_function_t = decltype(std::declval<T&>().end_object());
-template <typename T>
+template<typename T>
using start_array_function_t =
decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
-template <typename T>
+template<typename T>
using end_array_function_t = decltype(std::declval<T&>().end_array());
-template <typename T, typename Exception>
+template<typename T, typename Exception>
using parse_error_function_t = decltype(std::declval<T&>().parse_error(
std::declval<std::size_t>(), std::declval<const std::string&>(),
std::declval<const Exception&>()));
-template <typename SAX, typename BasicJsonType>
+template<typename SAX, typename BasicJsonType>
struct is_sax
{
private:
@@ -68,19 +72,18 @@ struct is_sax
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
using number_float_t = typename BasicJsonType::number_float_t;
using string_t = typename BasicJsonType::string_t;
+ using binary_t = typename BasicJsonType::binary_t;
using exception_t = typename BasicJsonType::exception;
public:
static constexpr bool value =
is_detected_exact<bool, null_function_t, SAX>::value &&
is_detected_exact<bool, boolean_function_t, SAX>::value &&
- is_detected_exact<bool, number_integer_function_t, SAX,
- number_integer_t>::value &&
- is_detected_exact<bool, number_unsigned_function_t, SAX,
- number_unsigned_t>::value &&
- is_detected_exact<bool, number_float_function_t, SAX, number_float_t,
- string_t>::value &&
+ is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
+ is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
+ is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
+ is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
is_detected_exact<bool, start_object_function_t, SAX>::value &&
is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
is_detected_exact<bool, end_object_function_t, SAX>::value &&
@@ -89,7 +92,7 @@ struct is_sax
is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
};
-template <typename SAX, typename BasicJsonType>
+template<typename SAX, typename BasicJsonType>
struct is_sax_static_asserts
{
private:
@@ -100,6 +103,7 @@ struct is_sax_static_asserts
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
using number_float_t = typename BasicJsonType::number_float_t;
using string_t = typename BasicJsonType::string_t;
+ using binary_t = typename BasicJsonType::binary_t;
using exception_t = typename BasicJsonType::exception;
public:
@@ -123,6 +127,9 @@ struct is_sax_static_asserts
static_assert(
is_detected_exact<bool, string_function_t, SAX, string_t>::value,
"Missing/invalid function: bool string(string_t&)");
+ static_assert(
+ is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
+ "Missing/invalid function: bool binary(binary_t&)");
static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
"Missing/invalid function: bool start_object(std::size_t)");
static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
diff --git a/include/nlohmann/detail/meta/type_traits.hpp b/include/nlohmann/detail/meta/type_traits.hpp
index 3b93fa8b..ac143bec 100644
--- a/include/nlohmann/detail/meta/type_traits.hpp
+++ b/include/nlohmann/detail/meta/type_traits.hpp
@@ -4,7 +4,6 @@
#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
#include <utility> // declval
-#include <nlohmann/detail/boolean_operators.hpp>
#include <nlohmann/detail/iterators/iterator_traits.hpp>
#include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/meta/cpp_future.hpp>
@@ -45,59 +44,69 @@ struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
// json_ref helpers //
//////////////////////
-template <typename>
+template<typename>
class json_ref;
template<typename>
struct is_json_ref : std::false_type {};
-template <typename T>
+template<typename T>
struct is_json_ref<json_ref<T>> : std::true_type {};
//////////////////////////
// aliases for detected //
//////////////////////////
-template <typename T>
+template<typename T>
using mapped_type_t = typename T::mapped_type;
-template <typename T>
+template<typename T>
using key_type_t = typename T::key_type;
-template <typename T>
+template<typename T>
using value_type_t = typename T::value_type;
-template <typename T>
+template<typename T>
using difference_type_t = typename T::difference_type;
-template <typename T>
+template<typename T>
using pointer_t = typename T::pointer;
-template <typename T>
+template<typename T>
using reference_t = typename T::reference;
-template <typename T>
+template<typename T>
using iterator_category_t = typename T::iterator_category;
-template <typename T>
+template<typename T>
using iterator_t = typename T::iterator;
-template <typename T, typename... Args>
+template<typename T, typename... Args>
using to_json_function = decltype(T::to_json(std::declval<Args>()...));
-template <typename T, typename... Args>
+template<typename T, typename... Args>
using from_json_function = decltype(T::from_json(std::declval<Args>()...));
-template <typename T, typename U>
+template<typename T, typename U>
using get_template_function = decltype(std::declval<T>().template get<U>());
// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
-template <typename BasicJsonType, typename T, typename = void>
+template<typename BasicJsonType, typename T, typename = void>
struct has_from_json : std::false_type {};
+// trait checking if j.get<T> 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 <typename BasicJsonType, typename T>
-struct has_from_json<BasicJsonType, T,
- enable_if_t<not is_basic_json<T>::value>>
+struct is_getable
+{
+ static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
+};
+
+template<typename BasicJsonType, typename T>
+struct has_from_json < BasicJsonType, T,
+ enable_if_t < !is_basic_json<T>::value >>
{
using serializer = typename BasicJsonType::template json_serializer<T, void>;
@@ -108,11 +117,11 @@ struct has_from_json<BasicJsonType, T,
// This trait checks if JSONSerializer<T>::from_json(json const&) exists
// this overload is used for non-default-constructible user-defined-types
-template <typename BasicJsonType, typename T, typename = void>
+template<typename BasicJsonType, typename T, typename = void>
struct has_non_default_from_json : std::false_type {};
template<typename BasicJsonType, typename T>
-struct has_non_default_from_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>>
+struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
{
using serializer = typename BasicJsonType::template json_serializer<T, void>;
@@ -123,11 +132,11 @@ struct has_non_default_from_json<BasicJsonType, T, enable_if_t<not is_basic_json
// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
-template <typename BasicJsonType, typename T, typename = void>
+template<typename BasicJsonType, typename T, typename = void>
struct has_to_json : std::false_type {};
-template <typename BasicJsonType, typename T>
-struct has_to_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>>
+template<typename BasicJsonType, typename T>
+struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
{
using serializer = typename BasicJsonType::template json_serializer<T, void>;
@@ -141,10 +150,10 @@ struct has_to_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>>
// is_ functions //
///////////////////
-template <typename T, typename = void>
+template<typename T, typename = void>
struct is_iterator_traits : std::false_type {};
-template <typename T>
+template<typename T>
struct is_iterator_traits<iterator_traits<T>>
{
private:
@@ -161,20 +170,20 @@ struct is_iterator_traits<iterator_traits<T>>
// source: https://stackoverflow.com/a/37193089/4116453
-template <typename T, typename = void>
+template<typename T, typename = void>
struct is_complete_type : std::false_type {};
-template <typename T>
+template<typename T>
struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
-template <typename BasicJsonType, typename CompatibleObjectType,
- typename = void>
+template<typename BasicJsonType, typename CompatibleObjectType,
+ typename = void>
struct is_compatible_object_type_impl : std::false_type {};
-template <typename BasicJsonType, typename CompatibleObjectType>
+template<typename BasicJsonType, typename CompatibleObjectType>
struct is_compatible_object_type_impl <
BasicJsonType, CompatibleObjectType,
- enable_if_t<is_detected<mapped_type_t, CompatibleObjectType>::value and
+ enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
is_detected<key_type_t, CompatibleObjectType>::value >>
{
@@ -183,53 +192,53 @@ struct is_compatible_object_type_impl <
// macOS's is_constructible does not play well with nonesuch...
static constexpr bool value =
std::is_constructible<typename object_t::key_type,
- typename CompatibleObjectType::key_type>::value and
+ typename CompatibleObjectType::key_type>::value &&
std::is_constructible<typename object_t::mapped_type,
typename CompatibleObjectType::mapped_type>::value;
};
-template <typename BasicJsonType, typename CompatibleObjectType>
+template<typename BasicJsonType, typename CompatibleObjectType>
struct is_compatible_object_type
: is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
-template <typename BasicJsonType, typename ConstructibleObjectType,
- typename = void>
+template<typename BasicJsonType, typename ConstructibleObjectType,
+ typename = void>
struct is_constructible_object_type_impl : std::false_type {};
-template <typename BasicJsonType, typename ConstructibleObjectType>
+template<typename BasicJsonType, typename ConstructibleObjectType>
struct is_constructible_object_type_impl <
BasicJsonType, ConstructibleObjectType,
- enable_if_t<is_detected<mapped_type_t, ConstructibleObjectType>::value and
+ enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
is_detected<key_type_t, ConstructibleObjectType>::value >>
{
using object_t = typename BasicJsonType::object_t;
static constexpr bool value =
- (std::is_default_constructible<ConstructibleObjectType>::value and
- (std::is_move_assignable<ConstructibleObjectType>::value or
- std::is_copy_assignable<ConstructibleObjectType>::value) and
+ (std::is_default_constructible<ConstructibleObjectType>::value &&
+ (std::is_move_assignable<ConstructibleObjectType>::value ||
+ std::is_copy_assignable<ConstructibleObjectType>::value) &&
(std::is_constructible<typename ConstructibleObjectType::key_type,
- typename object_t::key_type>::value and
+ typename object_t::key_type>::value &&
std::is_same <
typename object_t::mapped_type,
- typename ConstructibleObjectType::mapped_type >::value)) or
+ typename ConstructibleObjectType::mapped_type >::value)) ||
(has_from_json<BasicJsonType,
- typename ConstructibleObjectType::mapped_type>::value or
+ typename ConstructibleObjectType::mapped_type>::value ||
has_non_default_from_json <
BasicJsonType,
typename ConstructibleObjectType::mapped_type >::value);
};
-template <typename BasicJsonType, typename ConstructibleObjectType>
+template<typename BasicJsonType, typename ConstructibleObjectType>
struct is_constructible_object_type
: is_constructible_object_type_impl<BasicJsonType,
ConstructibleObjectType> {};
-template <typename BasicJsonType, typename CompatibleStringType,
- typename = void>
+template<typename BasicJsonType, typename CompatibleStringType,
+ typename = void>
struct is_compatible_string_type_impl : std::false_type {};
-template <typename BasicJsonType, typename CompatibleStringType>
+template<typename BasicJsonType, typename CompatibleStringType>
struct is_compatible_string_type_impl <
BasicJsonType, CompatibleStringType,
enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
@@ -239,15 +248,15 @@ struct is_compatible_string_type_impl <
std::is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
};
-template <typename BasicJsonType, typename ConstructibleStringType>
+template<typename BasicJsonType, typename ConstructibleStringType>
struct is_compatible_string_type
: is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
-template <typename BasicJsonType, typename ConstructibleStringType,
- typename = void>
+template<typename BasicJsonType, typename ConstructibleStringType,
+ typename = void>
struct is_constructible_string_type_impl : std::false_type {};
-template <typename BasicJsonType, typename ConstructibleStringType>
+template<typename BasicJsonType, typename ConstructibleStringType>
struct is_constructible_string_type_impl <
BasicJsonType, ConstructibleStringType,
enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
@@ -258,55 +267,55 @@ struct is_constructible_string_type_impl <
typename BasicJsonType::string_t>::value;
};
-template <typename BasicJsonType, typename ConstructibleStringType>
+template<typename BasicJsonType, typename ConstructibleStringType>
struct is_constructible_string_type
: is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
-template <typename BasicJsonType, typename CompatibleArrayType, typename = void>
+template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
struct is_compatible_array_type_impl : std::false_type {};
-template <typename BasicJsonType, typename CompatibleArrayType>
+template<typename BasicJsonType, typename CompatibleArrayType>
struct is_compatible_array_type_impl <
BasicJsonType, CompatibleArrayType,
- enable_if_t<is_detected<value_type_t, CompatibleArrayType>::value and
- is_detected<iterator_t, CompatibleArrayType>::value and
+ enable_if_t < is_detected<value_type_t, CompatibleArrayType>::value&&
+ is_detected<iterator_t, CompatibleArrayType>::value&&
// This is needed because json_reverse_iterator has a ::iterator type...
// Therefore it is detected as a CompatibleArrayType.
// The real fix would be to have an Iterable concept.
- not is_iterator_traits<
- iterator_traits<CompatibleArrayType>>::value >>
+ !is_iterator_traits <
+ iterator_traits<CompatibleArrayType >>::value >>
{
static constexpr bool value =
std::is_constructible<BasicJsonType,
typename CompatibleArrayType::value_type>::value;
};
-template <typename BasicJsonType, typename CompatibleArrayType>
+template<typename BasicJsonType, typename CompatibleArrayType>
struct is_compatible_array_type
: is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
-template <typename BasicJsonType, typename ConstructibleArrayType, typename = void>
+template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
struct is_constructible_array_type_impl : std::false_type {};
-template <typename BasicJsonType, typename ConstructibleArrayType>
+template<typename BasicJsonType, typename ConstructibleArrayType>
struct is_constructible_array_type_impl <
BasicJsonType, ConstructibleArrayType,
enable_if_t<std::is_same<ConstructibleArrayType,
typename BasicJsonType::value_type>::value >>
: std::true_type {};
-template <typename BasicJsonType, typename ConstructibleArrayType>
+template<typename BasicJsonType, typename ConstructibleArrayType>
struct is_constructible_array_type_impl <
BasicJsonType, ConstructibleArrayType,
- enable_if_t<not std::is_same<ConstructibleArrayType,
- typename BasicJsonType::value_type>::value and
- std::is_default_constructible<ConstructibleArrayType>::value and
-(std::is_move_assignable<ConstructibleArrayType>::value or
- std::is_copy_assignable<ConstructibleArrayType>::value) and
-is_detected<value_type_t, ConstructibleArrayType>::value and
-is_detected<iterator_t, ConstructibleArrayType>::value and
-is_complete_type<
-detected_t<value_type_t, ConstructibleArrayType>>::value >>
+ enable_if_t < !std::is_same<ConstructibleArrayType,
+ typename BasicJsonType::value_type>::value&&
+ std::is_default_constructible<ConstructibleArrayType>::value&&
+(std::is_move_assignable<ConstructibleArrayType>::value ||
+ std::is_copy_assignable<ConstructibleArrayType>::value)&&
+is_detected<value_type_t, ConstructibleArrayType>::value&&
+is_detected<iterator_t, ConstructibleArrayType>::value&&
+is_complete_type <
+detected_t<value_type_t, ConstructibleArrayType >>::value >>
{
static constexpr bool value =
// This is needed because json_reverse_iterator has a ::iterator type,
@@ -314,30 +323,30 @@ detected_t<value_type_t, ConstructibleArrayType>>::value >>
// base class `iterator`... Therefore it is detected as a
// ConstructibleArrayType. The real fix would be to have an Iterable
// concept.
- not is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value and
+ !is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value &&
(std::is_same<typename ConstructibleArrayType::value_type,
- typename BasicJsonType::array_t::value_type>::value or
+ typename BasicJsonType::array_t::value_type>::value ||
has_from_json<BasicJsonType,
- typename ConstructibleArrayType::value_type>::value or
+ typename ConstructibleArrayType::value_type>::value ||
has_non_default_from_json <
BasicJsonType, typename ConstructibleArrayType::value_type >::value);
};
-template <typename BasicJsonType, typename ConstructibleArrayType>
+template<typename BasicJsonType, typename ConstructibleArrayType>
struct is_constructible_array_type
: is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
-template <typename RealIntegerType, typename CompatibleNumberIntegerType,
- typename = void>
+template<typename RealIntegerType, typename CompatibleNumberIntegerType,
+ typename = void>
struct is_compatible_integer_type_impl : std::false_type {};
-template <typename RealIntegerType, typename CompatibleNumberIntegerType>
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
struct is_compatible_integer_type_impl <
RealIntegerType, CompatibleNumberIntegerType,
- enable_if_t<std::is_integral<RealIntegerType>::value and
- std::is_integral<CompatibleNumberIntegerType>::value and
- not std::is_same<bool, CompatibleNumberIntegerType>::value >>
+ enable_if_t < std::is_integral<RealIntegerType>::value&&
+ std::is_integral<CompatibleNumberIntegerType>::value&&
+ !std::is_same<bool, CompatibleNumberIntegerType>::value >>
{
// is there an assert somewhere on overflows?
using RealLimits = std::numeric_limits<RealIntegerType>;
@@ -345,20 +354,20 @@ struct is_compatible_integer_type_impl <
static constexpr auto value =
std::is_constructible<RealIntegerType,
- CompatibleNumberIntegerType>::value and
- CompatibleLimits::is_integer and
+ CompatibleNumberIntegerType>::value &&
+ CompatibleLimits::is_integer &&
RealLimits::is_signed == CompatibleLimits::is_signed;
};
-template <typename RealIntegerType, typename CompatibleNumberIntegerType>
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
struct is_compatible_integer_type
: is_compatible_integer_type_impl<RealIntegerType,
CompatibleNumberIntegerType> {};
-template <typename BasicJsonType, typename CompatibleType, typename = void>
+template<typename BasicJsonType, typename CompatibleType, typename = void>
struct is_compatible_type_impl: std::false_type {};
-template <typename BasicJsonType, typename CompatibleType>
+template<typename BasicJsonType, typename CompatibleType>
struct is_compatible_type_impl <
BasicJsonType, CompatibleType,
enable_if_t<is_complete_type<CompatibleType>::value >>
@@ -367,7 +376,7 @@ struct is_compatible_type_impl <
has_to_json<BasicJsonType, CompatibleType>::value;
};
-template <typename BasicJsonType, typename CompatibleType>
+template<typename BasicJsonType, typename CompatibleType>
struct is_compatible_type
: is_compatible_type_impl<BasicJsonType, CompatibleType> {};
@@ -378,10 +387,10 @@ template<class B1, class... Bn>
struct conjunction<B1, Bn...>
: std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
-template <typename T1, typename T2>
+template<typename T1, typename T2>
struct is_constructible_tuple : std::false_type {};
-template <typename T1, typename... Args>
+template<typename T1, typename... Args>
struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<std::is_constructible<T1, Args>...> {};
} // namespace detail
} // namespace nlohmann
diff --git a/include/nlohmann/detail/meta/void_t.hpp b/include/nlohmann/detail/meta/void_t.hpp
index a256f85a..4ee2c86f 100644
--- a/include/nlohmann/detail/meta/void_t.hpp
+++ b/include/nlohmann/detail/meta/void_t.hpp
@@ -4,10 +4,10 @@ namespace nlohmann
{
namespace detail
{
-template <typename ...Ts> struct make_void
+template<typename ...Ts> struct make_void
{
using type = void;
};
-template <typename ...Ts> using void_t = typename make_void<Ts...>::type;
+template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
} // namespace detail
} // namespace nlohmann
diff --git a/include/nlohmann/detail/output/binary_writer.hpp b/include/nlohmann/detail/output/binary_writer.hpp
index 269df0d5..0c6185e0 100644
--- a/include/nlohmann/detail/output/binary_writer.hpp
+++ b/include/nlohmann/detail/output/binary_writer.hpp
@@ -28,6 +28,7 @@ class binary_writer
{
using string_t = typename BasicJsonType::string_t;
using binary_t = typename BasicJsonType::binary_t;
+ using number_float_t = typename BasicJsonType::number_float_t;
public:
/*!
@@ -37,7 +38,7 @@ class binary_writer
*/
explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)
{
- assert(oa);
+ JSON_ASSERT(oa);
}
/*!
@@ -194,18 +195,7 @@ class binary_writer
}
else
{
- if (static_cast<double>(j.m_value.number_float) >= static_cast<double>(std::numeric_limits<float>::lowest()) and
- static_cast<double>(j.m_value.number_float) <= static_cast<double>((std::numeric_limits<float>::max)()) and
- static_cast<double>(static_cast<float>(j.m_value.number_float)) == static_cast<double>(j.m_value.number_float))
- {
- oa->write_character(get_cbor_float_prefix(static_cast<float>(j.m_value.number_float)));
- write_number(static_cast<float>(j.m_value.number_float));
- }
- else
- {
- oa->write_character(get_cbor_float_prefix(j.m_value.number_float));
- write_number(j.m_value.number_float);
- }
+ write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
}
break;
}
@@ -289,6 +279,12 @@ class binary_writer
case value_t::binary:
{
+ if (j.m_value.binary->has_subtype())
+ {
+ write_number(static_cast<std::uint8_t>(0xd8));
+ write_number(j.m_value.binary->subtype());
+ }
+
// step 1: write control byte and the binary array size
const auto N = j.m_value.binary->size();
if (N <= 0x17)
@@ -436,28 +432,28 @@ class binary_writer
// negative fixnum
write_number(static_cast<std::int8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() and
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
{
// int 8
oa->write_character(to_char_type(0xD0));
write_number(static_cast<std::int8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() and
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
{
// int 16
oa->write_character(to_char_type(0xD1));
write_number(static_cast<std::int16_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() and
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
{
// int 32
oa->write_character(to_char_type(0xD2));
write_number(static_cast<std::int32_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() and
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
{
// int 64
@@ -504,8 +500,7 @@ class binary_writer
case value_t::number_float:
{
- oa->write_character(get_msgpack_float_prefix(j.m_value.number_float));
- write_number(j.m_value.number_float);
+ write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
break;
}
@@ -584,7 +579,7 @@ class binary_writer
const auto N = j.m_value.binary->size();
if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
- std::uint8_t output_type;
+ std::uint8_t output_type{};
bool fixed = true;
if (use_ext)
{
@@ -619,37 +614,25 @@ class binary_writer
}
oa->write_character(to_char_type(output_type));
- if (not fixed)
+ if (!fixed)
{
write_number(static_cast<std::uint8_t>(N));
}
}
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
- std::uint8_t output_type;
- if (use_ext)
- {
- output_type = 0xC8; // ext 16
- }
- else
- {
- output_type = 0xC5; // bin 16
- }
+ std::uint8_t output_type = use_ext
+ ? 0xC8 // ext 16
+ : 0xC5; // bin 16
oa->write_character(to_char_type(output_type));
write_number(static_cast<std::uint16_t>(N));
}
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
- std::uint8_t output_type;
- if (use_ext)
- {
- output_type = 0xC9; // ext 32
- }
- else
- {
- output_type = 0xC6; // bin 32
- }
+ std::uint8_t output_type = use_ext
+ ? 0xC9 // ext 32
+ : 0xC6; // bin 32
oa->write_character(to_char_type(output_type));
write_number(static_cast<std::uint32_t>(N));
@@ -775,9 +758,9 @@ class binary_writer
}
bool prefix_required = true;
- if (use_type and not j.m_value.array->empty())
+ if (use_type && !j.m_value.array->empty())
{
- assert(use_count);
+ JSON_ASSERT(use_count);
const CharType first_prefix = ubjson_prefix(j.front());
const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
[this, first_prefix](const BasicJsonType & v)
@@ -804,7 +787,7 @@ class binary_writer
write_ubjson(el, use_count, use_type, prefix_required);
}
- if (not use_count)
+ if (!use_count)
{
oa->write_character(to_char_type(']'));
}
@@ -819,9 +802,9 @@ class binary_writer
oa->write_character(to_char_type('['));
}
- if (use_type and not j.m_value.binary->empty())
+ if (use_type && !j.m_value.binary->empty())
{
- assert(use_count);
+ JSON_ASSERT(use_count);
oa->write_character(to_char_type('$'));
oa->write_character('U');
}
@@ -847,7 +830,7 @@ class binary_writer
}
}
- if (not use_count)
+ if (!use_count)
{
oa->write_character(to_char_type(']'));
}
@@ -863,9 +846,9 @@ class binary_writer
}
bool prefix_required = true;
- if (use_type and not j.m_value.object->empty())
+ if (use_type && !j.m_value.object->empty())
{
- assert(use_count);
+ JSON_ASSERT(use_count);
const CharType first_prefix = ubjson_prefix(j.front());
const bool same_prefix = std::all_of(j.begin(), j.end(),
[this, first_prefix](const BasicJsonType & v)
@@ -896,7 +879,7 @@ class binary_writer
write_ubjson(el.second, use_count, use_type, prefix_required);
}
- if (not use_count)
+ if (!use_count)
{
oa->write_character(to_char_type('}'));
}
@@ -997,7 +980,7 @@ class binary_writer
*/
static std::size_t calc_bson_integer_size(const std::int64_t value)
{
- return (std::numeric_limits<std::int32_t>::min)() <= value and value <= (std::numeric_limits<std::int32_t>::max)()
+ return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
? sizeof(std::int32_t)
: sizeof(std::int64_t);
}
@@ -1008,7 +991,7 @@ class binary_writer
void write_bson_integer(const string_t& name,
const std::int64_t value)
{
- if ((std::numeric_limits<std::int32_t>::min)() <= value and value <= (std::numeric_limits<std::int32_t>::max)())
+ if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
{
write_bson_entry_header(name, 0x10); // int32
write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
@@ -1157,7 +1140,7 @@ class binary_writer
// LCOV_EXCL_START
default:
- assert(false);
+ JSON_ASSERT(false);
return 0ul;
// LCOV_EXCL_STOP
}
@@ -1204,7 +1187,7 @@ class binary_writer
// LCOV_EXCL_START
default:
- assert(false);
+ JSON_ASSERT(false);
return;
// LCOV_EXCL_STOP
}
@@ -1336,18 +1319,28 @@ class binary_writer
}
else
{
- JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(n) + " cannot be represented by UBJSON as it does not fit int64"));
+ if (add_prefix)
+ {
+ oa->write_character(to_char_type('H')); // high-precision number
+ }
+
+ const auto number = BasicJsonType(n).dump();
+ write_number_with_ubjson_prefix(number.size(), true);
+ for (std::size_t i = 0; i < number.size(); ++i)
+ {
+ oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+ }
}
}
// UBJSON: write number (signed integer)
- template<typename NumberType, typename std::enable_if<
- std::is_signed<NumberType>::value and
- not std::is_floating_point<NumberType>::value, int>::type = 0>
+ template < typename NumberType, typename std::enable_if <
+ std::is_signed<NumberType>::value&&
+ !std::is_floating_point<NumberType>::value, int >::type = 0 >
void write_number_with_ubjson_prefix(const NumberType n,
const bool add_prefix)
{
- if ((std::numeric_limits<std::int8_t>::min)() <= n and n <= (std::numeric_limits<std::int8_t>::max)())
+ if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
{
if (add_prefix)
{
@@ -1355,7 +1348,7 @@ class binary_writer
}
write_number(static_cast<std::int8_t>(n));
}
- else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n and n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
+ else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
{
if (add_prefix)
{
@@ -1363,7 +1356,7 @@ class binary_writer
}
write_number(static_cast<std::uint8_t>(n));
}
- else if ((std::numeric_limits<std::int16_t>::min)() <= n and n <= (std::numeric_limits<std::int16_t>::max)())
+ else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
{
if (add_prefix)
{
@@ -1371,7 +1364,7 @@ class binary_writer
}
write_number(static_cast<std::int16_t>(n));
}
- else if ((std::numeric_limits<std::int32_t>::min)() <= n and n <= (std::numeric_limits<std::int32_t>::max)())
+ else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
{
if (add_prefix)
{
@@ -1379,7 +1372,7 @@ class binary_writer
}
write_number(static_cast<std::int32_t>(n));
}
- else if ((std::numeric_limits<std::int64_t>::min)() <= n and n <= (std::numeric_limits<std::int64_t>::max)())
+ else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
{
if (add_prefix)
{
@@ -1390,19 +1383,23 @@ class binary_writer
// LCOV_EXCL_START
else
{
- JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(n) + " cannot be represented by UBJSON as it does not fit int64"));
+ if (add_prefix)
+ {
+ oa->write_character(to_char_type('H')); // high-precision number
+ }
+
+ const auto number = BasicJsonType(n).dump();
+ write_number_with_ubjson_prefix(number.size(), true);
+ for (std::size_t i = 0; i < number.size(); ++i)
+ {
+ oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+ }
}
// LCOV_EXCL_STOP
}
/*!
@brief determine the type prefix of container values
-
- @note This function does not need to be 100% accurate when it comes to
- integer limits. In case a number exceeds the limits of int64_t,
- this will be detected by a later call to function
- write_number_with_ubjson_prefix. Therefore, we return 'L' for any
- value that does not fit the previous limits.
*/
CharType ubjson_prefix(const BasicJsonType& j) const noexcept
{
@@ -1416,24 +1413,28 @@ class binary_writer
case value_t::number_integer:
{
- if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+ if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
{
return 'i';
}
- if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+ if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
{
return 'U';
}
- if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+ if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
{
return 'I';
}
- if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+ if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
{
return 'l';
}
- // no check and assume int64_t (see note above)
- return 'L';
+ if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+ {
+ return 'L';
+ }
+ // anything else is treated as high-precision number
+ return 'H'; // LCOV_EXCL_LINE
}
case value_t::number_unsigned:
@@ -1454,8 +1455,12 @@ class binary_writer
{
return 'l';
}
- // no check and assume int64_t (see note above)
- return 'L';
+ if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+ {
+ return 'L';
+ }
+ // anything else is treated as high-precision number
+ return 'H'; // LCOV_EXCL_LINE
}
case value_t::number_float:
@@ -1518,20 +1523,40 @@ class binary_writer
oa->write_characters(vec.data(), sizeof(NumberType));
}
+ void write_compact_float(const number_float_t n, detail::input_format_t format)
+ {
+ if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
+ static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
+ static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
+ {
+ oa->write_character(format == detail::input_format_t::cbor
+ ? get_cbor_float_prefix(static_cast<float>(n))
+ : get_msgpack_float_prefix(static_cast<float>(n)));
+ write_number(static_cast<float>(n));
+ }
+ else
+ {
+ oa->write_character(format == detail::input_format_t::cbor
+ ? get_cbor_float_prefix(n)
+ : get_msgpack_float_prefix(n));
+ write_number(n);
+ }
+ }
+
public:
// The following to_char_type functions are implement the conversion
// between uint8_t and CharType. In case CharType is not unsigned,
// such a conversion is required to allow values greater than 128.
// See <https://github.com/nlohmann/json/issues/1286> for a discussion.
template < typename C = CharType,
- enable_if_t < std::is_signed<C>::value and std::is_signed<char>::value > * = nullptr >
+ enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
static constexpr CharType to_char_type(std::uint8_t x) noexcept
{
return *reinterpret_cast<char*>(&x);
}
template < typename C = CharType,
- enable_if_t < std::is_signed<C>::value and std::is_unsigned<char>::value > * = nullptr >
+ enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
static CharType to_char_type(std::uint8_t x) noexcept
{
static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
@@ -1550,8 +1575,8 @@ class binary_writer
template < typename InputCharType, typename C = CharType,
enable_if_t <
- std::is_signed<C>::value and
- std::is_signed<char>::value and
+ std::is_signed<C>::value &&
+ std::is_signed<char>::value &&
std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
> * = nullptr >
static constexpr CharType to_char_type(InputCharType x) noexcept
diff --git a/include/nlohmann/detail/output/serializer.hpp b/include/nlohmann/detail/output/serializer.hpp
index e8f31fd8..865b8904 100644
--- a/include/nlohmann/detail/output/serializer.hpp
+++ b/include/nlohmann/detail/output/serializer.hpp
@@ -2,18 +2,16 @@
#include <algorithm> // reverse, remove, fill, find, none_of
#include <array> // array
-#include <cassert> // assert
#include <clocale> // localeconv, lconv
#include <cmath> // labs, isfinite, isnan, signbit
#include <cstddef> // size_t, ptrdiff_t
#include <cstdint> // uint8_t
#include <cstdio> // snprintf
#include <limits> // numeric_limits
-#include <string> // string
+#include <string> // string, char_traits
#include <type_traits> // is_same
#include <utility> // move
-#include <nlohmann/detail/boolean_operators.hpp>
#include <nlohmann/detail/conversions/to_chars.hpp>
#include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/macro_scope.hpp>
@@ -59,8 +57,8 @@ class serializer
error_handler_t error_handler_ = error_handler_t::strict)
: o(std::move(s))
, loc(std::localeconv())
- , thousands_sep(loc->thousands_sep == nullptr ? '\0' : * (loc->thousands_sep))
- , decimal_point(loc->decimal_point == nullptr ? '\0' : * (loc->decimal_point))
+ , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
+ , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
, indent_char(ichar)
, indent_string(512, indent_char)
, error_handler(error_handler_)
@@ -135,8 +133,8 @@ class serializer
}
// last element
- assert(i != val.m_value.object->cend());
- assert(std::next(i) == val.m_value.object->cend());
+ JSON_ASSERT(i != val.m_value.object->cend());
+ JSON_ASSERT(std::next(i) == val.m_value.object->cend());
o->write_characters(indent_string.c_str(), new_indent);
o->write_character('\"');
dump_escaped(i->first, ensure_ascii);
@@ -163,8 +161,8 @@ class serializer
}
// last element
- assert(i != val.m_value.object->cend());
- assert(std::next(i) == val.m_value.object->cend());
+ JSON_ASSERT(i != val.m_value.object->cend());
+ JSON_ASSERT(std::next(i) == val.m_value.object->cend());
o->write_character('\"');
dump_escaped(i->first, ensure_ascii);
o->write_characters("\":", 2);
@@ -205,7 +203,7 @@ class serializer
}
// last element
- assert(not val.m_value.array->empty());
+ JSON_ASSERT(!val.m_value.array->empty());
o->write_characters(indent_string.c_str(), new_indent);
dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
@@ -226,7 +224,7 @@ class serializer
}
// last element
- assert(not val.m_value.array->empty());
+ JSON_ASSERT(!val.m_value.array->empty());
dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
o->write_character(']');
@@ -260,7 +258,7 @@ class serializer
o->write_characters("\"bytes\": [", 10);
- if (not val.m_value.binary->empty())
+ if (!val.m_value.binary->empty())
{
for (auto i = val.m_value.binary->cbegin();
i != val.m_value.binary->cend() - 1; ++i)
@@ -291,7 +289,7 @@ class serializer
{
o->write_characters("{\"bytes\":[", 10);
- if (not val.m_value.binary->empty())
+ if (!val.m_value.binary->empty())
{
for (auto i = val.m_value.binary->cbegin();
i != val.m_value.binary->cend() - 1; ++i)
@@ -360,7 +358,7 @@ class serializer
}
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
}
@@ -452,7 +450,7 @@ class serializer
{
// escape control characters (0x00..0x1F) or, if
// ensure_ascii parameter is used, non-ASCII characters
- if ((codepoint <= 0x1F) or (ensure_ascii and (codepoint >= 0x7F)))
+ if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
{
if (codepoint <= 0xFFFF)
{
@@ -559,14 +557,14 @@ class serializer
}
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
break;
}
default: // decode found yet incomplete multi-byte code point
{
- if (not ensure_ascii)
+ if (!ensure_ascii)
{
// code point will not be escaped - copy byte to buffer
string_buffer[bytes++] = s[i];
@@ -622,7 +620,7 @@ class serializer
}
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
}
}
@@ -670,11 +668,11 @@ class serializer
@param[in] x integer number (signed or unsigned) to dump
@tparam NumberType either @a number_integer_t or @a number_unsigned_t
*/
- template<typename NumberType, detail::enable_if_t<
- std::is_same<NumberType, number_unsigned_t>::value or
- std::is_same<NumberType, number_integer_t>::value or
- std::is_same<NumberType, binary_char_t>::value,
- int> = 0>
+ template < typename NumberType, detail::enable_if_t <
+ std::is_same<NumberType, number_unsigned_t>::value ||
+ std::is_same<NumberType, number_integer_t>::value ||
+ std::is_same<NumberType, binary_char_t>::value,
+ int > = 0 >
void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
@@ -703,7 +701,7 @@ class serializer
// use a pointer to fill the buffer
auto buffer_ptr = number_buffer.begin();
- const bool is_negative = std::is_same<NumberType, number_integer_t>::value and not(x >= 0); // see issue #755
+ const bool is_negative = std::is_same<NumberType, number_integer_t>::value && !(x >= 0); // see issue #755
number_unsigned_t abs_value;
unsigned int n_chars;
@@ -723,7 +721,7 @@ class serializer
}
// spare 1 byte for '\0'
- assert(n_chars < number_buffer.size() - 1);
+ JSON_ASSERT(n_chars < number_buffer.size() - 1);
// jump to the end to generate the string from backward
// so we later avoid reversing the result
@@ -764,7 +762,7 @@ class serializer
void dump_float(number_float_t x)
{
// NaN / inf
- if (not std::isfinite(x))
+ if (!std::isfinite(x))
{
o->write_characters("null", 4);
return;
@@ -776,8 +774,8 @@ class serializer
//
// NB: The test below works if <long double> == <double>.
static constexpr bool is_ieee_single_or_double
- = (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 24 and std::numeric_limits<number_float_t>::max_exponent == 128) or
- (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 53 and std::numeric_limits<number_float_t>::max_exponent == 1024);
+ = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
+ (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
}
@@ -799,9 +797,9 @@ class serializer
std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
// negative value indicates an error
- assert(len > 0);
+ JSON_ASSERT(len > 0);
// check if buffer was large enough
- assert(static_cast<std::size_t>(len) < number_buffer.size());
+ JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
// erase thousands separator
if (thousands_sep != '\0')
@@ -809,12 +807,12 @@ class serializer
const auto end = std::remove(number_buffer.begin(),
number_buffer.begin() + len, thousands_sep);
std::fill(end, number_buffer.end(), '\0');
- assert((end - number_buffer.begin()) <= len);
+ JSON_ASSERT((end - number_buffer.begin()) <= len);
len = (end - number_buffer.begin());
}
// convert decimal point to '.'
- if (decimal_point != '\0' and decimal_point != '.')
+ if (decimal_point != '\0' && decimal_point != '.')
{
const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
if (dec_pos != number_buffer.end())
@@ -830,7 +828,7 @@ class serializer
std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
[](char c)
{
- return c == '.' or c == 'e';
+ return c == '.' || c == 'e';
});
if (value_is_int_like)
@@ -889,7 +887,7 @@ class serializer
: (0xFFu >> type) & (byte);
std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
- assert(index < 400);
+ JSON_ASSERT(index < 400);
state = utf8d[index];
return state;
}
@@ -901,7 +899,7 @@ class serializer
*/
number_unsigned_t remove_sign(number_unsigned_t x)
{
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
return x; // LCOV_EXCL_LINE
}
@@ -916,7 +914,7 @@ class serializer
*/
inline number_unsigned_t remove_sign(number_integer_t x) noexcept
{
- assert(x < 0 and x < (std::numeric_limits<number_integer_t>::max)());
+ JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)());
return static_cast<number_unsigned_t>(-(x + 1)) + 1;
}
diff --git a/include/nlohmann/detail/value_t.hpp b/include/nlohmann/detail/value_t.hpp
index 7580d856..0383df06 100644
--- a/include/nlohmann/detail/value_t.hpp
+++ b/include/nlohmann/detail/value_t.hpp
@@ -5,8 +5,6 @@
#include <cstdint> // uint8_t
#include <string> // string
-#include <nlohmann/detail/boolean_operators.hpp>
-
namespace nlohmann
{
namespace detail
@@ -77,7 +75,7 @@ inline bool operator<(const value_t lhs, const value_t rhs) noexcept
const auto l_index = static_cast<std::size_t>(lhs);
const auto r_index = static_cast<std::size_t>(rhs);
- return l_index < order.size() and r_index < order.size() and order[l_index] < order[r_index];
+ return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
}
} // namespace detail
} // namespace nlohmann
diff --git a/include/nlohmann/json.hpp b/include/nlohmann/json.hpp
index 409a6e79..3b122b0c 100644
--- a/include/nlohmann/json.hpp
+++ b/include/nlohmann/json.hpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -31,11 +31,10 @@ SOFTWARE.
#define INCLUDE_NLOHMANN_JSON_HPP_
#define NLOHMANN_JSON_VERSION_MAJOR 3
-#define NLOHMANN_JSON_VERSION_MINOR 8
+#define NLOHMANN_JSON_VERSION_MINOR 9
#define NLOHMANN_JSON_VERSION_PATCH 0
#include <algorithm> // all_of, find, for_each
-#include <cassert> // assert
#include <cstddef> // nullptr_t, ptrdiff_t, size_t
#include <functional> // hash, less
#include <initializer_list> // initializer_list
@@ -49,10 +48,10 @@ SOFTWARE.
#include <nlohmann/adl_serializer.hpp>
#include <nlohmann/byte_container_with_subtype.hpp>
-#include <nlohmann/detail/boolean_operators.hpp>
#include <nlohmann/detail/conversions/from_json.hpp>
#include <nlohmann/detail/conversions/to_json.hpp>
#include <nlohmann/detail/exceptions.hpp>
+#include <nlohmann/detail/hash.hpp>
#include <nlohmann/detail/input/binary_reader.hpp>
#include <nlohmann/detail/input/input_adapters.hpp>
#include <nlohmann/detail/input/lexer.hpp>
@@ -72,6 +71,7 @@ SOFTWARE.
#include <nlohmann/detail/output/serializer.hpp>
#include <nlohmann/detail/value_t.hpp>
#include <nlohmann/json_fwd.hpp>
+#include <nlohmann/ordered_map.hpp>
/*!
@brief namespace for Niels Lohmann
@@ -196,10 +196,12 @@ class basic_json
static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
InputAdapterType adapter,
detail::parser_callback_t<basic_json>cb = nullptr,
- bool allow_exceptions = true
+ const bool allow_exceptions = true,
+ const bool ignore_comments = false
)
{
- return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter), std::move(cb), allow_exceptions);
+ return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
+ std::move(cb), allow_exceptions, ignore_comments);
}
using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
@@ -228,6 +230,8 @@ class basic_json
using json_serializer = JSONSerializer<T, SFINAE>;
/// how to treat decoding errors
using error_handler_t = detail::error_handler_t;
+ /// how to treat CBOR tags
+ using cbor_tag_handler_t = detail::cbor_tag_handler_t;
/// helper type for initializer lists of basic_json values
using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
@@ -340,7 +344,7 @@ class basic_json
{
basic_json result;
- result["copyright"] = "(C) 2013-2017 Niels Lohmann";
+ result["copyright"] = "(C) 2013-2020 Niels Lohmann";
result["name"] = "JSON for Modern C++";
result["url"] = "https://github.com/nlohmann/json";
result["version"]["string"] =
@@ -922,7 +926,7 @@ class basic_json
};
std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
- assert(object != nullptr);
+ JSON_ASSERT(object != nullptr);
return object.release();
}
@@ -1048,7 +1052,7 @@ class basic_json
object = nullptr; // silence warning, see #821
if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
{
- JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.8.0")); // LCOV_EXCL_LINE
+ JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.9.0")); // LCOV_EXCL_LINE
}
break;
}
@@ -1135,7 +1139,7 @@ class basic_json
}
}
- while (not stack.empty())
+ while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
@@ -1217,10 +1221,10 @@ class basic_json
*/
void assert_invariant() const noexcept
{
- assert(m_type != value_t::object or m_value.object != nullptr);
- assert(m_type != value_t::array or m_value.array != nullptr);
- assert(m_type != value_t::string or m_value.string != nullptr);
- assert(m_type != value_t::binary or m_value.binary != nullptr);
+ JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
+ JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
+ JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
+ JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
}
public:
@@ -1428,10 +1432,10 @@ class basic_json
@since version 2.1.0
*/
- template <typename CompatibleType,
- typename U = detail::uncvref_t<CompatibleType>,
- detail::enable_if_t<
- not detail::is_basic_json<U>::value and detail::is_compatible_type<basic_json_t, U>::value, int> = 0>
+ template < typename CompatibleType,
+ typename U = detail::uncvref_t<CompatibleType>,
+ detail::enable_if_t <
+ !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
basic_json(CompatibleType && val) noexcept(noexcept(
JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
std::forward<CompatibleType>(val))))
@@ -1466,9 +1470,9 @@ class basic_json
@since version 3.2.0
*/
- template <typename BasicJsonType,
- detail::enable_if_t<
- detail::is_basic_json<BasicJsonType>::value and not std::is_same<basic_json, BasicJsonType>::value, int> = 0>
+ template < typename BasicJsonType,
+ detail::enable_if_t <
+ detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
basic_json(const BasicJsonType& val)
{
using other_boolean_t = typename BasicJsonType::boolean_t;
@@ -1513,7 +1517,7 @@ class basic_json
m_type = value_t::discarded;
break;
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
assert_invariant();
}
@@ -1601,11 +1605,11 @@ class basic_json
bool is_an_object = std::all_of(init.begin(), init.end(),
[](const detail::json_ref<basic_json>& element_ref)
{
- return element_ref->is_array() and element_ref->size() == 2 and (*element_ref)[0].is_string();
+ return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
});
// adjust type if type deduction is not wanted
- if (not type_deduction)
+ if (!type_deduction)
{
// if array is wanted, do not create an object though possible
if (manual_type == value_t::array)
@@ -1614,7 +1618,7 @@ class basic_json
}
// if object is wanted but impossible, throw an exception
- if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object and not is_an_object))
+ if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
{
JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
}
@@ -1908,13 +1912,13 @@ class basic_json
@since version 1.0.0
*/
- template<class InputIT, typename std::enable_if<
- std::is_same<InputIT, typename basic_json_t::iterator>::value or
- std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int>::type = 0>
+ template < class InputIT, typename std::enable_if <
+ std::is_same<InputIT, typename basic_json_t::iterator>::value ||
+ std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
basic_json(InputIT first, InputIT last)
{
- assert(first.m_object != nullptr);
- assert(last.m_object != nullptr);
+ JSON_ASSERT(first.m_object != nullptr);
+ JSON_ASSERT(last.m_object != nullptr);
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
@@ -1934,8 +1938,8 @@ class basic_json
case value_t::number_unsigned:
case value_t::string:
{
- if (JSON_HEDLEY_UNLIKELY(not first.m_it.primitive_iterator.is_begin()
- or not last.m_it.primitive_iterator.is_end()))
+ if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
+ || !last.m_it.primitive_iterator.is_end()))
{
JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
}
@@ -2011,9 +2015,9 @@ class basic_json
// other constructors and destructor //
///////////////////////////////////////
- template <typename JsonRef,
- detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
- std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
+ template<typename JsonRef,
+ detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
+ std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
/*!
@@ -2168,9 +2172,9 @@ class basic_json
@since version 1.0.0
*/
basic_json& operator=(basic_json other) noexcept (
- std::is_nothrow_move_constructible<value_t>::value and
- std::is_nothrow_move_assignable<value_t>::value and
- std::is_nothrow_move_constructible<json_value>::value and
+ std::is_nothrow_move_constructible<value_t>::value&&
+ std::is_nothrow_move_assignable<value_t>::value&&
+ std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value
)
{
@@ -2236,7 +2240,8 @@ class basic_json
@param[in] error_handler how to react on decoding errors; there are three
possible values: `strict` (throws and exception in case a decoding error
occurs; default), `replace` (replace invalid UTF-8 sequences with U+FFFD),
- and `ignore` (ignore invalid UTF-8 sequences during serialization).
+ and `ignore` (ignore invalid UTF-8 sequences during serialization; all
+ bytes are copied to the output unchanged).
@return string containing the serialization of the JSON value
@@ -2349,7 +2354,7 @@ class basic_json
*/
constexpr bool is_primitive() const noexcept
{
- return is_null() or is_string() or is_boolean() or is_number() or is_binary();
+ return is_null() || is_string() || is_boolean() || is_number() || is_binary();
}
/*!
@@ -2376,7 +2381,7 @@ class basic_json
*/
constexpr bool is_structured() const noexcept
{
- return is_array() or is_object();
+ return is_array() || is_object();
}
/*!
@@ -2450,7 +2455,7 @@ class basic_json
*/
constexpr bool is_number() const noexcept
{
- return is_number_integer() or is_number_float();
+ return is_number_integer() || is_number_float();
}
/*!
@@ -2479,7 +2484,7 @@ class basic_json
*/
constexpr bool is_number_integer() const noexcept
{
- return m_type == value_t::number_integer or m_type == value_t::number_unsigned;
+ return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
}
/*!
@@ -2860,9 +2865,9 @@ class basic_json
@since version 3.2.0
*/
- template<typename BasicJsonType, detail::enable_if_t<
- not std::is_same<BasicJsonType, basic_json>::value and
- detail::is_basic_json<BasicJsonType>::value, int> = 0>
+ template < typename BasicJsonType, detail::enable_if_t <
+ !std::is_same<BasicJsonType, basic_json>::value&&
+ detail::is_basic_json<BasicJsonType>::value, int > = 0 >
BasicJsonType get() const
{
return *this;
@@ -2907,19 +2912,19 @@ class basic_json
@since version 2.1.0
*/
- template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
- detail::enable_if_t <
- not detail::is_basic_json<ValueType>::value and
- detail::has_from_json<basic_json_t, ValueType>::value and
- not detail::has_non_default_from_json<basic_json_t, ValueType>::value,
- int> = 0>
+ template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
+ detail::enable_if_t <
+ !detail::is_basic_json<ValueType>::value &&
+ detail::has_from_json<basic_json_t, ValueType>::value &&
+ !detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+ int > = 0 >
ValueType get() const noexcept(noexcept(
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
{
// we cannot static_assert on ValueTypeCV being non-const, because
// there is support for get<const basic_json_t>(), which is why we
// still need the uncvref
- static_assert(not std::is_reference<ValueTypeCV>::value,
+ static_assert(!std::is_reference<ValueTypeCV>::value,
"get() cannot be used with reference types, you might want to use get_ref()");
static_assert(std::is_default_constructible<ValueType>::value,
"types must be DefaultConstructible when used with get()");
@@ -2960,14 +2965,14 @@ class basic_json
@since version 2.1.0
*/
- template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
- detail::enable_if_t<not std::is_same<basic_json_t, ValueType>::value and
- detail::has_non_default_from_json<basic_json_t, ValueType>::value,
- int> = 0>
+ template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
+ detail::enable_if_t < !std::is_same<basic_json_t, ValueType>::value &&
+ detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+ int > = 0 >
ValueType get() const noexcept(noexcept(
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
{
- static_assert(not std::is_reference<ValueTypeCV>::value,
+ static_assert(!std::is_reference<ValueTypeCV>::value,
"get() cannot be used with reference types, you might want to use get_ref()");
return JSONSerializer<ValueType>::from_json(*this);
}
@@ -3005,11 +3010,11 @@ class basic_json
@since version 3.3.0
*/
- template<typename ValueType,
- detail::enable_if_t <
- not detail::is_basic_json<ValueType>::value and
- detail::has_from_json<basic_json_t, ValueType>::value,
- int> = 0>
+ template < typename ValueType,
+ detail::enable_if_t <
+ !detail::is_basic_json<ValueType>::value&&
+ detail::has_from_json<basic_json_t, ValueType>::value,
+ int > = 0 >
ValueType & get_to(ValueType& v) const noexcept(noexcept(
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
{
@@ -3017,6 +3022,18 @@ class basic_json
return v;
}
+ // specialization to allow to call get_to with a basic_json value
+ // see https://github.com/nlohmann/json/issues/2175
+ template<typename ValueType,
+ detail::enable_if_t <
+ detail::is_basic_json<ValueType>::value,
+ int> = 0>
+ ValueType & get_to(ValueType& v) const
+ {
+ v = *this;
+ return v;
+ }
+
template <
typename T, std::size_t N,
typename Array = T (&)[N],
@@ -3069,9 +3086,9 @@ class basic_json
@brief get a pointer value (implicit)
@copydoc get_ptr()
*/
- template<typename PointerType, typename std::enable_if<
- std::is_pointer<PointerType>::value and
- std::is_const<typename std::remove_pointer<PointerType>::type>::value, int>::type = 0>
+ template < typename PointerType, typename std::enable_if <
+ std::is_pointer<PointerType>::value&&
+ std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
{
// delegate the call to get_impl_ptr<>() const
@@ -3163,9 +3180,9 @@ class basic_json
@brief get a reference value (implicit)
@copydoc get_ref()
*/
- template<typename ReferenceType, typename std::enable_if<
- std::is_reference<ReferenceType>::value and
- std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int>::type = 0>
+ template < typename ReferenceType, typename std::enable_if <
+ std::is_reference<ReferenceType>::value&&
+ std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
ReferenceType get_ref() const
{
// delegate call to get_ref_impl
@@ -3202,17 +3219,17 @@ class basic_json
@since version 1.0.0
*/
template < typename ValueType, typename std::enable_if <
- not std::is_pointer<ValueType>::value and
- not std::is_same<ValueType, detail::json_ref<basic_json>>::value and
- not std::is_same<ValueType, typename string_t::value_type>::value and
- not detail::is_basic_json<ValueType>::value
- and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
-#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) and _MSC_VER >= 1910 and _MSC_VER <= 1914))
- and not std::is_same<ValueType, typename std::string_view>::value
+ !std::is_pointer<ValueType>::value&&
+ !std::is_same<ValueType, detail::json_ref<basic_json>>::value&&
+ !std::is_same<ValueType, typename string_t::value_type>::value&&
+ !detail::is_basic_json<ValueType>::value
+ && !std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
+#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
+ && !std::is_same<ValueType, typename std::string_view>::value
#endif
- and detail::is_detected<detail::get_template_function, const basic_json_t&, ValueType>::value
+ && detail::is_detected<detail::get_template_function, const basic_json_t&, ValueType>::value
, int >::type = 0 >
- operator ValueType() const
+ JSON_EXPLICIT operator ValueType() const
{
// delegate the call to get<>() const
return get<ValueType>();
@@ -3229,7 +3246,7 @@ class basic_json
*/
binary_t& get_binary()
{
- if (not is_binary())
+ if (!is_binary())
{
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
}
@@ -3240,7 +3257,7 @@ class basic_json
/// @copydoc get_binary()
const binary_t& get_binary() const
{
- if (not is_binary())
+ if (!is_binary())
{
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
}
@@ -3618,7 +3635,7 @@ class basic_json
// const operator[] only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
- assert(m_value.object->find(key) != m_value.object->end());
+ JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
return m_value.object->find(key)->second;
}
@@ -3710,7 +3727,7 @@ class basic_json
// at only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
- assert(m_value.object->find(key) != m_value.object->end());
+ JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
return m_value.object->find(key)->second;
}
@@ -3767,9 +3784,10 @@ class basic_json
@since version 1.0.0
*/
- template<class ValueType, typename std::enable_if<
- std::is_convertible<basic_json_t, ValueType>::value
- and not std::is_same<value_t, ValueType>::value, int>::type = 0>
+ // using std::is_convertible in a std::enable_if will fail when using explicit conversions
+ template < class ValueType, typename std::enable_if <
+ detail::is_getable<basic_json_t, ValueType>::value
+ && !std::is_same<value_t, ValueType>::value, int >::type = 0 >
ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
{
// at only works for objects
@@ -3779,7 +3797,7 @@ class basic_json
const auto it = find(key);
if (it != end())
{
- return *it;
+ return it->template get<ValueType>();
}
return default_value;
@@ -3841,7 +3859,7 @@ class basic_json
@since version 2.0.2
*/
template<class ValueType, typename std::enable_if<
- std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
+ detail::is_getable<basic_json_t, ValueType>::value, int>::type = 0>
ValueType value(const json_pointer& ptr, const ValueType& default_value) const
{
// at only works for objects
@@ -3850,7 +3868,7 @@ class basic_json
// if pointer resolves a value, return it or use default value
JSON_TRY
{
- return ptr.get_checked(this);
+ return ptr.get_checked(this).template get<ValueType>();
}
JSON_INTERNAL_CATCH (out_of_range&)
{
@@ -4003,10 +4021,10 @@ class basic_json
@since version 1.0.0
*/
- template<class IteratorType, typename std::enable_if<
- std::is_same<IteratorType, typename basic_json_t::iterator>::value or
- std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
- = 0>
+ template < class IteratorType, typename std::enable_if <
+ std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+ std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
+ = 0 >
IteratorType erase(IteratorType pos)
{
// make sure iterator fits the current value
@@ -4026,7 +4044,7 @@ class basic_json
case value_t::string:
case value_t::binary:
{
- if (JSON_HEDLEY_UNLIKELY(not pos.m_it.primitive_iterator.is_begin()))
+ if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
{
JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
}
@@ -4116,14 +4134,14 @@ class basic_json
@since version 1.0.0
*/
- template<class IteratorType, typename std::enable_if<
- std::is_same<IteratorType, typename basic_json_t::iterator>::value or
- std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
- = 0>
+ template < class IteratorType, typename std::enable_if <
+ std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+ std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
+ = 0 >
IteratorType erase(IteratorType first, IteratorType last)
{
// make sure iterator fits the current value
- if (JSON_HEDLEY_UNLIKELY(this != first.m_object or this != last.m_object))
+ if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
{
JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
}
@@ -4139,8 +4157,8 @@ class basic_json
case value_t::string:
case value_t::binary:
{
- if (JSON_HEDLEY_LIKELY(not first.m_it.primitive_iterator.is_begin()
- or not last.m_it.primitive_iterator.is_end()))
+ if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
+ || !last.m_it.primitive_iterator.is_end()))
{
JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
}
@@ -4385,11 +4403,11 @@ class basic_json
@since version 3.6.0
*/
- template<typename KeyT, typename std::enable_if<
- not std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int>::type = 0>
+ template < typename KeyT, typename std::enable_if <
+ !std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int >::type = 0 >
bool contains(KeyT && key) const
{
- return is_object() and m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
+ return is_object() && m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
}
/*!
@@ -5207,7 +5225,7 @@ class basic_json
void push_back(basic_json&& val)
{
// push_back only works for null objects or arrays
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
+ if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
}
@@ -5242,7 +5260,7 @@ class basic_json
void push_back(const basic_json& val)
{
// push_back only works for null objects or arrays
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
+ if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
}
@@ -5292,7 +5310,7 @@ class basic_json
void push_back(const typename object_t::value_type& val)
{
// push_back only works for null objects or objects
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_object())))
+ if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
{
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
}
@@ -5346,7 +5364,7 @@ class basic_json
*/
void push_back(initializer_list_t init)
{
- if (is_object() and init.size() == 2 and (*init.begin())->is_string())
+ if (is_object() && init.size() == 2 && (*init.begin())->is_string())
{
basic_json&& key = init.begin()->moved_or_copied();
push_back(typename object_t::value_type(
@@ -5395,7 +5413,7 @@ class basic_json
reference emplace_back(Args&& ... args)
{
// emplace_back only works for null objects or arrays
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
+ if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
}
@@ -5448,7 +5466,7 @@ class basic_json
std::pair<iterator, bool> emplace(Args&& ... args)
{
// emplace only works for null objects or arrays
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_object())))
+ if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
{
JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
}
@@ -5478,7 +5496,7 @@ class basic_json
iterator insert_iterator(const_iterator pos, Args&& ... args)
{
iterator result(this);
- assert(m_value.array != nullptr);
+ JSON_ASSERT(m_value.array != nullptr);
auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
@@ -5615,7 +5633,7 @@ class basic_json
iterator insert(const_iterator pos, const_iterator first, const_iterator last)
{
// insert only works for arrays
- if (JSON_HEDLEY_UNLIKELY(not is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!is_array()))
{
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
}
@@ -5668,7 +5686,7 @@ class basic_json
iterator insert(const_iterator pos, initializer_list_t ilist)
{
// insert only works for arrays
- if (JSON_HEDLEY_UNLIKELY(not is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!is_array()))
{
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
}
@@ -5709,7 +5727,7 @@ class basic_json
void insert(const_iterator first, const_iterator last)
{
// insert only works for objects
- if (JSON_HEDLEY_UNLIKELY(not is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
}
@@ -5721,7 +5739,7 @@ class basic_json
}
// passed iterators must belong to objects
- if (JSON_HEDLEY_UNLIKELY(not first.m_object->is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
{
JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
}
@@ -5758,11 +5776,11 @@ class basic_json
assert_invariant();
}
- if (JSON_HEDLEY_UNLIKELY(not is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
}
- if (JSON_HEDLEY_UNLIKELY(not j.is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
{
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
}
@@ -5809,7 +5827,7 @@ class basic_json
assert_invariant();
}
- if (JSON_HEDLEY_UNLIKELY(not is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
}
@@ -5821,8 +5839,8 @@ class basic_json
}
// passed iterators must belong to objects
- if (JSON_HEDLEY_UNLIKELY(not first.m_object->is_object()
- or not last.m_object->is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()
+ || !last.m_object->is_object()))
{
JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
}
@@ -5851,9 +5869,9 @@ class basic_json
@since version 1.0.0
*/
void swap(reference other) noexcept (
- std::is_nothrow_move_constructible<value_t>::value and
- std::is_nothrow_move_assignable<value_t>::value and
- std::is_nothrow_move_constructible<json_value>::value and
+ std::is_nothrow_move_constructible<value_t>::value&&
+ std::is_nothrow_move_assignable<value_t>::value&&
+ std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value
)
{
@@ -5865,6 +5883,34 @@ class basic_json
/*!
@brief exchanges the values
+ Exchanges the contents of the JSON value from @a left with those of @a right. Does not
+ invoke any move, copy, or swap operations on individual elements. All
+ iterators and references remain valid. The past-the-end iterator is
+ invalidated. implemented as a friend function callable via ADL.
+
+ @param[in,out] left JSON value to exchange the contents with
+ @param[in,out] right JSON value to exchange the contents with
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how JSON values can be swapped with
+ `swap()`.,swap__reference}
+
+ @since version 1.0.0
+ */
+ friend void swap(reference left, reference right) noexcept (
+ std::is_nothrow_move_constructible<value_t>::value&&
+ std::is_nothrow_move_assignable<value_t>::value&&
+ std::is_nothrow_move_constructible<json_value>::value&&
+ std::is_nothrow_move_assignable<json_value>::value
+ )
+ {
+ left.swap(right);
+ }
+
+ /*!
+ @brief exchanges the values
+
Exchanges the contents of a JSON array with those of @a other. Does not
invoke any move, copy, or swap operations on individual elements. All
iterators and references remain valid. The past-the-end iterator is
@@ -6113,27 +6159,27 @@ class basic_json
return false;
}
}
- else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+ else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
{
return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
}
- else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+ else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
{
return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
}
- else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
+ else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
{
return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
}
- else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
+ else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
{
return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
}
- else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
+ else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
{
return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
}
- else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
+ else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
{
return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
}
@@ -6183,7 +6229,7 @@ class basic_json
*/
friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
{
- return not (lhs == rhs);
+ return !(lhs == rhs);
}
/*!
@@ -6276,27 +6322,27 @@ class basic_json
return false;
}
}
- else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+ else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
{
return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
}
- else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+ else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
{
return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
}
- else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
+ else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
{
return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
}
- else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
+ else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
{
return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
}
- else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
+ else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
{
return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
}
- else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
+ else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
{
return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
}
@@ -6350,7 +6396,7 @@ class basic_json
*/
friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
{
- return not (rhs < lhs);
+ return !(rhs < lhs);
}
/*!
@@ -6396,7 +6442,7 @@ class basic_json
*/
friend bool operator>(const_reference lhs, const_reference rhs) noexcept
{
- return not (lhs <= rhs);
+ return !(lhs <= rhs);
}
/*!
@@ -6442,7 +6488,7 @@ class basic_json
*/
friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
{
- return not (lhs < rhs);
+ return !(lhs < rhs);
}
/*!
@@ -6563,6 +6609,9 @@ class basic_json
(optional)
@param[in] allow_exceptions whether to throw exceptions in case of a
parse error (optional, true by default)
+ @param[in] ignore_comments whether comments should be ignored and treated
+ like whitespace (true) or yield a parse error (true); (optional, false by
+ default)
@return deserialized JSON value; in case of a parse error and
@a allow_exceptions set to `false`, the return value will be
@@ -6591,16 +6640,18 @@ class basic_json
@liveexample{The example below demonstrates the `parse()` function reading
from a contiguous container.,parse__contiguouscontainer__parser_callback_t}
- @since version 2.0.3 (contiguous containers)
+ @since version 2.0.3 (contiguous containers); version 3.9.0 allowed to
+ ignore comments.
*/
template<typename InputType>
JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json parse(InputType&& i,
const parser_callback_t cb = nullptr,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const bool ignore_comments = false)
{
basic_json result;
- parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions).parse(true, result);
+ parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
return result;
}
@@ -6617,6 +6668,9 @@ class basic_json
(optional)
@param[in] allow_exceptions whether to throw exceptions in case of a
parse error (optional, true by default)
+ @param[in] ignore_comments whether comments should be ignored and treated
+ like whitespace (true) or yield a parse error (true); (optional, false by
+ default)
@return deserialized JSON value; in case of a parse error and
@a allow_exceptions set to `false`, the return value will be
@@ -6632,10 +6686,11 @@ class basic_json
static basic_json parse(IteratorType first,
IteratorType last,
const parser_callback_t cb = nullptr,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const bool ignore_comments = false)
{
basic_json result;
- parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions).parse(true, result);
+ parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
return result;
}
@@ -6643,10 +6698,11 @@ class basic_json
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
static basic_json parse(detail::span_input_adapter&& i,
const parser_callback_t cb = nullptr,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const bool ignore_comments = false)
{
basic_json result;
- parser(i.get(), cb, allow_exceptions).parse(true, result);
+ parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
return result;
}
@@ -6666,6 +6722,9 @@ class basic_json
iterators.
@param[in] i input to read from
+ @param[in] ignore_comments whether comments should be ignored and treated
+ like whitespace (true) or yield a parse error (true); (optional, false by
+ default)
@return Whether the input read from @a i is valid JSON.
@@ -6678,22 +6737,25 @@ class basic_json
from a string.,accept__string}
*/
template<typename InputType>
- static bool accept(InputType&& i)
+ static bool accept(InputType&& i,
+ const bool ignore_comments = false)
{
- return parser(detail::input_adapter(std::forward<InputType>(i))).accept(true);
+ return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
}
template<typename IteratorType>
- static bool accept(IteratorType first, IteratorType last)
+ static bool accept(IteratorType first, IteratorType last,
+ const bool ignore_comments = false)
{
- return parser(detail::input_adapter(std::move(first), std::move(last))).accept(true);
+ return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
}
JSON_HEDLEY_WARN_UNUSED_RESULT
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
- static bool accept(detail::span_input_adapter&& i)
+ static bool accept(detail::span_input_adapter&& i,
+ const bool ignore_comments = false)
{
- return parser(i.get()).accept(true);
+ return parser(i.get(), nullptr, false, ignore_comments).accept(true);
}
/*!
@@ -6713,6 +6775,9 @@ class basic_json
@param[in,out] sax SAX event listener
@param[in] format the format to parse (JSON, CBOR, MessagePack, or UBJSON)
@param[in] strict whether the input has to be consumed completely
+ @param[in] ignore_comments whether comments should be ignored and treated
+ like whitespace (true) or yield a parse error (true); (optional, false by
+ default); only applies to the JSON file format.
@return return value of the last processed SAX event
@@ -6737,11 +6802,12 @@ class basic_json
JSON_HEDLEY_NON_NULL(2)
static bool sax_parse(InputType&& i, SAX* sax,
input_format_t format = input_format_t::json,
- const bool strict = true)
+ const bool strict = true,
+ const bool ignore_comments = false)
{
auto ia = detail::input_adapter(std::forward<InputType>(i));
return format == input_format_t::json
- ? parser(std::move(ia)).sax_parse(sax, strict)
+ ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
}
@@ -6749,11 +6815,12 @@ class basic_json
JSON_HEDLEY_NON_NULL(3)
static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
input_format_t format = input_format_t::json,
- const bool strict = true)
+ const bool strict = true,
+ const bool ignore_comments = false)
{
auto ia = detail::input_adapter(std::move(first), std::move(last));
return format == input_format_t::json
- ? parser(std::move(ia)).sax_parse(sax, strict)
+ ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
}
@@ -6762,11 +6829,12 @@ class basic_json
JSON_HEDLEY_NON_NULL(2)
static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
input_format_t format = input_format_t::json,
- const bool strict = true)
+ const bool strict = true,
+ const bool ignore_comments = false)
{
auto ia = i.get();
return format == input_format_t::json
- ? parser(std::move(ia)).sax_parse(sax, strict)
+ ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
}
@@ -6968,7 +7036,6 @@ class basic_json
- bignum (0xC2..0xC3)
- decimal fraction (0xC4)
- bigfloat (0xC5)
- - tagged items (0xC6..0xD4, 0xD8..0xDB)
- expected conversions (0xD5..0xD7)
- simple values (0xE0..0xF3, 0xF8)
- undefined (0xF7)
@@ -6984,7 +7051,7 @@ class basic_json
vector in CBOR format.,to_cbor}
@sa http://cbor.io
- @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+ @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
analogous deserialization
@sa @ref to_msgpack(const basic_json&) for the related MessagePack format
@sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
@@ -7040,7 +7107,8 @@ class basic_json
number_unsigned | 256..65535 | uint 16 | 0xCD
number_unsigned | 65536..4294967295 | uint 32 | 0xCE
number_unsigned | 4294967296..18446744073709551615 | uint 64 | 0xCF
- number_float | *any value* | float 64 | 0xCB
+ number_float | *any value representable by a float* | float 32 | 0xCA
+ number_float | *any value NOT representable by a float* | float 64 | 0xCB
string | *length*: 0..31 | fixstr | 0xA0..0xBF
string | *length*: 32..255 | str 8 | 0xD9
string | *length*: 256..65535 | str 16 | 0xDA
@@ -7064,9 +7132,6 @@ class basic_json
- arrays with more than 4294967295 elements
- objects with more than 4294967295 elements
- @note The following MessagePack types are not used in the conversion:
- - float 32 (0xCA)
-
@note Any MessagePack output created @ref to_msgpack can be successfully
parsed by @ref from_msgpack.
@@ -7135,6 +7200,7 @@ class basic_json
number_unsigned | 256..32767 | int16 | `I`
number_unsigned | 32768..2147483647 | int32 | `l`
number_unsigned | 2147483648..9223372036854775807 | int64 | `L`
+ number_unsigned | 2147483649..18446744073709551615 | high-precision | `H`
number_float | *any value* | float64 | `D`
string | *with shortest length indicator* | string | `S`
array | *see notes on optimized format* | array | `[`
@@ -7145,7 +7211,6 @@ class basic_json
@note The following values can **not** be converted to a UBJSON value:
- strings with more than 9223372036854775807 bytes (theoretical)
- - unsigned integer numbers above 9223372036854775807
@note The following markers are not used in the conversion:
- `Z`: no-op values are not created.
@@ -7357,7 +7422,6 @@ class basic_json
- bignum (0xC2..0xC3)
- decimal fraction (0xC4)
- bigfloat (0xC5)
- - tagged items (0xC6..0xD4, 0xD8..0xDB)
- expected conversions (0xD5..0xD7)
- simple values (0xE0..0xF3, 0xF8)
- undefined (0xF7)
@@ -7374,6 +7438,7 @@ class basic_json
(true by default)
@param[in] allow_exceptions whether to throw exceptions in case of a
parse error (optional, true by default)
+ @param[in] tag_handler how to treat CBOR tags (optional, error by default)
@return deserialized JSON value; in case of a parse error and
@a allow_exceptions set to `false`, the return value will be
@@ -7400,34 +7465,36 @@ class basic_json
@since version 2.0.9; parameter @a start_index since 2.1.1; changed to
consume input adapters, removed start_index parameter, and added
@a strict parameter since 3.0.0; added @a allow_exceptions parameter
- since 3.2.0
+ since 3.2.0; added @a tag_handler parameter since 3.9.0.
*/
template<typename InputType>
JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json from_cbor(InputType&& i,
const bool strict = true,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
{
basic_json result;
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
auto ia = detail::input_adapter(std::forward<InputType>(i));
- const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict);
+ const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
return res ? result : basic_json(value_t::discarded);
}
/*!
- @copydoc from_cbor(detail::input_adapter&&, const bool, const bool)
+ @copydoc from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t)
*/
template<typename IteratorType>
JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json from_cbor(IteratorType first, IteratorType last,
const bool strict = true,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
{
basic_json result;
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
auto ia = detail::input_adapter(std::move(first), std::move(last));
- const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict);
+ const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
return res ? result : basic_json(value_t::discarded);
}
@@ -7436,9 +7503,10 @@ class basic_json
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
static basic_json from_cbor(const T* ptr, std::size_t len,
const bool strict = true,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
{
- return from_cbor(ptr, ptr + len, strict, allow_exceptions);
+ return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
}
@@ -7446,12 +7514,13 @@ class basic_json
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
static basic_json from_cbor(detail::span_input_adapter&& i,
const bool strict = true,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
{
basic_json result;
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
auto ia = i.get();
- const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict);
+ const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
return res ? result : basic_json(value_t::discarded);
}
@@ -7529,7 +7598,7 @@ class basic_json
@sa http://msgpack.org
@sa @ref to_msgpack(const basic_json&) for the analogous serialization
- @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+ @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
related CBOR format
@sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for
the related UBJSON format
@@ -7616,6 +7685,7 @@ class basic_json
int16 | number_integer | `I`
int32 | number_integer | `l`
int64 | number_integer | `L`
+ high-precision number | number_integer, number_unsigned, or number_float - depends on number string | 'H'
string | string | `S`
char | string | `C`
array | array (optimized values are supported) | `[`
@@ -7647,7 +7717,7 @@ class basic_json
@sa http://ubjson.org
@sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
analogous serialization
- @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+ @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
related CBOR format
@sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
the related MessagePack format
@@ -7762,7 +7832,7 @@ class basic_json
@sa http://bsonspec.org/spec.html
@sa @ref to_bson(const basic_json&) for the analogous serialization
- @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+ @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
related CBOR format
@sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
the related MessagePack format
@@ -8181,7 +8251,7 @@ class basic_json
else
{
const auto idx = json_pointer::array_index(last_path);
- if (JSON_HEDLEY_UNLIKELY(static_cast<size_type>(idx) > parent.size()))
+ if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
{
// avoid undefined behavior
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
@@ -8195,7 +8265,7 @@ class basic_json
// if there exists a parent it cannot be primitive
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
};
@@ -8224,12 +8294,12 @@ class basic_json
else if (parent.is_array())
{
// note erase performs range check
- parent.erase(static_cast<size_type>(json_pointer::array_index(last_path)));
+ parent.erase(json_pointer::array_index(last_path));
}
};
// type check: top level value must be an array
- if (JSON_HEDLEY_UNLIKELY(not json_patch.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
{
JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
}
@@ -8255,7 +8325,7 @@ class basic_json
}
// check if result is of type string
- if (JSON_HEDLEY_UNLIKELY(string_type and not it->second.is_string()))
+ if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
{
JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
}
@@ -8265,14 +8335,14 @@ class basic_json
};
// type check: every element of the array must be an object
- if (JSON_HEDLEY_UNLIKELY(not val.is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
{
JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
}
// collect mandatory members
- const std::string op = get_value("op", "op", true);
- const std::string path = get_value(op, "path", true);
+ const auto op = get_value("op", "op", true).template get<std::string>();
+ const auto path = get_value(op, "path", true).template get<std::string>();
json_pointer ptr(path);
switch (get_op(op))
@@ -8298,7 +8368,7 @@ class basic_json
case patch_operations::move:
{
- const std::string from_path = get_value("move", "from", true);
+ const auto from_path = get_value("move", "from", true).template get<std::string>();
json_pointer from_ptr(from_path);
// the "from" location must exist - use at()
@@ -8315,7 +8385,7 @@ class basic_json
case patch_operations::copy:
{
- const std::string from_path = get_value("copy", "from", true);
+ const auto from_path = get_value("copy", "from", true).template get<std::string>();
const json_pointer from_ptr(from_path);
// the "from" location must exist - use at()
@@ -8343,7 +8413,7 @@ class basic_json
}
// throw an exception if test fails
- if (JSON_HEDLEY_UNLIKELY(not success))
+ if (JSON_HEDLEY_UNLIKELY(!success))
{
JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
}
@@ -8425,7 +8495,7 @@ class basic_json
{
// first pass: traverse common elements
std::size_t i = 0;
- while (i < source.size() and i < target.size())
+ while (i < source.size() && i < target.size())
{
// recursive call to compare array values at index i
auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
@@ -8576,7 +8646,7 @@ class basic_json
{
if (apply_patch.is_object())
{
- if (not is_object())
+ if (!is_object())
{
*this = object();
}
@@ -8636,9 +8706,7 @@ struct hash<nlohmann::json>
*/
std::size_t operator()(const nlohmann::json& j) const
{
- // a naive hashing via the string representation
- const auto& h = hash<nlohmann::json::string_t>();
- return h(j.dump());
+ return nlohmann::detail::hash(j);
}
};
@@ -8659,6 +8727,9 @@ struct less<::nlohmann::detail::value_t>
}
};
+// C++20 prohibit function specialization in the std namespace.
+#ifndef JSON_HAS_CPP_20
+
/*!
@brief exchanges the values of two JSON objects
@@ -8666,13 +8737,15 @@ struct less<::nlohmann::detail::value_t>
*/
template<>
inline void swap<nlohmann::json>(nlohmann::json& j1, nlohmann::json& j2) noexcept(
- is_nothrow_move_constructible<nlohmann::json>::value and
+ is_nothrow_move_constructible<nlohmann::json>::value&&
is_nothrow_move_assignable<nlohmann::json>::value
)
{
j1.swap(j2);
}
+#endif
+
} // namespace std
/*!
diff --git a/include/nlohmann/json_fwd.hpp b/include/nlohmann/json_fwd.hpp
index 824e86a1..332227c1 100644
--- a/include/nlohmann/json_fwd.hpp
+++ b/include/nlohmann/json_fwd.hpp
@@ -60,6 +60,19 @@ uses the standard template types.
@since version 1.0.0
*/
using json = basic_json<>;
+
+template<class Key, class T, class IgnoredLess, class Allocator>
+struct ordered_map;
+
+/*!
+@brief ordered JSON class
+
+This type preserves the insertion order of object keys.
+
+@since version 3.9.0
+*/
+using ordered_json = basic_json<nlohmann::ordered_map>;
+
} // namespace nlohmann
#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_
diff --git a/include/nlohmann/ordered_map.hpp b/include/nlohmann/ordered_map.hpp
new file mode 100644
index 00000000..2a72fefd
--- /dev/null
+++ b/include/nlohmann/ordered_map.hpp
@@ -0,0 +1,71 @@
+#pragma once
+
+#include <functional> // less
+#include <memory> // allocator
+#include <utility> // pair
+#include <vector> // vector
+
+namespace nlohmann
+{
+
+/// ordered_map: a minimal map-like container that preserves insertion order
+/// for use within nlohmann::basic_json<ordered_map>
+template <class Key, class T, class IgnoredLess = std::less<Key>,
+ class Allocator = std::allocator<std::pair<const Key, T>>>
+ struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
+{
+ using key_type = Key;
+ using mapped_type = T;
+ using Container = std::vector<std::pair<const Key, T>, Allocator>;
+ using typename Container::iterator;
+ using typename Container::size_type;
+ using typename Container::value_type;
+
+ // Explicit constructors instead of `using Container::Container`
+ // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
+ ordered_map(const Allocator& alloc = Allocator()) : Container{alloc} {}
+ template <class It>
+ ordered_map(It first, It last, const Allocator& alloc = Allocator())
+ : Container{first, last, alloc} {}
+ ordered_map(std::initializer_list<T> init, const Allocator& alloc = Allocator() )
+ : Container{init, alloc} {}
+
+ std::pair<iterator, bool> emplace(key_type&& key, T&& t)
+ {
+ for (auto it = this->begin(); it != this->end(); ++it)
+ {
+ if (it->first == key)
+ {
+ return {it, false};
+ }
+ }
+ Container::emplace_back(key, t);
+ return {--this->end(), true};
+ }
+
+ T& operator[](Key&& key)
+ {
+ return emplace(std::move(key), T{}).first->second;
+ }
+
+ size_type erase(const Key& key)
+ {
+ for (auto it = this->begin(); it != this->end(); ++it)
+ {
+ if (it->first == key)
+ {
+ // Since we cannot move const Keys, re-construct them in place
+ for (auto next = it; ++next != this->end(); ++it)
+ {
+ it->~value_type(); // Destroy but keep allocation
+ new (&*it) value_type{std::move(*next)};
+ }
+ Container::pop_back();
+ return 1;
+ }
+ }
+ return 0;
+ }
+};
+
+} // namespace nlohmann
diff --git a/meson.build b/meson.build
index ffc7b09f..6f95c9b6 100644
--- a/meson.build
+++ b/meson.build
@@ -1,6 +1,6 @@
project('nlohmann_json',
'cpp',
- version : '3.8.0',
+ version : '3.9.0',
license : 'MIT',
)
diff --git a/single_include/nlohmann/json.hpp b/single_include/nlohmann/json.hpp
index cc822a54..6a0f47ab 100644
--- a/single_include/nlohmann/json.hpp
+++ b/single_include/nlohmann/json.hpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -31,11 +31,10 @@ SOFTWARE.
#define INCLUDE_NLOHMANN_JSON_HPP_
#define NLOHMANN_JSON_VERSION_MAJOR 3
-#define NLOHMANN_JSON_VERSION_MINOR 8
+#define NLOHMANN_JSON_VERSION_MINOR 9
#define NLOHMANN_JSON_VERSION_PATCH 0
#include <algorithm> // all_of, find, for_each
-#include <cassert> // assert
#include <cstddef> // nullptr_t, ptrdiff_t, size_t
#include <functional> // hash, less
#include <initializer_list> // initializer_list
@@ -67,16 +66,6 @@ SOFTWARE.
#include <utility> // pair, declval
#include <valarray> // valarray
-// #include <nlohmann/detail/boolean_operators.hpp>
-
-
-// Header <ciso646> is removed in C++20.
-// See <https://github.com/nlohmann/json/issues/2089> for more information.
-
-#if __cplusplus <= 201703L
- #include <ciso646> // and, not, or
-#endif
-
// #include <nlohmann/detail/exceptions.hpp>
@@ -2048,7 +2037,11 @@ JSON_HEDLEY_DIAGNOSTIC_POP
#endif
// C++ language standard detection
-#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+#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)
@@ -2101,6 +2094,12 @@ JSON_HEDLEY_DIAGNOSTIC_POP
#define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
#endif
+// allow to override assert
+#if !defined(JSON_ASSERT)
+ #include <cassert> // assert
+ #define JSON_ASSERT(x) assert(x)
+#endif
+
/*!
@brief macro to briefly define a mapping between an enum and JSON
@def NLOHMANN_JSON_SERIALIZE_ENUM
@@ -2149,6 +2148,170 @@ JSON_HEDLEY_DIAGNOSTIC_POP
NumberIntegerType, NumberUnsignedType, NumberFloatType, \
AllocatorType, JSONSerializer, BinaryType>
+// 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);
+
+/*!
+@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__)) }
+
+/*!
+@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__)) }
+
+#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
+
namespace nlohmann
{
@@ -2240,6 +2403,7 @@ json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vect
json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xF8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read.
json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read.
json.exception.parse_error.114 | parse error: Unsupported BSON record type 0x0F | The parsing of the corresponding BSON record type is not implemented (yet).
+json.exception.parse_error.115 | parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1A | A UBJSON high-precision number could not be parsed.
@note For an input with n bytes, 1 is the index of the first character and n+1
is the index of the terminating null byte or the end of file. This also
@@ -2428,7 +2592,7 @@ json.exception.out_of_range.403 | key 'foo' not found | The provided key was not
json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved.
json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value.
json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF.
-json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON and BSON only support integer numbers up to 9223372036854775807. |
+json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON and BSON only support integer numbers up to 9223372036854775807. (until version 3.8.0) |
json.exception.out_of_range.408 | excessive array size: 8658170730974374167 | The size (following `#`) of an UBJSON array or object exceeds the maximal capacity. |
json.exception.out_of_range.409 | BSON key cannot contain code point U+0000 (at byte 2) | Key identifiers to be serialized to BSON cannot contain code point U+0000, since the key is stored as zero-terminated c-string |
@@ -2506,9 +2670,6 @@ class other_error : public exception
#include <cstddef> // size_t
#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
-// #include <nlohmann/detail/boolean_operators.hpp>
-
-
namespace nlohmann
{
namespace detail
@@ -2574,8 +2735,6 @@ constexpr T static_const<T>::value;
#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
#include <utility> // declval
-// #include <nlohmann/detail/boolean_operators.hpp>
-
// #include <nlohmann/detail/iterators/iterator_traits.hpp>
@@ -2588,11 +2747,11 @@ namespace nlohmann
{
namespace detail
{
-template <typename ...Ts> struct make_void
+template<typename ...Ts> struct make_void
{
using type = void;
};
-template <typename ...Ts> using void_t = typename make_void<Ts...>::type;
+template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
} // namespace detail
} // namespace nlohmann
@@ -2603,10 +2762,10 @@ namespace nlohmann
{
namespace detail
{
-template <typename It, typename = void>
+template<typename It, typename = void>
struct iterator_types {};
-template <typename It>
+template<typename It>
struct iterator_types <
It,
void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
@@ -2621,18 +2780,18 @@ struct iterator_types <
// 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 <typename T, typename = void>
+template<typename T, typename = void>
struct iterator_traits
{
};
-template <typename T>
+template<typename T>
struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
: iterator_types<T>
{
};
-template <typename T>
+template<typename T>
struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
{
using iterator_category = std::random_access_iterator_tag;
@@ -2671,39 +2830,39 @@ struct nonesuch
void operator=(nonesuch&&) = delete;
};
-template <class Default,
- class AlwaysVoid,
- template <class...> class Op,
- class... Args>
+template<class Default,
+ class AlwaysVoid,
+ template<class...> class Op,
+ class... Args>
struct detector
{
using value_t = std::false_type;
using type = Default;
};
-template <class Default, template <class...> class Op, class... Args>
+template<class Default, template<class...> class Op, class... Args>
struct detector<Default, void_t<Op<Args...>>, Op, Args...>
{
using value_t = std::true_type;
using type = Op<Args...>;
};
-template <template <class...> class Op, class... Args>
+template<template<class...> class Op, class... Args>
using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
-template <template <class...> class Op, class... Args>
+template<template<class...> class Op, class... Args>
using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
-template <class Default, template <class...> class Op, class... Args>
+template<class Default, template<class...> class Op, class... Args>
using detected_or = detector<Default, void, Op, Args...>;
-template <class Default, template <class...> class Op, class... Args>
+template<class Default, template<class...> class Op, class... Args>
using detected_or_t = typename detected_or<Default, Op, Args...>::type;
-template <class Expected, template <class...> class Op, class... Args>
+template<class Expected, template<class...> class Op, class... Args>
using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
-template <class To, template <class...> class Op, class... Args>
+template<class To, template<class...> class Op, class... Args>
using is_detected_convertible =
std::is_convertible<detected_t<Op, Args...>, To>;
} // namespace detail
@@ -2772,6 +2931,19 @@ uses the standard template types.
@since version 1.0.0
*/
using json = basic_json<>;
+
+template<class Key, class T, class IgnoredLess, class Allocator>
+struct ordered_map;
+
+/*!
+@brief ordered JSON class
+
+This type preserves the insertion order of object keys.
+
+@since version 3.9.0
+*/
+using ordered_json = basic_json<nlohmann::ordered_map>;
+
} // namespace nlohmann
#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_
@@ -2811,59 +2983,69 @@ struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
// json_ref helpers //
//////////////////////
-template <typename>
+template<typename>
class json_ref;
template<typename>
struct is_json_ref : std::false_type {};
-template <typename T>
+template<typename T>
struct is_json_ref<json_ref<T>> : std::true_type {};
//////////////////////////
// aliases for detected //
//////////////////////////
-template <typename T>
+template<typename T>
using mapped_type_t = typename T::mapped_type;
-template <typename T>
+template<typename T>
using key_type_t = typename T::key_type;
-template <typename T>
+template<typename T>
using value_type_t = typename T::value_type;
-template <typename T>
+template<typename T>
using difference_type_t = typename T::difference_type;
-template <typename T>
+template<typename T>
using pointer_t = typename T::pointer;
-template <typename T>
+template<typename T>
using reference_t = typename T::reference;
-template <typename T>
+template<typename T>
using iterator_category_t = typename T::iterator_category;
-template <typename T>
+template<typename T>
using iterator_t = typename T::iterator;
-template <typename T, typename... Args>
+template<typename T, typename... Args>
using to_json_function = decltype(T::to_json(std::declval<Args>()...));
-template <typename T, typename... Args>
+template<typename T, typename... Args>
using from_json_function = decltype(T::from_json(std::declval<Args>()...));
-template <typename T, typename U>
+template<typename T, typename U>
using get_template_function = decltype(std::declval<T>().template get<U>());
// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
-template <typename BasicJsonType, typename T, typename = void>
+template<typename BasicJsonType, typename T, typename = void>
struct has_from_json : std::false_type {};
+// trait checking if j.get<T> 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 <typename BasicJsonType, typename T>
-struct has_from_json<BasicJsonType, T,
- enable_if_t<not is_basic_json<T>::value>>
+struct is_getable
+{
+ static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
+};
+
+template<typename BasicJsonType, typename T>
+struct has_from_json < BasicJsonType, T,
+ enable_if_t < !is_basic_json<T>::value >>
{
using serializer = typename BasicJsonType::template json_serializer<T, void>;
@@ -2874,11 +3056,11 @@ struct has_from_json<BasicJsonType, T,
// This trait checks if JSONSerializer<T>::from_json(json const&) exists
// this overload is used for non-default-constructible user-defined-types
-template <typename BasicJsonType, typename T, typename = void>
+template<typename BasicJsonType, typename T, typename = void>
struct has_non_default_from_json : std::false_type {};
template<typename BasicJsonType, typename T>
-struct has_non_default_from_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>>
+struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
{
using serializer = typename BasicJsonType::template json_serializer<T, void>;
@@ -2889,11 +3071,11 @@ struct has_non_default_from_json<BasicJsonType, T, enable_if_t<not is_basic_json
// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
-template <typename BasicJsonType, typename T, typename = void>
+template<typename BasicJsonType, typename T, typename = void>
struct has_to_json : std::false_type {};
-template <typename BasicJsonType, typename T>
-struct has_to_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>>
+template<typename BasicJsonType, typename T>
+struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
{
using serializer = typename BasicJsonType::template json_serializer<T, void>;
@@ -2907,10 +3089,10 @@ struct has_to_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>>
// is_ functions //
///////////////////
-template <typename T, typename = void>
+template<typename T, typename = void>
struct is_iterator_traits : std::false_type {};
-template <typename T>
+template<typename T>
struct is_iterator_traits<iterator_traits<T>>
{
private:
@@ -2927,20 +3109,20 @@ struct is_iterator_traits<iterator_traits<T>>
// source: https://stackoverflow.com/a/37193089/4116453
-template <typename T, typename = void>
+template<typename T, typename = void>
struct is_complete_type : std::false_type {};
-template <typename T>
+template<typename T>
struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
-template <typename BasicJsonType, typename CompatibleObjectType,
- typename = void>
+template<typename BasicJsonType, typename CompatibleObjectType,
+ typename = void>
struct is_compatible_object_type_impl : std::false_type {};
-template <typename BasicJsonType, typename CompatibleObjectType>
+template<typename BasicJsonType, typename CompatibleObjectType>
struct is_compatible_object_type_impl <
BasicJsonType, CompatibleObjectType,
- enable_if_t<is_detected<mapped_type_t, CompatibleObjectType>::value and
+ enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
is_detected<key_type_t, CompatibleObjectType>::value >>
{
@@ -2949,53 +3131,53 @@ struct is_compatible_object_type_impl <
// macOS's is_constructible does not play well with nonesuch...
static constexpr bool value =
std::is_constructible<typename object_t::key_type,
- typename CompatibleObjectType::key_type>::value and
+ typename CompatibleObjectType::key_type>::value &&
std::is_constructible<typename object_t::mapped_type,
typename CompatibleObjectType::mapped_type>::value;
};
-template <typename BasicJsonType, typename CompatibleObjectType>
+template<typename BasicJsonType, typename CompatibleObjectType>
struct is_compatible_object_type
: is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
-template <typename BasicJsonType, typename ConstructibleObjectType,
- typename = void>
+template<typename BasicJsonType, typename ConstructibleObjectType,
+ typename = void>
struct is_constructible_object_type_impl : std::false_type {};
-template <typename BasicJsonType, typename ConstructibleObjectType>
+template<typename BasicJsonType, typename ConstructibleObjectType>
struct is_constructible_object_type_impl <
BasicJsonType, ConstructibleObjectType,
- enable_if_t<is_detected<mapped_type_t, ConstructibleObjectType>::value and
+ enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
is_detected<key_type_t, ConstructibleObjectType>::value >>
{
using object_t = typename BasicJsonType::object_t;
static constexpr bool value =
- (std::is_default_constructible<ConstructibleObjectType>::value and
- (std::is_move_assignable<ConstructibleObjectType>::value or
- std::is_copy_assignable<ConstructibleObjectType>::value) and
+ (std::is_default_constructible<ConstructibleObjectType>::value &&
+ (std::is_move_assignable<ConstructibleObjectType>::value ||
+ std::is_copy_assignable<ConstructibleObjectType>::value) &&
(std::is_constructible<typename ConstructibleObjectType::key_type,
- typename object_t::key_type>::value and
+ typename object_t::key_type>::value &&
std::is_same <
typename object_t::mapped_type,
- typename ConstructibleObjectType::mapped_type >::value)) or
+ typename ConstructibleObjectType::mapped_type >::value)) ||
(has_from_json<BasicJsonType,
- typename ConstructibleObjectType::mapped_type>::value or
+ typename ConstructibleObjectType::mapped_type>::value ||
has_non_default_from_json <
BasicJsonType,
typename ConstructibleObjectType::mapped_type >::value);
};
-template <typename BasicJsonType, typename ConstructibleObjectType>
+template<typename BasicJsonType, typename ConstructibleObjectType>
struct is_constructible_object_type
: is_constructible_object_type_impl<BasicJsonType,
ConstructibleObjectType> {};
-template <typename BasicJsonType, typename CompatibleStringType,
- typename = void>
+template<typename BasicJsonType, typename CompatibleStringType,
+ typename = void>
struct is_compatible_string_type_impl : std::false_type {};
-template <typename BasicJsonType, typename CompatibleStringType>
+template<typename BasicJsonType, typename CompatibleStringType>
struct is_compatible_string_type_impl <
BasicJsonType, CompatibleStringType,
enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
@@ -3005,15 +3187,15 @@ struct is_compatible_string_type_impl <
std::is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
};
-template <typename BasicJsonType, typename ConstructibleStringType>
+template<typename BasicJsonType, typename ConstructibleStringType>
struct is_compatible_string_type
: is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
-template <typename BasicJsonType, typename ConstructibleStringType,
- typename = void>
+template<typename BasicJsonType, typename ConstructibleStringType,
+ typename = void>
struct is_constructible_string_type_impl : std::false_type {};
-template <typename BasicJsonType, typename ConstructibleStringType>
+template<typename BasicJsonType, typename ConstructibleStringType>
struct is_constructible_string_type_impl <
BasicJsonType, ConstructibleStringType,
enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
@@ -3024,55 +3206,55 @@ struct is_constructible_string_type_impl <
typename BasicJsonType::string_t>::value;
};
-template <typename BasicJsonType, typename ConstructibleStringType>
+template<typename BasicJsonType, typename ConstructibleStringType>
struct is_constructible_string_type
: is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
-template <typename BasicJsonType, typename CompatibleArrayType, typename = void>
+template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
struct is_compatible_array_type_impl : std::false_type {};
-template <typename BasicJsonType, typename CompatibleArrayType>
+template<typename BasicJsonType, typename CompatibleArrayType>
struct is_compatible_array_type_impl <
BasicJsonType, CompatibleArrayType,
- enable_if_t<is_detected<value_type_t, CompatibleArrayType>::value and
- is_detected<iterator_t, CompatibleArrayType>::value and
+ enable_if_t < is_detected<value_type_t, CompatibleArrayType>::value&&
+ is_detected<iterator_t, CompatibleArrayType>::value&&
// This is needed because json_reverse_iterator has a ::iterator type...
// Therefore it is detected as a CompatibleArrayType.
// The real fix would be to have an Iterable concept.
- not is_iterator_traits<
- iterator_traits<CompatibleArrayType>>::value >>
+ !is_iterator_traits <
+ iterator_traits<CompatibleArrayType >>::value >>
{
static constexpr bool value =
std::is_constructible<BasicJsonType,
typename CompatibleArrayType::value_type>::value;
};
-template <typename BasicJsonType, typename CompatibleArrayType>
+template<typename BasicJsonType, typename CompatibleArrayType>
struct is_compatible_array_type
: is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
-template <typename BasicJsonType, typename ConstructibleArrayType, typename = void>
+template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
struct is_constructible_array_type_impl : std::false_type {};
-template <typename BasicJsonType, typename ConstructibleArrayType>
+template<typename BasicJsonType, typename ConstructibleArrayType>
struct is_constructible_array_type_impl <
BasicJsonType, ConstructibleArrayType,
enable_if_t<std::is_same<ConstructibleArrayType,
typename BasicJsonType::value_type>::value >>
: std::true_type {};
-template <typename BasicJsonType, typename ConstructibleArrayType>
+template<typename BasicJsonType, typename ConstructibleArrayType>
struct is_constructible_array_type_impl <
BasicJsonType, ConstructibleArrayType,
- enable_if_t<not std::is_same<ConstructibleArrayType,
- typename BasicJsonType::value_type>::value and
- std::is_default_constructible<ConstructibleArrayType>::value and
-(std::is_move_assignable<ConstructibleArrayType>::value or
- std::is_copy_assignable<ConstructibleArrayType>::value) and
-is_detected<value_type_t, ConstructibleArrayType>::value and
-is_detected<iterator_t, ConstructibleArrayType>::value and
-is_complete_type<
-detected_t<value_type_t, ConstructibleArrayType>>::value >>
+ enable_if_t < !std::is_same<ConstructibleArrayType,
+ typename BasicJsonType::value_type>::value&&
+ std::is_default_constructible<ConstructibleArrayType>::value&&
+(std::is_move_assignable<ConstructibleArrayType>::value ||
+ std::is_copy_assignable<ConstructibleArrayType>::value)&&
+is_detected<value_type_t, ConstructibleArrayType>::value&&
+is_detected<iterator_t, ConstructibleArrayType>::value&&
+is_complete_type <
+detected_t<value_type_t, ConstructibleArrayType >>::value >>
{
static constexpr bool value =
// This is needed because json_reverse_iterator has a ::iterator type,
@@ -3080,30 +3262,30 @@ detected_t<value_type_t, ConstructibleArrayType>>::value >>
// base class `iterator`... Therefore it is detected as a
// ConstructibleArrayType. The real fix would be to have an Iterable
// concept.
- not is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value and
+ !is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value &&
(std::is_same<typename ConstructibleArrayType::value_type,
- typename BasicJsonType::array_t::value_type>::value or
+ typename BasicJsonType::array_t::value_type>::value ||
has_from_json<BasicJsonType,
- typename ConstructibleArrayType::value_type>::value or
+ typename ConstructibleArrayType::value_type>::value ||
has_non_default_from_json <
BasicJsonType, typename ConstructibleArrayType::value_type >::value);
};
-template <typename BasicJsonType, typename ConstructibleArrayType>
+template<typename BasicJsonType, typename ConstructibleArrayType>
struct is_constructible_array_type
: is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
-template <typename RealIntegerType, typename CompatibleNumberIntegerType,
- typename = void>
+template<typename RealIntegerType, typename CompatibleNumberIntegerType,
+ typename = void>
struct is_compatible_integer_type_impl : std::false_type {};
-template <typename RealIntegerType, typename CompatibleNumberIntegerType>
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
struct is_compatible_integer_type_impl <
RealIntegerType, CompatibleNumberIntegerType,
- enable_if_t<std::is_integral<RealIntegerType>::value and
- std::is_integral<CompatibleNumberIntegerType>::value and
- not std::is_same<bool, CompatibleNumberIntegerType>::value >>
+ enable_if_t < std::is_integral<RealIntegerType>::value&&
+ std::is_integral<CompatibleNumberIntegerType>::value&&
+ !std::is_same<bool, CompatibleNumberIntegerType>::value >>
{
// is there an assert somewhere on overflows?
using RealLimits = std::numeric_limits<RealIntegerType>;
@@ -3111,20 +3293,20 @@ struct is_compatible_integer_type_impl <
static constexpr auto value =
std::is_constructible<RealIntegerType,
- CompatibleNumberIntegerType>::value and
- CompatibleLimits::is_integer and
+ CompatibleNumberIntegerType>::value &&
+ CompatibleLimits::is_integer &&
RealLimits::is_signed == CompatibleLimits::is_signed;
};
-template <typename RealIntegerType, typename CompatibleNumberIntegerType>
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
struct is_compatible_integer_type
: is_compatible_integer_type_impl<RealIntegerType,
CompatibleNumberIntegerType> {};
-template <typename BasicJsonType, typename CompatibleType, typename = void>
+template<typename BasicJsonType, typename CompatibleType, typename = void>
struct is_compatible_type_impl: std::false_type {};
-template <typename BasicJsonType, typename CompatibleType>
+template<typename BasicJsonType, typename CompatibleType>
struct is_compatible_type_impl <
BasicJsonType, CompatibleType,
enable_if_t<is_complete_type<CompatibleType>::value >>
@@ -3133,7 +3315,7 @@ struct is_compatible_type_impl <
has_to_json<BasicJsonType, CompatibleType>::value;
};
-template <typename BasicJsonType, typename CompatibleType>
+template<typename BasicJsonType, typename CompatibleType>
struct is_compatible_type
: is_compatible_type_impl<BasicJsonType, CompatibleType> {};
@@ -3144,10 +3326,10 @@ template<class B1, class... Bn>
struct conjunction<B1, Bn...>
: std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
-template <typename T1, typename T2>
+template<typename T1, typename T2>
struct is_constructible_tuple : std::false_type {};
-template <typename T1, typename... Args>
+template<typename T1, typename... Args>
struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<std::is_constructible<T1, Args>...> {};
} // namespace detail
} // namespace nlohmann
@@ -3160,9 +3342,6 @@ struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<std::is_con
#include <cstdint> // uint8_t
#include <string> // string
-// #include <nlohmann/detail/boolean_operators.hpp>
-
-
namespace nlohmann
{
namespace detail
@@ -3233,7 +3412,7 @@ inline bool operator<(const value_t lhs, const value_t rhs) noexcept
const auto l_index = static_cast<std::size_t>(lhs);
const auto r_index = static_cast<std::size_t>(rhs);
- return l_index < order.size() and r_index < order.size() and order[l_index] < order[r_index];
+ return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
}
} // namespace detail
} // namespace nlohmann
@@ -3246,7 +3425,7 @@ namespace detail
template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_null()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
{
JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
}
@@ -3254,10 +3433,10 @@ void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
}
// overloads for basic_json template parameters
-template<typename BasicJsonType, typename ArithmeticType,
- enable_if_t<std::is_arithmetic<ArithmeticType>::value and
- not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
- int> = 0>
+template < typename BasicJsonType, typename ArithmeticType,
+ enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
+ !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+ int > = 0 >
void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
{
switch (static_cast<value_t>(j))
@@ -3286,7 +3465,7 @@ void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_boolean()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
{
JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
}
@@ -3296,7 +3475,7 @@ void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
{
JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
}
@@ -3306,13 +3485,13 @@ void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
template <
typename BasicJsonType, typename ConstructibleStringType,
enable_if_t <
- is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value and
- not std::is_same<typename BasicJsonType::string_t,
- ConstructibleStringType>::value,
+ is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
+ !std::is_same<typename BasicJsonType::string_t,
+ ConstructibleStringType>::value,
int > = 0 >
void from_json(const BasicJsonType& j, ConstructibleStringType& s)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
{
JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
}
@@ -3349,10 +3528,10 @@ void from_json(const BasicJsonType& j, EnumType& e)
// forward_list doesn't have an insert method
template<typename BasicJsonType, typename T, typename Allocator,
- enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
+ enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
@@ -3366,18 +3545,22 @@ void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
// valarray doesn't have an insert method
template<typename BasicJsonType, typename T,
- enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
+ enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
void from_json(const BasicJsonType& j, std::valarray<T>& l)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
l.resize(j.size());
- std::copy(j.begin(), j.end(), std::begin(l));
+ std::transform(j.begin(), j.end(), std::begin(l),
+ [](const BasicJsonType & elem)
+ {
+ return elem.template get<T>();
+ });
}
-template <typename BasicJsonType, typename T, std::size_t N>
+template<typename BasicJsonType, typename T, std::size_t N>
auto from_json(const BasicJsonType& j, T (&arr)[N])
-> decltype(j.template get<T>(), void())
{
@@ -3393,7 +3576,7 @@ void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_
arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
}
-template <typename BasicJsonType, typename T, std::size_t N>
+template<typename BasicJsonType, typename T, std::size_t N>
auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
priority_tag<2> /*unused*/)
-> decltype(j.template get<T>(), void())
@@ -3425,7 +3608,7 @@ auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, p
arr = std::move(ret);
}
-template <typename BasicJsonType, typename ConstructibleArrayType>
+template<typename BasicJsonType, typename ConstructibleArrayType>
void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
priority_tag<0> /*unused*/)
{
@@ -3443,20 +3626,20 @@ void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
arr = std::move(ret);
}
-template <typename BasicJsonType, typename ConstructibleArrayType,
- enable_if_t <
- is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value and
- not is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value and
- not is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value and
- not std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value and
- not is_basic_json<ConstructibleArrayType>::value,
- int > = 0 >
+template < typename BasicJsonType, typename ConstructibleArrayType,
+ enable_if_t <
+ is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
+ !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
+ !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+ !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
+ !is_basic_json<ConstructibleArrayType>::value,
+ int > = 0 >
auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
j.template get<typename ConstructibleArrayType::value_type>(),
void())
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " +
std::string(j.type_name())));
@@ -3465,10 +3648,10 @@ void())
from_json_array_impl(j, arr, priority_tag<3> {});
}
-template <typename BasicJsonType>
+template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_binary()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
{
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name())));
}
@@ -3480,7 +3663,7 @@ template<typename BasicJsonType, typename ConstructibleObjectType,
enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
{
JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
}
@@ -3502,14 +3685,14 @@ void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
// (BooleanType, etc..); note: Is it really necessary to provide explicit
// overloads for boolean_t etc. in case of a custom BooleanType which is not
// an arithmetic type?
-template<typename BasicJsonType, typename ArithmeticType,
- enable_if_t <
- std::is_arithmetic<ArithmeticType>::value and
- not std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value and
- not std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value and
- not std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value and
- not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
- int> = 0>
+template < typename BasicJsonType, typename ArithmeticType,
+ enable_if_t <
+ std::is_arithmetic<ArithmeticType>::value&&
+ !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
+ !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
+ !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
+ !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+ int > = 0 >
void from_json(const BasicJsonType& j, ArithmeticType& val)
{
switch (static_cast<value_t>(j))
@@ -3558,19 +3741,19 @@ void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
}
-template <typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
- typename = enable_if_t<not std::is_constructible<
- typename BasicJsonType::string_t, Key>::value>>
+template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
+ typename = enable_if_t < !std::is_constructible <
+ typename BasicJsonType::string_t, Key >::value >>
void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
m.clear();
for (const auto& p : j)
{
- if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
}
@@ -3578,19 +3761,19 @@ void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>&
}
}
-template <typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
- typename = enable_if_t<not std::is_constructible<
- typename BasicJsonType::string_t, Key>::value>>
+template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+ typename = enable_if_t < !std::is_constructible <
+ typename BasicJsonType::string_t, Key >::value >>
void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
m.clear();
for (const auto& p : j)
{
- if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
}
@@ -3631,8 +3814,6 @@ constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::va
#include <valarray> // valarray
#include <vector> // vector
-// #include <nlohmann/detail/boolean_operators.hpp>
-
// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
@@ -3653,9 +3834,11 @@ namespace detail
template<typename string_type>
void int_to_string( string_type& target, std::size_t value )
{
- target = std::to_string(value);
+ // For ADL
+ using std::to_string;
+ target = to_string(value);
}
-template <typename IteratorType> class iteration_proxy_value
+template<typename IteratorType> class iteration_proxy_value
{
public:
using difference_type = std::ptrdiff_t;
@@ -3710,7 +3893,7 @@ template <typename IteratorType> class iteration_proxy_value
/// return key of the iterator
const string_type& key() const
{
- assert(anchor.m_object != nullptr);
+ JSON_ASSERT(anchor.m_object != nullptr);
switch (anchor.m_object->type())
{
@@ -3769,7 +3952,7 @@ template<typename IteratorType> class iteration_proxy
// Structured Bindings Support
// For further reference see https://blog.tartanllama.xyz/structured-bindings/
// And see https://github.com/nlohmann/json/pull/1391
-template <std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
+template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
{
return i.key();
@@ -3777,7 +3960,7 @@ auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decl
// Structured Bindings Support
// For further reference see https://blog.tartanllama.xyz/structured-bindings/
// And see https://github.com/nlohmann/json/pull/1391
-template <std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
+template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
{
return i.value();
@@ -3796,11 +3979,11 @@ namespace std
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmismatched-tags"
#endif
-template <typename IteratorType>
+template<typename IteratorType>
class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
: public std::integral_constant<std::size_t, 2> {};
-template <std::size_t N, typename IteratorType>
+template<std::size_t N, typename IteratorType>
class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
{
public:
@@ -3861,9 +4044,9 @@ struct external_constructor<value_t::string>
j.assert_invariant();
}
- template<typename BasicJsonType, typename CompatibleStringType,
- enable_if_t<not std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
- int> = 0>
+ template < typename BasicJsonType, typename CompatibleStringType,
+ enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
+ int > = 0 >
static void construct(BasicJsonType& j, const CompatibleStringType& str)
{
j.m_type = value_t::string;
@@ -3949,9 +4132,9 @@ struct external_constructor<value_t::array>
j.assert_invariant();
}
- template<typename BasicJsonType, typename CompatibleArrayType,
- enable_if_t<not std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
- int> = 0>
+ template < typename BasicJsonType, typename CompatibleArrayType,
+ enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
+ int > = 0 >
static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
{
using std::begin;
@@ -4008,8 +4191,8 @@ struct external_constructor<value_t::object>
j.assert_invariant();
}
- template<typename BasicJsonType, typename CompatibleObjectType,
- enable_if_t<not std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int> = 0>
+ template < typename BasicJsonType, typename CompatibleObjectType,
+ enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
{
using std::begin;
@@ -4080,20 +4263,20 @@ void to_json(BasicJsonType& j, const std::vector<bool>& e)
external_constructor<value_t::array>::construct(j, e);
}
-template <typename BasicJsonType, typename CompatibleArrayType,
- enable_if_t<is_compatible_array_type<BasicJsonType,
- CompatibleArrayType>::value and
- not is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value and
- not is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value and
- not std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value and
- not is_basic_json<CompatibleArrayType>::value,
- int> = 0>
+template < typename BasicJsonType, typename CompatibleArrayType,
+ enable_if_t < is_compatible_array_type<BasicJsonType,
+ CompatibleArrayType>::value&&
+ !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
+ !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
+ !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
+ !is_basic_json<CompatibleArrayType>::value,
+ int > = 0 >
void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
{
external_constructor<value_t::array>::construct(j, arr);
}
-template <typename BasicJsonType>
+template<typename BasicJsonType>
void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
{
external_constructor<value_t::binary>::construct(j, bin);
@@ -4112,8 +4295,8 @@ void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
external_constructor<value_t::array>::construct(j, std::move(arr));
}
-template<typename BasicJsonType, typename CompatibleObjectType,
- enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value and not is_basic_json<CompatibleObjectType>::value, int> = 0>
+template < typename BasicJsonType, typename CompatibleObjectType,
+ enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
{
external_constructor<value_t::object>::construct(j, obj);
@@ -4127,9 +4310,9 @@ void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
template <
typename BasicJsonType, typename T, std::size_t N,
- enable_if_t<not std::is_constructible<typename BasicJsonType::string_t,
- const T(&)[N]>::value,
- int> = 0 >
+ enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
+ const T(&)[N]>::value,
+ int > = 0 >
void to_json(BasicJsonType& j, const T(&arr)[N])
{
external_constructor<value_t::array>::construct(j, arr);
@@ -4142,8 +4325,8 @@ void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
}
// for https://github.com/nlohmann/json/pull/1134
-template < typename BasicJsonType, typename T,
- enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
+template<typename BasicJsonType, typename T,
+ enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
void to_json(BasicJsonType& j, const T& b)
{
j = { {b.key(), b.value()} };
@@ -4212,7 +4395,7 @@ struct adl_serializer
@param[in,out] j JSON value to write to
@param[in] val value to read from
*/
- template <typename BasicJsonType, typename ValueType>
+ template<typename BasicJsonType, typename ValueType>
static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(
noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
-> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)), void())
@@ -4391,20 +4574,136 @@ class byte_container_with_subtype : public BinaryType
} // namespace nlohmann
-// #include <nlohmann/detail/boolean_operators.hpp>
-
// #include <nlohmann/detail/conversions/from_json.hpp>
// #include <nlohmann/detail/conversions/to_json.hpp>
// #include <nlohmann/detail/exceptions.hpp>
+// #include <nlohmann/detail/hash.hpp>
+
+
+#include <cstddef> // size_t, uint8_t
+#include <functional> // hash
+
+namespace nlohmann
+{
+namespace detail
+{
+
+// boost::hash_combine
+inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
+{
+ seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
+ return seed;
+}
+
+/*!
+@brief hash a JSON value
+
+The hash function tries to rely on std::hash where possible. Furthermore, the
+type of the JSON value is taken into account to have different hash values for
+null, 0, 0U, and false, etc.
+
+@tparam BasicJsonType basic_json specialization
+@param j JSON value to hash
+@return hash value of j
+*/
+template<typename BasicJsonType>
+std::size_t hash(const BasicJsonType& j)
+{
+ using string_t = typename BasicJsonType::string_t;
+ using number_integer_t = typename BasicJsonType::number_integer_t;
+ using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+ using number_float_t = typename BasicJsonType::number_float_t;
+
+ const auto type = static_cast<std::size_t>(j.type());
+ switch (j.type())
+ {
+ case BasicJsonType::value_t::null:
+ case BasicJsonType::value_t::discarded:
+ {
+ return combine(type, 0);
+ }
+
+ case BasicJsonType::value_t::object:
+ {
+ auto seed = combine(type, j.size());
+ for (const auto& element : j.items())
+ {
+ const auto h = std::hash<string_t> {}(element.key());
+ seed = combine(seed, h);
+ seed = combine(seed, hash(element.value()));
+ }
+ return seed;
+ }
+
+ case BasicJsonType::value_t::array:
+ {
+ auto seed = combine(type, j.size());
+ for (const auto& element : j)
+ {
+ seed = combine(seed, hash(element));
+ }
+ return seed;
+ }
+
+ case BasicJsonType::value_t::string:
+ {
+ const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
+ return combine(type, h);
+ }
+
+ case BasicJsonType::value_t::boolean:
+ {
+ const auto h = std::hash<bool> {}(j.template get<bool>());
+ return combine(type, h);
+ }
+
+ case BasicJsonType::value_t::number_integer:
+ {
+ const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
+ return combine(type, h);
+ }
+
+ case nlohmann::detail::value_t::number_unsigned:
+ {
+ const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
+ return combine(type, h);
+ }
+
+ case nlohmann::detail::value_t::number_float:
+ {
+ const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
+ return combine(type, h);
+ }
+
+ case nlohmann::detail::value_t::binary:
+ {
+ auto seed = combine(type, j.get_binary().size());
+ const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
+ seed = combine(seed, h);
+ seed = combine(seed, j.get_binary().subtype());
+ for (const auto byte : j.get_binary())
+ {
+ seed = combine(seed, std::hash<std::uint8_t> {}(byte));
+ }
+ return seed;
+ }
+
+ default: // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
+ }
+}
+
+} // namespace detail
+} // namespace nlohmann
+
// #include <nlohmann/detail/input/binary_reader.hpp>
#include <algorithm> // generate_n
#include <array> // array
-#include <cassert> // assert
#include <cmath> // ldexp
#include <cstddef> // size_t
#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
@@ -4421,7 +4720,6 @@ class byte_container_with_subtype : public BinaryType
#include <array> // array
-#include <cassert> // assert
#include <cstddef> // size_t
#include <cstdio> //FILE *
#include <cstring> // strlen
@@ -4459,7 +4757,7 @@ class file_input_adapter
using char_type = char;
JSON_HEDLEY_NON_NULL(2)
- explicit file_input_adapter(std::FILE* f) noexcept
+ explicit file_input_adapter(std::FILE* f) noexcept
: m_file(f)
{}
@@ -4498,7 +4796,7 @@ class input_stream_adapter
{
// clear stream flags; we use underlying streambuf I/O, do not
// maintain ifstream flags, except eof
- if (is)
+ if (is != nullptr)
{
is->clear(is->rdstate() & std::ios::eofbit);
}
@@ -4513,7 +4811,7 @@ class input_stream_adapter
input_stream_adapter& operator=(input_stream_adapter&) = delete;
input_stream_adapter& operator=(input_stream_adapter&& rhs) = delete;
- input_stream_adapter(input_stream_adapter&& rhs) : is(rhs.is), sb(rhs.sb)
+ input_stream_adapter(input_stream_adapter&& rhs) noexcept : is(rhs.is), sb(rhs.sb)
{
rhs.is = nullptr;
rhs.sb = nullptr;
@@ -4673,7 +4971,7 @@ struct wide_string_input_helper<BaseInputAdapter, 2>
utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
utf8_bytes_filled = 2;
}
- else if (0xD800 > wc or wc >= 0xE000)
+ else if (0xD800 > wc || wc >= 0xE000)
{
utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
@@ -4682,7 +4980,7 @@ struct wide_string_input_helper<BaseInputAdapter, 2>
}
else
{
- if (JSON_HEDLEY_UNLIKELY(not input.empty()))
+ if (JSON_HEDLEY_UNLIKELY(!input.empty()))
{
const auto wc2 = static_cast<unsigned int>(input.get_character());
const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
@@ -4719,13 +5017,13 @@ class wide_string_input_adapter
{
fill_buffer<sizeof(WideCharType)>();
- assert(utf8_bytes_filled > 0);
- assert(utf8_bytes_index == 0);
+ JSON_ASSERT(utf8_bytes_filled > 0);
+ JSON_ASSERT(utf8_bytes_index == 0);
}
// use buffer
- assert(utf8_bytes_filled > 0);
- assert(utf8_bytes_index < utf8_bytes_filled);
+ JSON_ASSERT(utf8_bytes_filled > 0);
+ JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
return utf8_bytes[utf8_bytes_index++];
}
@@ -4825,15 +5123,15 @@ using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const
// Null-delimited strings, and the like.
template < typename CharT,
typename std::enable_if <
- std::is_pointer<CharT>::value and
- not std::is_array<CharT>::value and
- std::is_integral<typename std::remove_pointer<CharT>::type>::value and
+ std::is_pointer<CharT>::value&&
+ !std::is_array<CharT>::value&&
+ std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
sizeof(typename std::remove_pointer<CharT>::type) == 1,
int >::type = 0 >
contiguous_bytes_input_adapter input_adapter(CharT b)
{
auto length = std::strlen(reinterpret_cast<const char*>(b));
- auto ptr = reinterpret_cast<const char*>(b);
+ const auto* ptr = reinterpret_cast<const char*>(b);
return input_adapter(ptr, ptr + length);
}
@@ -4849,12 +5147,12 @@ auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N))
class span_input_adapter
{
public:
- template<typename CharT,
- typename std::enable_if<
- std::is_pointer<CharT>::value and
- std::is_integral<typename std::remove_pointer<CharT>::type>::value and
- sizeof(typename std::remove_pointer<CharT>::type) == 1,
- int>::type = 0>
+ template < typename CharT,
+ typename std::enable_if <
+ std::is_pointer<CharT>::value&&
+ std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+ sizeof(typename std::remove_pointer<CharT>::type) == 1,
+ int >::type = 0 >
span_input_adapter(CharT b, std::size_t l)
: ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
@@ -4879,7 +5177,6 @@ class span_input_adapter
// #include <nlohmann/detail/input/json_sax.hpp>
-#include <cassert> // assert
#include <cstddef>
#include <string> // string
#include <utility> // move
@@ -5099,7 +5396,7 @@ class json_sax_dom_parser
{
ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
- if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+ if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len)));
@@ -5125,7 +5422,7 @@ class json_sax_dom_parser
{
ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
- if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+ if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len)));
@@ -5140,30 +5437,15 @@ class json_sax_dom_parser
return true;
}
+ template<class Exception>
bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
- const detail::exception& ex)
+ const Exception& ex)
{
errored = true;
+ static_cast<void>(ex);
if (allow_exceptions)
{
- // determine the proper exception type from the id
- switch ((ex.id / 100) % 100)
- {
- case 1:
- JSON_THROW(*static_cast<const detail::parse_error*>(&ex));
- case 4:
- JSON_THROW(*static_cast<const detail::out_of_range*>(&ex));
- // LCOV_EXCL_START
- case 2:
- JSON_THROW(*static_cast<const detail::invalid_iterator*>(&ex));
- case 3:
- JSON_THROW(*static_cast<const detail::type_error*>(&ex));
- case 5:
- JSON_THROW(*static_cast<const detail::other_error*>(&ex));
- default:
- assert(false);
- // LCOV_EXCL_STOP
- }
+ JSON_THROW(ex);
}
return false;
}
@@ -5190,7 +5472,7 @@ class json_sax_dom_parser
return &root;
}
- assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
+ JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
if (ref_stack.back()->is_array())
{
@@ -5198,8 +5480,8 @@ class json_sax_dom_parser
return &(ref_stack.back()->m_value.array->back());
}
- assert(ref_stack.back()->is_object());
- assert(object_element);
+ JSON_ASSERT(ref_stack.back()->is_object());
+ JSON_ASSERT(object_element);
*object_element = BasicJsonType(std::forward<Value>(v));
return object_element;
}
@@ -5295,7 +5577,7 @@ class json_sax_dom_callback_parser
ref_stack.push_back(val.second);
// check object limit
- if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+ if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len)));
}
@@ -5312,7 +5594,7 @@ class json_sax_dom_callback_parser
key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later
- if (keep and ref_stack.back())
+ if (keep && ref_stack.back())
{
object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
}
@@ -5322,18 +5604,18 @@ class json_sax_dom_callback_parser
bool end_object()
{
- if (ref_stack.back() and not callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
+ if (ref_stack.back() && !callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
{
// discard object
*ref_stack.back() = discarded;
}
- assert(not ref_stack.empty());
- assert(not keep_stack.empty());
+ JSON_ASSERT(!ref_stack.empty());
+ JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
- if (not ref_stack.empty() and ref_stack.back() and ref_stack.back()->is_structured())
+ if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
{
// remove discarded value
for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
@@ -5358,7 +5640,7 @@ class json_sax_dom_callback_parser
ref_stack.push_back(val.second);
// check array limit
- if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+ if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len)));
}
@@ -5373,20 +5655,20 @@ class json_sax_dom_callback_parser
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
- if (not keep)
+ if (!keep)
{
// discard array
*ref_stack.back() = discarded;
}
}
- assert(not ref_stack.empty());
- assert(not keep_stack.empty());
+ JSON_ASSERT(!ref_stack.empty());
+ JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
// remove discarded value
- if (not keep and not ref_stack.empty() and ref_stack.back()->is_array())
+ if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
{
ref_stack.back()->m_value.array->pop_back();
}
@@ -5394,30 +5676,15 @@ class json_sax_dom_callback_parser
return true;
}
+ template<class Exception>
bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
- const detail::exception& ex)
+ const Exception& ex)
{
errored = true;
+ static_cast<void>(ex);
if (allow_exceptions)
{
- // determine the proper exception type from the id
- switch ((ex.id / 100) % 100)
- {
- case 1:
- JSON_THROW(*static_cast<const detail::parse_error*>(&ex));
- case 4:
- JSON_THROW(*static_cast<const detail::out_of_range*>(&ex));
- // LCOV_EXCL_START
- case 2:
- JSON_THROW(*static_cast<const detail::invalid_iterator*>(&ex));
- case 3:
- JSON_THROW(*static_cast<const detail::type_error*>(&ex));
- case 5:
- JSON_THROW(*static_cast<const detail::other_error*>(&ex));
- default:
- assert(false);
- // LCOV_EXCL_STOP
- }
+ JSON_THROW(ex);
}
return false;
}
@@ -5446,11 +5713,11 @@ class json_sax_dom_callback_parser
template<typename Value>
std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
- assert(not keep_stack.empty());
+ JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
- if (not keep_stack.back())
+ if (!keep_stack.back())
{
return {false, nullptr};
}
@@ -5459,10 +5726,10 @@ class json_sax_dom_callback_parser
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
- const bool keep = skip_callback or callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
+ const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
- if (not keep)
+ if (!keep)
{
return {false, nullptr};
}
@@ -5475,13 +5742,13 @@ class json_sax_dom_callback_parser
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
- if (not ref_stack.back())
+ if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
- assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
+ JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
@@ -5491,18 +5758,18 @@ class json_sax_dom_callback_parser
}
// object
- assert(ref_stack.back()->is_object());
+ JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
- assert(not key_keep_stack.empty());
+ JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
- if (not store_element)
+ if (!store_element)
{
return {false, nullptr};
}
- assert(object_element);
+ JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
}
@@ -5606,2461 +5873,6 @@ class json_sax_acceptor
} // namespace nlohmann
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/is_sax.hpp>
-
-
-#include <cstdint> // size_t
-#include <utility> // declval
-#include <string> // string
-
-// #include <nlohmann/detail/meta/detected.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-template <typename T>
-using null_function_t = decltype(std::declval<T&>().null());
-
-template <typename T>
-using boolean_function_t =
- decltype(std::declval<T&>().boolean(std::declval<bool>()));
-
-template <typename T, typename Integer>
-using number_integer_function_t =
- decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
-
-template <typename T, typename Unsigned>
-using number_unsigned_function_t =
- decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
-
-template <typename T, typename Float, typename String>
-using number_float_function_t = decltype(std::declval<T&>().number_float(
- std::declval<Float>(), std::declval<const String&>()));
-
-template <typename T, typename String>
-using string_function_t =
- decltype(std::declval<T&>().string(std::declval<String&>()));
-
-template <typename T>
-using start_object_function_t =
- decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
-
-template <typename T, typename String>
-using key_function_t =
- decltype(std::declval<T&>().key(std::declval<String&>()));
-
-template <typename T>
-using end_object_function_t = decltype(std::declval<T&>().end_object());
-
-template <typename T>
-using start_array_function_t =
- decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
-
-template <typename T>
-using end_array_function_t = decltype(std::declval<T&>().end_array());
-
-template <typename T, typename Exception>
-using parse_error_function_t = decltype(std::declval<T&>().parse_error(
- std::declval<std::size_t>(), std::declval<const std::string&>(),
- std::declval<const Exception&>()));
-
-template <typename SAX, typename BasicJsonType>
-struct is_sax
-{
- private:
- static_assert(is_basic_json<BasicJsonType>::value,
- "BasicJsonType must be of type basic_json<...>");
-
- using number_integer_t = typename BasicJsonType::number_integer_t;
- using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
- using number_float_t = typename BasicJsonType::number_float_t;
- using string_t = typename BasicJsonType::string_t;
- using exception_t = typename BasicJsonType::exception;
-
- public:
- static constexpr bool value =
- is_detected_exact<bool, null_function_t, SAX>::value &&
- is_detected_exact<bool, boolean_function_t, SAX>::value &&
- is_detected_exact<bool, number_integer_function_t, SAX,
- number_integer_t>::value &&
- is_detected_exact<bool, number_unsigned_function_t, SAX,
- number_unsigned_t>::value &&
- is_detected_exact<bool, number_float_function_t, SAX, number_float_t,
- string_t>::value &&
- is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
- is_detected_exact<bool, start_object_function_t, SAX>::value &&
- is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
- is_detected_exact<bool, end_object_function_t, SAX>::value &&
- is_detected_exact<bool, start_array_function_t, SAX>::value &&
- is_detected_exact<bool, end_array_function_t, SAX>::value &&
- is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
-};
-
-template <typename SAX, typename BasicJsonType>
-struct is_sax_static_asserts
-{
- private:
- static_assert(is_basic_json<BasicJsonType>::value,
- "BasicJsonType must be of type basic_json<...>");
-
- using number_integer_t = typename BasicJsonType::number_integer_t;
- using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
- using number_float_t = typename BasicJsonType::number_float_t;
- using string_t = typename BasicJsonType::string_t;
- using exception_t = typename BasicJsonType::exception;
-
- public:
- static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
- "Missing/invalid function: bool null()");
- static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
- "Missing/invalid function: bool boolean(bool)");
- static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
- "Missing/invalid function: bool boolean(bool)");
- static_assert(
- is_detected_exact<bool, number_integer_function_t, SAX,
- number_integer_t>::value,
- "Missing/invalid function: bool number_integer(number_integer_t)");
- static_assert(
- is_detected_exact<bool, number_unsigned_function_t, SAX,
- number_unsigned_t>::value,
- "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
- static_assert(is_detected_exact<bool, number_float_function_t, SAX,
- number_float_t, string_t>::value,
- "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
- static_assert(
- is_detected_exact<bool, string_function_t, SAX, string_t>::value,
- "Missing/invalid function: bool string(string_t&)");
- static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
- "Missing/invalid function: bool start_object(std::size_t)");
- static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
- "Missing/invalid function: bool key(string_t&)");
- static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
- "Missing/invalid function: bool end_object()");
- static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
- "Missing/invalid function: bool start_array(std::size_t)");
- static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
- "Missing/invalid function: bool end_array()");
- static_assert(
- is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
- "Missing/invalid function: bool parse_error(std::size_t, const "
- "std::string&, const exception&)");
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/value_t.hpp>
-
-
-namespace nlohmann
-{
-namespace detail
-{
-
-/*!
-@brief determine system byte order
-
-@return true if and only if system's byte order is little endian
-
-@note from https://stackoverflow.com/a/1001328/266378
-*/
-static inline bool little_endianess(int num = 1) noexcept
-{
- return *reinterpret_cast<char*>(&num) == 1;
-}
-
-
-///////////////////
-// binary reader //
-///////////////////
-
-/*!
-@brief deserialization of CBOR, MessagePack, and UBJSON values
-*/
-template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
-class binary_reader
-{
- using number_integer_t = typename BasicJsonType::number_integer_t;
- using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
- using number_float_t = typename BasicJsonType::number_float_t;
- using string_t = typename BasicJsonType::string_t;
- using binary_t = typename BasicJsonType::binary_t;
- using json_sax_t = SAX;
- using char_type = typename InputAdapterType::char_type;
- using char_int_type = typename std::char_traits<char_type>::int_type;
-
- public:
- /*!
- @brief create a binary reader
-
- @param[in] adapter input adapter to read from
- */
- explicit binary_reader(InputAdapterType&& adapter) : ia(std::move(adapter))
- {
- (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
- }
-
- // make class move-only
- binary_reader(const binary_reader&) = delete;
- binary_reader(binary_reader&&) = default;
- binary_reader& operator=(const binary_reader&) = delete;
- binary_reader& operator=(binary_reader&&) = default;
- ~binary_reader() = default;
-
- /*!
- @param[in] format the binary format to parse
- @param[in] sax_ a SAX event processor
- @param[in] strict whether to expect the input to be consumed completed
-
- @return
- */
- JSON_HEDLEY_NON_NULL(3)
- bool sax_parse(const input_format_t format,
- json_sax_t* sax_,
- const bool strict = true)
- {
- sax = sax_;
- bool result = false;
-
- switch (format)
- {
- case input_format_t::bson:
- result = parse_bson_internal();
- break;
-
- case input_format_t::cbor:
- result = parse_cbor_internal();
- break;
-
- case input_format_t::msgpack:
- result = parse_msgpack_internal();
- break;
-
- case input_format_t::ubjson:
- result = parse_ubjson_internal();
- break;
-
- default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
- }
-
- // strict mode: next byte must be EOF
- if (result and strict)
- {
- if (format == input_format_t::ubjson)
- {
- get_ignore_noop();
- }
- else
- {
- get();
- }
-
- if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
- {
- return sax->parse_error(chars_read, get_token_string(),
- parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value")));
- }
- }
-
- return result;
- }
-
- private:
- //////////
- // BSON //
- //////////
-
- /*!
- @brief Reads in a BSON-object and passes it to the SAX-parser.
- @return whether a valid BSON-value was passed to the SAX parser
- */
- bool parse_bson_internal()
- {
- std::int32_t document_size;
- get_number<std::int32_t, true>(input_format_t::bson, document_size);
-
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
- {
- return false;
- }
-
- if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_list(/*is_array*/false)))
- {
- return false;
- }
-
- return sax->end_object();
- }
-
- /*!
- @brief Parses a C-style string from the BSON input.
- @param[in, out] result A reference to the string variable where the read
- string is to be stored.
- @return `true` if the \x00-byte indicating the end of the string was
- encountered before the EOF; false` indicates an unexpected EOF.
- */
- bool get_bson_cstr(string_t& result)
- {
- auto out = std::back_inserter(result);
- while (true)
- {
- get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::bson, "cstring")))
- {
- return false;
- }
- if (current == 0x00)
- {
- return true;
- }
- *out++ = static_cast<typename string_t::value_type>(current);
- }
-
- return true;
- }
-
- /*!
- @brief Parses a zero-terminated string of length @a len from the BSON
- input.
- @param[in] len The length (including the zero-byte at the end) of the
- string to be read.
- @param[in, out] result A reference to the string variable where the read
- string is to be stored.
- @tparam NumberType The type of the length @a len
- @pre len >= 1
- @return `true` if the string was successfully parsed
- */
- template<typename NumberType>
- bool get_bson_string(const NumberType len, string_t& result)
- {
- if (JSON_HEDLEY_UNLIKELY(len < 1))
- {
- auto last_token = get_token_string();
- return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string")));
- }
-
- return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) and get() != std::char_traits<char_type>::eof();
- }
-
- /*!
- @brief Parses a byte array input of length @a len from the BSON input.
- @param[in] len The length of the byte array to be read.
- @param[in, out] result A reference to the binary variable where the read
- array is to be stored.
- @tparam NumberType The type of the length @a len
- @pre len >= 0
- @return `true` if the byte array was successfully parsed
- */
- template<typename NumberType>
- bool get_bson_binary(const NumberType len, binary_t& result)
- {
- if (JSON_HEDLEY_UNLIKELY(len < 0))
- {
- auto last_token = get_token_string();
- return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "byte array length cannot be negative, is " + std::to_string(len), "binary")));
- }
-
- // All BSON binary values have a subtype
- std::uint8_t subtype;
- get_number<std::uint8_t>(input_format_t::bson, subtype);
- result.set_subtype(subtype);
-
- return get_binary(input_format_t::bson, len, result);
- }
-
- /*!
- @brief Read a BSON document element of the given @a element_type.
- @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
- @param[in] element_type_parse_position The position in the input stream,
- where the `element_type` was read.
- @warning Not all BSON element types are supported yet. An unsupported
- @a element_type will give rise to a parse_error.114:
- Unsupported BSON record type 0x...
- @return whether a valid BSON-object/array was passed to the SAX parser
- */
- bool parse_bson_element_internal(const char_int_type element_type,
- const std::size_t element_type_parse_position)
- {
- switch (element_type)
- {
- case 0x01: // double
- {
- double number;
- return get_number<double, true>(input_format_t::bson, number) and sax->number_float(static_cast<number_float_t>(number), "");
- }
-
- case 0x02: // string
- {
- std::int32_t len;
- string_t value;
- return get_number<std::int32_t, true>(input_format_t::bson, len) and get_bson_string(len, value) and sax->string(value);
- }
-
- case 0x03: // object
- {
- return parse_bson_internal();
- }
-
- case 0x04: // array
- {
- return parse_bson_array();
- }
-
- case 0x05: // binary
- {
- std::int32_t len;
- binary_t value;
- return get_number<std::int32_t, true>(input_format_t::bson, len) and get_bson_binary(len, value) and sax->binary(value);
- }
-
- case 0x08: // boolean
- {
- return sax->boolean(get() != 0);
- }
-
- case 0x0A: // null
- {
- return sax->null();
- }
-
- case 0x10: // int32
- {
- std::int32_t value;
- return get_number<std::int32_t, true>(input_format_t::bson, value) and sax->number_integer(value);
- }
-
- case 0x12: // int64
- {
- std::int64_t value;
- return get_number<std::int64_t, true>(input_format_t::bson, value) and sax->number_integer(value);
- }
-
- default: // anything else not supported (yet)
- {
- std::array<char, 3> cr{{}};
- (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type));
- return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data())));
- }
- }
- }
-
- /*!
- @brief Read a BSON element list (as specified in the BSON-spec)
-
- The same binary layout is used for objects and arrays, hence it must be
- indicated with the argument @a is_array which one is expected
- (true --> array, false --> object).
-
- @param[in] is_array Determines if the element list being read is to be
- treated as an object (@a is_array == false), or as an
- array (@a is_array == true).
- @return whether a valid BSON-object/array was passed to the SAX parser
- */
- bool parse_bson_element_list(const bool is_array)
- {
- string_t key;
-
- while (auto element_type = get())
- {
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::bson, "element list")))
- {
- return false;
- }
-
- const std::size_t element_type_parse_position = chars_read;
- if (JSON_HEDLEY_UNLIKELY(not get_bson_cstr(key)))
- {
- return false;
- }
-
- if (not is_array and not sax->key(key))
- {
- return false;
- }
-
- if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_internal(element_type, element_type_parse_position)))
- {
- return false;
- }
-
- // get_bson_cstr only appends
- key.clear();
- }
-
- return true;
- }
-
- /*!
- @brief Reads an array from the BSON input and passes it to the SAX-parser.
- @return whether a valid BSON-array was passed to the SAX parser
- */
- bool parse_bson_array()
- {
- std::int32_t document_size;
- get_number<std::int32_t, true>(input_format_t::bson, document_size);
-
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
- {
- return false;
- }
-
- if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_list(/*is_array*/true)))
- {
- return false;
- }
-
- return sax->end_array();
- }
-
- //////////
- // CBOR //
- //////////
-
- /*!
- @param[in] get_char whether a new character should be retrieved from the
- input (true, default) or whether the last read
- character should be considered instead
-
- @return whether a valid CBOR value was passed to the SAX parser
- */
- bool parse_cbor_internal(const bool get_char = true)
- {
- switch (get_char ? get() : current)
- {
- // EOF
- case std::char_traits<char_type>::eof():
- return unexpect_eof(input_format_t::cbor, "value");
-
- // Integer 0x00..0x17 (0..23)
- case 0x00:
- case 0x01:
- case 0x02:
- case 0x03:
- case 0x04:
- case 0x05:
- case 0x06:
- case 0x07:
- case 0x08:
- case 0x09:
- case 0x0A:
- case 0x0B:
- case 0x0C:
- case 0x0D:
- case 0x0E:
- case 0x0F:
- case 0x10:
- case 0x11:
- case 0x12:
- case 0x13:
- case 0x14:
- case 0x15:
- case 0x16:
- case 0x17:
- return sax->number_unsigned(static_cast<number_unsigned_t>(current));
-
- case 0x18: // Unsigned integer (one-byte uint8_t follows)
- {
- std::uint8_t number;
- return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
- }
-
- case 0x19: // Unsigned integer (two-byte uint16_t follows)
- {
- std::uint16_t number;
- return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
- }
-
- case 0x1A: // Unsigned integer (four-byte uint32_t follows)
- {
- std::uint32_t number;
- return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
- }
-
- case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
- {
- std::uint64_t number;
- return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
- }
-
- // Negative integer -1-0x00..-1-0x17 (-1..-24)
- case 0x20:
- case 0x21:
- case 0x22:
- case 0x23:
- case 0x24:
- case 0x25:
- case 0x26:
- case 0x27:
- case 0x28:
- case 0x29:
- case 0x2A:
- case 0x2B:
- case 0x2C:
- case 0x2D:
- case 0x2E:
- case 0x2F:
- case 0x30:
- case 0x31:
- case 0x32:
- case 0x33:
- case 0x34:
- case 0x35:
- case 0x36:
- case 0x37:
- return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
-
- case 0x38: // Negative integer (one-byte uint8_t follows)
- {
- std::uint8_t number;
- return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
- }
-
- case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
- {
- std::uint16_t number;
- return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
- }
-
- case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
- {
- std::uint32_t number;
- return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
- }
-
- case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
- {
- std::uint64_t number;
- return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1)
- - static_cast<number_integer_t>(number));
- }
-
- // Binary data (0x00..0x17 bytes follow)
- case 0x40:
- case 0x41:
- case 0x42:
- case 0x43:
- case 0x44:
- case 0x45:
- case 0x46:
- case 0x47:
- case 0x48:
- case 0x49:
- case 0x4A:
- case 0x4B:
- case 0x4C:
- case 0x4D:
- case 0x4E:
- case 0x4F:
- case 0x50:
- case 0x51:
- case 0x52:
- case 0x53:
- case 0x54:
- case 0x55:
- case 0x56:
- case 0x57:
- case 0x58: // Binary data (one-byte uint8_t for n follows)
- case 0x59: // Binary data (two-byte uint16_t for n follow)
- case 0x5A: // Binary data (four-byte uint32_t for n follow)
- case 0x5B: // Binary data (eight-byte uint64_t for n follow)
- case 0x5F: // Binary data (indefinite length)
- {
- binary_t b;
- return get_cbor_binary(b) and sax->binary(b);
- }
-
- // UTF-8 string (0x00..0x17 bytes follow)
- case 0x60:
- case 0x61:
- case 0x62:
- case 0x63:
- case 0x64:
- case 0x65:
- case 0x66:
- case 0x67:
- case 0x68:
- case 0x69:
- case 0x6A:
- case 0x6B:
- case 0x6C:
- case 0x6D:
- case 0x6E:
- case 0x6F:
- case 0x70:
- case 0x71:
- case 0x72:
- case 0x73:
- case 0x74:
- case 0x75:
- case 0x76:
- case 0x77:
- case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
- case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
- case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
- case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
- case 0x7F: // UTF-8 string (indefinite length)
- {
- string_t s;
- return get_cbor_string(s) and sax->string(s);
- }
-
- // array (0x00..0x17 data items follow)
- case 0x80:
- case 0x81:
- case 0x82:
- case 0x83:
- case 0x84:
- case 0x85:
- case 0x86:
- case 0x87:
- case 0x88:
- case 0x89:
- case 0x8A:
- case 0x8B:
- case 0x8C:
- case 0x8D:
- case 0x8E:
- case 0x8F:
- case 0x90:
- case 0x91:
- case 0x92:
- case 0x93:
- case 0x94:
- case 0x95:
- case 0x96:
- case 0x97:
- return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
-
- case 0x98: // array (one-byte uint8_t for n follows)
- {
- std::uint8_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
- }
-
- case 0x99: // array (two-byte uint16_t for n follow)
- {
- std::uint16_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
- }
-
- case 0x9A: // array (four-byte uint32_t for n follow)
- {
- std::uint32_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
- }
-
- case 0x9B: // array (eight-byte uint64_t for n follow)
- {
- std::uint64_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
- }
-
- case 0x9F: // array (indefinite length)
- return get_cbor_array(std::size_t(-1));
-
- // map (0x00..0x17 pairs of data items follow)
- case 0xA0:
- case 0xA1:
- case 0xA2:
- case 0xA3:
- case 0xA4:
- case 0xA5:
- case 0xA6:
- case 0xA7:
- case 0xA8:
- case 0xA9:
- case 0xAA:
- case 0xAB:
- case 0xAC:
- case 0xAD:
- case 0xAE:
- case 0xAF:
- case 0xB0:
- case 0xB1:
- case 0xB2:
- case 0xB3:
- case 0xB4:
- case 0xB5:
- case 0xB6:
- case 0xB7:
- return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
-
- case 0xB8: // map (one-byte uint8_t for n follows)
- {
- std::uint8_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
- }
-
- case 0xB9: // map (two-byte uint16_t for n follow)
- {
- std::uint16_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
- }
-
- case 0xBA: // map (four-byte uint32_t for n follow)
- {
- std::uint32_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
- }
-
- case 0xBB: // map (eight-byte uint64_t for n follow)
- {
- std::uint64_t len;
- return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
- }
-
- case 0xBF: // map (indefinite length)
- return get_cbor_object(std::size_t(-1));
-
- case 0xF4: // false
- return sax->boolean(false);
-
- case 0xF5: // true
- return sax->boolean(true);
-
- case 0xF6: // null
- return sax->null();
-
- case 0xF9: // Half-Precision Float (two-byte IEEE 754)
- {
- const auto byte1_raw = get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
- {
- return false;
- }
- const auto byte2_raw = get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
- {
- return false;
- }
-
- const auto byte1 = static_cast<unsigned char>(byte1_raw);
- const auto byte2 = static_cast<unsigned char>(byte2_raw);
-
- // code from RFC 7049, Appendix D, Figure 3:
- // As half-precision floating-point numbers were only added
- // to IEEE 754 in 2008, today's programming platforms often
- // still only have limited support for them. It is very
- // easy to include at least decoding support for them even
- // without such support. An example of a small decoder for
- // half-precision floating-point numbers in the C language
- // is shown in Fig. 3.
- const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
- const double val = [&half]
- {
- const int exp = (half >> 10u) & 0x1Fu;
- const unsigned int mant = half & 0x3FFu;
- assert(0 <= exp and exp <= 32);
- assert(mant <= 1024);
- switch (exp)
- {
- case 0:
- return std::ldexp(mant, -24);
- case 31:
- return (mant == 0)
- ? std::numeric_limits<double>::infinity()
- : std::numeric_limits<double>::quiet_NaN();
- default:
- return std::ldexp(mant + 1024, exp - 25);
- }
- }();
- return sax->number_float((half & 0x8000u) != 0
- ? static_cast<number_float_t>(-val)
- : static_cast<number_float_t>(val), "");
- }
-
- case 0xFA: // Single-Precision Float (four-byte IEEE 754)
- {
- float number;
- return get_number(input_format_t::cbor, number) and sax->number_float(static_cast<number_float_t>(number), "");
- }
-
- case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
- {
- double number;
- return get_number(input_format_t::cbor, number) and sax->number_float(static_cast<number_float_t>(number), "");
- }
-
- default: // anything else (0xFF is handled inside the other types)
- {
- auto last_token = get_token_string();
- return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
- }
- }
- }
-
- /*!
- @brief reads a CBOR string
-
- This function first reads starting bytes to determine the expected
- string length and then copies this number of bytes into a string.
- Additionally, CBOR's strings with indefinite lengths are supported.
-
- @param[out] result created string
-
- @return whether string creation completed
- */
- bool get_cbor_string(string_t& result)
- {
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "string")))
- {
- return false;
- }
-
- switch (current)
- {
- // UTF-8 string (0x00..0x17 bytes follow)
- case 0x60:
- case 0x61:
- case 0x62:
- case 0x63:
- case 0x64:
- case 0x65:
- case 0x66:
- case 0x67:
- case 0x68:
- case 0x69:
- case 0x6A:
- case 0x6B:
- case 0x6C:
- case 0x6D:
- case 0x6E:
- case 0x6F:
- case 0x70:
- case 0x71:
- case 0x72:
- case 0x73:
- case 0x74:
- case 0x75:
- case 0x76:
- case 0x77:
- {
- return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
- }
-
- case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
- {
- std::uint8_t len;
- return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
- }
-
- case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
- {
- std::uint16_t len;
- return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
- }
-
- case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
- {
- std::uint32_t len;
- return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
- }
-
- case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
- {
- std::uint64_t len;
- return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
- }
-
- case 0x7F: // UTF-8 string (indefinite length)
- {
- while (get() != 0xFF)
- {
- string_t chunk;
- if (not get_cbor_string(chunk))
- {
- return false;
- }
- result.append(chunk);
- }
- return true;
- }
-
- default:
- {
- auto last_token = get_token_string();
- return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string")));
- }
- }
- }
-
- /*!
- @brief reads a CBOR byte array
-
- This function first reads starting bytes to determine the expected
- byte array length and then copies this number of bytes into the byte array.
- Additionally, CBOR's byte arrays with indefinite lengths are supported.
-
- @param[out] result created byte array
-
- @return whether byte array creation completed
- */
- bool get_cbor_binary(binary_t& result)
- {
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "binary")))
- {
- return false;
- }
-
- switch (current)
- {
- // Binary data (0x00..0x17 bytes follow)
- case 0x40:
- case 0x41:
- case 0x42:
- case 0x43:
- case 0x44:
- case 0x45:
- case 0x46:
- case 0x47:
- case 0x48:
- case 0x49:
- case 0x4A:
- case 0x4B:
- case 0x4C:
- case 0x4D:
- case 0x4E:
- case 0x4F:
- case 0x50:
- case 0x51:
- case 0x52:
- case 0x53:
- case 0x54:
- case 0x55:
- case 0x56:
- case 0x57:
- {
- return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
- }
-
- case 0x58: // Binary data (one-byte uint8_t for n follows)
- {
- std::uint8_t len;
- return get_number(input_format_t::cbor, len) and
- get_binary(input_format_t::cbor, len, result);
- }
-
- case 0x59: // Binary data (two-byte uint16_t for n follow)
- {
- std::uint16_t len;
- return get_number(input_format_t::cbor, len) and
- get_binary(input_format_t::cbor, len, result);
- }
-
- case 0x5A: // Binary data (four-byte uint32_t for n follow)
- {
- std::uint32_t len;
- return get_number(input_format_t::cbor, len) and
- get_binary(input_format_t::cbor, len, result);
- }
-
- case 0x5B: // Binary data (eight-byte uint64_t for n follow)
- {
- std::uint64_t len;
- return get_number(input_format_t::cbor, len) and
- get_binary(input_format_t::cbor, len, result);
- }
-
- case 0x5F: // Binary data (indefinite length)
- {
- while (get() != 0xFF)
- {
- binary_t chunk;
- if (not get_cbor_binary(chunk))
- {
- return false;
- }
- result.insert(result.end(), chunk.begin(), chunk.end());
- }
- return true;
- }
-
- default:
- {
- auto last_token = get_token_string();
- return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x" + last_token, "binary")));
- }
- }
- }
-
- /*!
- @param[in] len the length of the array or std::size_t(-1) for an
- array of indefinite size
- @return whether array creation completed
- */
- bool get_cbor_array(const std::size_t len)
- {
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(len)))
- {
- return false;
- }
-
- if (len != std::size_t(-1))
- {
- for (std::size_t i = 0; i < len; ++i)
- {
- if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
- {
- return false;
- }
- }
- }
- else
- {
- while (get() != 0xFF)
- {
- if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal(false)))
- {
- return false;
- }
- }
- }
-
- return sax->end_array();
- }
-
- /*!
- @param[in] len the length of the object or std::size_t(-1) for an
- object of indefinite size
- @return whether object creation completed
- */
- bool get_cbor_object(const std::size_t len)
- {
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(len)))
- {
- return false;
- }
-
- string_t key;
- if (len != std::size_t(-1))
- {
- for (std::size_t i = 0; i < len; ++i)
- {
- get();
- if (JSON_HEDLEY_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
- {
- return false;
- }
-
- if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
- {
- return false;
- }
- key.clear();
- }
- }
- else
- {
- while (get() != 0xFF)
- {
- if (JSON_HEDLEY_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
- {
- return false;
- }
-
- if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
- {
- return false;
- }
- key.clear();
- }
- }
-
- return sax->end_object();
- }
-
- /////////////
- // MsgPack //
- /////////////
-
- /*!
- @return whether a valid MessagePack value was passed to the SAX parser
- */
- bool parse_msgpack_internal()
- {
- switch (get())
- {
- // EOF
- case std::char_traits<char_type>::eof():
- return unexpect_eof(input_format_t::msgpack, "value");
-
- // positive fixint
- case 0x00:
- case 0x01:
- case 0x02:
- case 0x03:
- case 0x04:
- case 0x05:
- case 0x06:
- case 0x07:
- case 0x08:
- case 0x09:
- case 0x0A:
- case 0x0B:
- case 0x0C:
- case 0x0D:
- case 0x0E:
- case 0x0F:
- case 0x10:
- case 0x11:
- case 0x12:
- case 0x13:
- case 0x14:
- case 0x15:
- case 0x16:
- case 0x17:
- case 0x18:
- case 0x19:
- case 0x1A:
- case 0x1B:
- case 0x1C:
- case 0x1D:
- case 0x1E:
- case 0x1F:
- case 0x20:
- case 0x21:
- case 0x22:
- case 0x23:
- case 0x24:
- case 0x25:
- case 0x26:
- case 0x27:
- case 0x28:
- case 0x29:
- case 0x2A:
- case 0x2B:
- case 0x2C:
- case 0x2D:
- case 0x2E:
- case 0x2F:
- case 0x30:
- case 0x31:
- case 0x32:
- case 0x33:
- case 0x34:
- case 0x35:
- case 0x36:
- case 0x37:
- case 0x38:
- case 0x39:
- case 0x3A:
- case 0x3B:
- case 0x3C:
- case 0x3D:
- case 0x3E:
- case 0x3F:
- case 0x40:
- case 0x41:
- case 0x42:
- case 0x43:
- case 0x44:
- case 0x45:
- case 0x46:
- case 0x47:
- case 0x48:
- case 0x49:
- case 0x4A:
- case 0x4B:
- case 0x4C:
- case 0x4D:
- case 0x4E:
- case 0x4F:
- case 0x50:
- case 0x51:
- case 0x52:
- case 0x53:
- case 0x54:
- case 0x55:
- case 0x56:
- case 0x57:
- case 0x58:
- case 0x59:
- case 0x5A:
- case 0x5B:
- case 0x5C:
- case 0x5D:
- case 0x5E:
- case 0x5F:
- case 0x60:
- case 0x61:
- case 0x62:
- case 0x63:
- case 0x64:
- case 0x65:
- case 0x66:
- case 0x67:
- case 0x68:
- case 0x69:
- case 0x6A:
- case 0x6B:
- case 0x6C:
- case 0x6D:
- case 0x6E:
- case 0x6F:
- case 0x70:
- case 0x71:
- case 0x72:
- case 0x73:
- case 0x74:
- case 0x75:
- case 0x76:
- case 0x77:
- case 0x78:
- case 0x79:
- case 0x7A:
- case 0x7B:
- case 0x7C:
- case 0x7D:
- case 0x7E:
- case 0x7F:
- return sax->number_unsigned(static_cast<number_unsigned_t>(current));
-
- // fixmap
- case 0x80:
- case 0x81:
- case 0x82:
- case 0x83:
- case 0x84:
- case 0x85:
- case 0x86:
- case 0x87:
- case 0x88:
- case 0x89:
- case 0x8A:
- case 0x8B:
- case 0x8C:
- case 0x8D:
- case 0x8E:
- case 0x8F:
- return get_msgpack_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
-
- // fixarray
- case 0x90:
- case 0x91:
- case 0x92:
- case 0x93:
- case 0x94:
- case 0x95:
- case 0x96:
- case 0x97:
- case 0x98:
- case 0x99:
- case 0x9A:
- case 0x9B:
- case 0x9C:
- case 0x9D:
- case 0x9E:
- case 0x9F:
- return get_msgpack_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
-
- // fixstr
- case 0xA0:
- case 0xA1:
- case 0xA2:
- case 0xA3:
- case 0xA4:
- case 0xA5:
- case 0xA6:
- case 0xA7:
- case 0xA8:
- case 0xA9:
- case 0xAA:
- case 0xAB:
- case 0xAC:
- case 0xAD:
- case 0xAE:
- case 0xAF:
- case 0xB0:
- case 0xB1:
- case 0xB2:
- case 0xB3:
- case 0xB4:
- case 0xB5:
- case 0xB6:
- case 0xB7:
- case 0xB8:
- case 0xB9:
- case 0xBA:
- case 0xBB:
- case 0xBC:
- case 0xBD:
- case 0xBE:
- case 0xBF:
- case 0xD9: // str 8
- case 0xDA: // str 16
- case 0xDB: // str 32
- {
- string_t s;
- return get_msgpack_string(s) and sax->string(s);
- }
-
- case 0xC0: // nil
- return sax->null();
-
- case 0xC2: // false
- return sax->boolean(false);
-
- case 0xC3: // true
- return sax->boolean(true);
-
- case 0xC4: // bin 8
- case 0xC5: // bin 16
- case 0xC6: // bin 32
- case 0xC7: // ext 8
- case 0xC8: // ext 16
- case 0xC9: // ext 32
- case 0xD4: // fixext 1
- case 0xD5: // fixext 2
- case 0xD6: // fixext 4
- case 0xD7: // fixext 8
- case 0xD8: // fixext 16
- {
- binary_t b;
- return get_msgpack_binary(b) and sax->binary(b);
- }
-
- case 0xCA: // float 32
- {
- float number;
- return get_number(input_format_t::msgpack, number) and sax->number_float(static_cast<number_float_t>(number), "");
- }
-
- case 0xCB: // float 64
- {
- double number;
- return get_number(input_format_t::msgpack, number) and sax->number_float(static_cast<number_float_t>(number), "");
- }
-
- case 0xCC: // uint 8
- {
- std::uint8_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
- }
-
- case 0xCD: // uint 16
- {
- std::uint16_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
- }
-
- case 0xCE: // uint 32
- {
- std::uint32_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
- }
-
- case 0xCF: // uint 64
- {
- std::uint64_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
- }
-
- case 0xD0: // int 8
- {
- std::int8_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
- }
-
- case 0xD1: // int 16
- {
- std::int16_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
- }
-
- case 0xD2: // int 32
- {
- std::int32_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
- }
-
- case 0xD3: // int 64
- {
- std::int64_t number;
- return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
- }
-
- case 0xDC: // array 16
- {
- std::uint16_t len;
- return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
- }
-
- case 0xDD: // array 32
- {
- std::uint32_t len;
- return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
- }
-
- case 0xDE: // map 16
- {
- std::uint16_t len;
- return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
- }
-
- case 0xDF: // map 32
- {
- std::uint32_t len;
- return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
- }
-
- // negative fixint
- case 0xE0:
- case 0xE1:
- case 0xE2:
- case 0xE3:
- case 0xE4:
- case 0xE5:
- case 0xE6:
- case 0xE7:
- case 0xE8:
- case 0xE9:
- case 0xEA:
- case 0xEB:
- case 0xEC:
- case 0xED:
- case 0xEE:
- case 0xEF:
- case 0xF0:
- case 0xF1:
- case 0xF2:
- case 0xF3:
- case 0xF4:
- case 0xF5:
- case 0xF6:
- case 0xF7:
- case 0xF8:
- case 0xF9:
- case 0xFA:
- case 0xFB:
- case 0xFC:
- case 0xFD:
- case 0xFE:
- case 0xFF:
- return sax->number_integer(static_cast<std::int8_t>(current));
-
- default: // anything else
- {
- auto last_token = get_token_string();
- return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack, "invalid byte: 0x" + last_token, "value")));
- }
- }
- }
-
- /*!
- @brief reads a MessagePack string
-
- This function first reads starting bytes to determine the expected
- string length and then copies this number of bytes into a string.
-
- @param[out] result created string
-
- @return whether string creation completed
- */
- bool get_msgpack_string(string_t& result)
- {
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::msgpack, "string")))
- {
- return false;
- }
-
- switch (current)
- {
- // fixstr
- case 0xA0:
- case 0xA1:
- case 0xA2:
- case 0xA3:
- case 0xA4:
- case 0xA5:
- case 0xA6:
- case 0xA7:
- case 0xA8:
- case 0xA9:
- case 0xAA:
- case 0xAB:
- case 0xAC:
- case 0xAD:
- case 0xAE:
- case 0xAF:
- case 0xB0:
- case 0xB1:
- case 0xB2:
- case 0xB3:
- case 0xB4:
- case 0xB5:
- case 0xB6:
- case 0xB7:
- case 0xB8:
- case 0xB9:
- case 0xBA:
- case 0xBB:
- case 0xBC:
- case 0xBD:
- case 0xBE:
- case 0xBF:
- {
- return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
- }
-
- case 0xD9: // str 8
- {
- std::uint8_t len;
- return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
- }
-
- case 0xDA: // str 16
- {
- std::uint16_t len;
- return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
- }
-
- case 0xDB: // str 32
- {
- std::uint32_t len;
- return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
- }
-
- default:
- {
- auto last_token = get_token_string();
- return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string")));
- }
- }
- }
-
- /*!
- @brief reads a MessagePack byte array
-
- This function first reads starting bytes to determine the expected
- byte array length and then copies this number of bytes into a byte array.
-
- @param[out] result created byte array
-
- @return whether byte array creation completed
- */
- bool get_msgpack_binary(binary_t& result)
- {
- // helper function to set the subtype
- auto assign_and_return_true = [&result](std::int8_t subtype)
- {
- result.set_subtype(static_cast<std::uint8_t>(subtype));
- return true;
- };
-
- switch (current)
- {
- case 0xC4: // bin 8
- {
- std::uint8_t len;
- return get_number(input_format_t::msgpack, len) and
- get_binary(input_format_t::msgpack, len, result);
- }
-
- case 0xC5: // bin 16
- {
- std::uint16_t len;
- return get_number(input_format_t::msgpack, len) and
- get_binary(input_format_t::msgpack, len, result);
- }
-
- case 0xC6: // bin 32
- {
- std::uint32_t len;
- return get_number(input_format_t::msgpack, len) and
- get_binary(input_format_t::msgpack, len, result);
- }
-
- case 0xC7: // ext 8
- {
- std::uint8_t len;
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, len) and
- get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, len, result) and
- assign_and_return_true(subtype);
- }
-
- case 0xC8: // ext 16
- {
- std::uint16_t len;
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, len) and
- get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, len, result) and
- assign_and_return_true(subtype);
- }
-
- case 0xC9: // ext 32
- {
- std::uint32_t len;
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, len) and
- get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, len, result) and
- assign_and_return_true(subtype);
- }
-
- case 0xD4: // fixext 1
- {
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, 1, result) and
- assign_and_return_true(subtype);
- }
-
- case 0xD5: // fixext 2
- {
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, 2, result) and
- assign_and_return_true(subtype);
- }
-
- case 0xD6: // fixext 4
- {
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, 4, result) and
- assign_and_return_true(subtype);
- }
-
- case 0xD7: // fixext 8
- {
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, 8, result) and
- assign_and_return_true(subtype);
- }
-
- case 0xD8: // fixext 16
- {
- std::int8_t subtype;
- return get_number(input_format_t::msgpack, subtype) and
- get_binary(input_format_t::msgpack, 16, result) and
- assign_and_return_true(subtype);
- }
-
- default: // LCOV_EXCL_LINE
- return false; // LCOV_EXCL_LINE
- }
- }
-
- /*!
- @param[in] len the length of the array
- @return whether array creation completed
- */
- bool get_msgpack_array(const std::size_t len)
- {
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(len)))
- {
- return false;
- }
-
- for (std::size_t i = 0; i < len; ++i)
- {
- if (JSON_HEDLEY_UNLIKELY(not parse_msgpack_internal()))
- {
- return false;
- }
- }
-
- return sax->end_array();
- }
-
- /*!
- @param[in] len the length of the object
- @return whether object creation completed
- */
- bool get_msgpack_object(const std::size_t len)
- {
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(len)))
- {
- return false;
- }
-
- string_t key;
- for (std::size_t i = 0; i < len; ++i)
- {
- get();
- if (JSON_HEDLEY_UNLIKELY(not get_msgpack_string(key) or not sax->key(key)))
- {
- return false;
- }
-
- if (JSON_HEDLEY_UNLIKELY(not parse_msgpack_internal()))
- {
- return false;
- }
- key.clear();
- }
-
- return sax->end_object();
- }
-
- ////////////
- // UBJSON //
- ////////////
-
- /*!
- @param[in] get_char whether a new character should be retrieved from the
- input (true, default) or whether the last read
- character should be considered instead
-
- @return whether a valid UBJSON value was passed to the SAX parser
- */
- bool parse_ubjson_internal(const bool get_char = true)
- {
- return get_ubjson_value(get_char ? get_ignore_noop() : current);
- }
-
- /*!
- @brief reads a UBJSON string
-
- This function is either called after reading the 'S' byte explicitly
- indicating a string, or in case of an object key where the 'S' byte can be
- left out.
-
- @param[out] result created string
- @param[in] get_char whether a new character should be retrieved from the
- input (true, default) or whether the last read
- character should be considered instead
-
- @return whether string creation completed
- */
- bool get_ubjson_string(string_t& result, const bool get_char = true)
- {
- if (get_char)
- {
- get(); // TODO(niels): may we ignore N here?
- }
-
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
- {
- return false;
- }
-
- switch (current)
- {
- case 'U':
- {
- std::uint8_t len;
- return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
- }
-
- case 'i':
- {
- std::int8_t len;
- return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
- }
-
- case 'I':
- {
- std::int16_t len;
- return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
- }
-
- case 'l':
- {
- std::int32_t len;
- return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
- }
-
- case 'L':
- {
- std::int64_t len;
- return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
- }
-
- default:
- auto last_token = get_token_string();
- return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string")));
- }
- }
-
- /*!
- @param[out] result determined size
- @return whether size determination completed
- */
- bool get_ubjson_size_value(std::size_t& result)
- {
- switch (get_ignore_noop())
- {
- case 'U':
- {
- std::uint8_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
- {
- return false;
- }
- result = static_cast<std::size_t>(number);
- return true;
- }
-
- case 'i':
- {
- std::int8_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
- {
- return false;
- }
- result = static_cast<std::size_t>(number);
- return true;
- }
-
- case 'I':
- {
- std::int16_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
- {
- return false;
- }
- result = static_cast<std::size_t>(number);
- return true;
- }
-
- case 'l':
- {
- std::int32_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
- {
- return false;
- }
- result = static_cast<std::size_t>(number);
- return true;
- }
-
- case 'L':
- {
- std::int64_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
- {
- return false;
- }
- result = static_cast<std::size_t>(number);
- return true;
- }
-
- default:
- {
- auto last_token = get_token_string();
- return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size")));
- }
- }
- }
-
- /*!
- @brief determine the type and size for a container
-
- In the optimized UBJSON format, a type and a size can be provided to allow
- for a more compact representation.
-
- @param[out] result pair of the size and the type
-
- @return whether pair creation completed
- */
- bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
- {
- result.first = string_t::npos; // size
- result.second = 0; // type
-
- get_ignore_noop();
-
- if (current == '$')
- {
- result.second = get(); // must not ignore 'N', because 'N' maybe the type
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "type")))
- {
- return false;
- }
-
- get_ignore_noop();
- if (JSON_HEDLEY_UNLIKELY(current != '#'))
- {
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
- {
- return false;
- }
- auto last_token = get_token_string();
- return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size")));
- }
-
- return get_ubjson_size_value(result.first);
- }
-
- if (current == '#')
- {
- return get_ubjson_size_value(result.first);
- }
-
- return true;
- }
-
- /*!
- @param prefix the previously read or set type prefix
- @return whether value creation completed
- */
- bool get_ubjson_value(const char_int_type prefix)
- {
- switch (prefix)
- {
- case std::char_traits<char_type>::eof(): // EOF
- return unexpect_eof(input_format_t::ubjson, "value");
-
- case 'T': // true
- return sax->boolean(true);
- case 'F': // false
- return sax->boolean(false);
-
- case 'Z': // null
- return sax->null();
-
- case 'U':
- {
- std::uint8_t number;
- return get_number(input_format_t::ubjson, number) and sax->number_unsigned(number);
- }
-
- case 'i':
- {
- std::int8_t number;
- return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
- }
-
- case 'I':
- {
- std::int16_t number;
- return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
- }
-
- case 'l':
- {
- std::int32_t number;
- return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
- }
-
- case 'L':
- {
- std::int64_t number;
- return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
- }
-
- case 'd':
- {
- float number;
- return get_number(input_format_t::ubjson, number) and sax->number_float(static_cast<number_float_t>(number), "");
- }
-
- case 'D':
- {
- double number;
- return get_number(input_format_t::ubjson, number) and sax->number_float(static_cast<number_float_t>(number), "");
- }
-
- case 'C': // char
- {
- get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "char")))
- {
- return false;
- }
- if (JSON_HEDLEY_UNLIKELY(current > 127))
- {
- auto last_token = get_token_string();
- return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char")));
- }
- string_t s(1, static_cast<typename string_t::value_type>(current));
- return sax->string(s);
- }
-
- case 'S': // string
- {
- string_t s;
- return get_ubjson_string(s) and sax->string(s);
- }
-
- case '[': // array
- return get_ubjson_array();
-
- case '{': // object
- return get_ubjson_object();
-
- default: // anything else
- {
- auto last_token = get_token_string();
- return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "invalid byte: 0x" + last_token, "value")));
- }
- }
- }
-
- /*!
- @return whether array creation completed
- */
- bool get_ubjson_array()
- {
- std::pair<std::size_t, char_int_type> size_and_type;
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_size_type(size_and_type)))
- {
- return false;
- }
-
- if (size_and_type.first != string_t::npos)
- {
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(size_and_type.first)))
- {
- return false;
- }
-
- if (size_and_type.second != 0)
- {
- if (size_and_type.second != 'N')
- {
- for (std::size_t i = 0; i < size_and_type.first; ++i)
- {
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_value(size_and_type.second)))
- {
- return false;
- }
- }
- }
- }
- else
- {
- for (std::size_t i = 0; i < size_and_type.first; ++i)
- {
- if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
- {
- return false;
- }
- }
- }
- }
- else
- {
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
- {
- return false;
- }
-
- while (current != ']')
- {
- if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal(false)))
- {
- return false;
- }
- get_ignore_noop();
- }
- }
-
- return sax->end_array();
- }
-
- /*!
- @return whether object creation completed
- */
- bool get_ubjson_object()
- {
- std::pair<std::size_t, char_int_type> size_and_type;
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_size_type(size_and_type)))
- {
- return false;
- }
-
- string_t key;
- if (size_and_type.first != string_t::npos)
- {
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(size_and_type.first)))
- {
- return false;
- }
-
- if (size_and_type.second != 0)
- {
- for (std::size_t i = 0; i < size_and_type.first; ++i)
- {
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
- {
- return false;
- }
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_value(size_and_type.second)))
- {
- return false;
- }
- key.clear();
- }
- }
- else
- {
- for (std::size_t i = 0; i < size_and_type.first; ++i)
- {
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
- {
- return false;
- }
- if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
- {
- return false;
- }
- key.clear();
- }
- }
- }
- else
- {
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
- {
- return false;
- }
-
- while (current != '}')
- {
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key, false) or not sax->key(key)))
- {
- return false;
- }
- if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
- {
- return false;
- }
- get_ignore_noop();
- key.clear();
- }
- }
-
- return sax->end_object();
- }
-
- // Note, no reader for UBJSON binary types is implemented because they do
- // not exist
-
- ///////////////////////
- // Utility functions //
- ///////////////////////
-
- /*!
- @brief get next character from the input
-
- This function provides the interface to the used input adapter. It does
- not throw in case the input reached EOF, but returns a -'ve valued
- `std::char_traits<char_type>::eof()` in that case.
-
- @return character read from the input
- */
- char_int_type get()
- {
- ++chars_read;
- return current = ia.get_character();
- }
-
- /*!
- @return character read from the input after ignoring all 'N' entries
- */
- char_int_type get_ignore_noop()
- {
- do
- {
- get();
- }
- while (current == 'N');
-
- return current;
- }
-
- /*
- @brief read a number from the input
-
- @tparam NumberType the type of the number
- @param[in] format the current format (for diagnostics)
- @param[out] result number of type @a NumberType
-
- @return whether conversion completed
-
- @note This function needs to respect the system's endianess, because
- bytes in CBOR, MessagePack, and UBJSON are stored in network order
- (big endian) and therefore need reordering on little endian systems.
- */
- template<typename NumberType, bool InputIsLittleEndian = false>
- bool get_number(const input_format_t format, NumberType& result)
- {
- // step 1: read input into array with system's byte order
- std::array<std::uint8_t, sizeof(NumberType)> vec;
- for (std::size_t i = 0; i < sizeof(NumberType); ++i)
- {
- get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "number")))
- {
- return false;
- }
-
- // reverse byte order prior to conversion if necessary
- if (is_little_endian != InputIsLittleEndian)
- {
- vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
- }
- else
- {
- vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
- }
- }
-
- // step 2: convert array into number of type T and return
- std::memcpy(&result, vec.data(), sizeof(NumberType));
- return true;
- }
-
- /*!
- @brief create a string by reading characters from the input
-
- @tparam NumberType the type of the number
- @param[in] format the current format (for diagnostics)
- @param[in] len number of characters to read
- @param[out] result string created by reading @a len bytes
-
- @return whether string creation completed
-
- @note We can not reserve @a len bytes for the result, because @a len
- may be too large. Usually, @ref unexpect_eof() detects the end of
- the input before we run out of string memory.
- */
- template<typename NumberType>
- bool get_string(const input_format_t format,
- const NumberType len,
- string_t& result)
- {
- bool success = true;
- std::generate_n(std::back_inserter(result), len, [this, &success, &format]()
- {
- get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "string")))
- {
- success = false;
- }
- return std::char_traits<char_type>::to_char_type(current);
- });
- return success;
- }
-
- /*!
- @brief create a byte array by reading bytes from the input
-
- @tparam NumberType the type of the number
- @param[in] format the current format (for diagnostics)
- @param[in] len number of bytes to read
- @param[out] result byte array created by reading @a len bytes
-
- @return whether byte array creation completed
-
- @note We can not reserve @a len bytes for the result, because @a len
- may be too large. Usually, @ref unexpect_eof() detects the end of
- the input before we run out of memory.
- */
- template<typename NumberType>
- bool get_binary(const input_format_t format,
- const NumberType len,
- binary_t& result)
- {
- bool success = true;
- std::generate_n(std::back_inserter(result), len, [this, &success, &format]()
- {
- get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "binary")))
- {
- success = false;
- }
- return static_cast<std::uint8_t>(current);
- });
- return success;
- }
-
- /*!
- @param[in] format the current format (for diagnostics)
- @param[in] context further context information (for diagnostics)
- @return whether the last read character is not EOF
- */
- JSON_HEDLEY_NON_NULL(3)
- bool unexpect_eof(const input_format_t format, const char* context) const
- {
- if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
- {
- return sax->parse_error(chars_read, "<end of file>",
- parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context)));
- }
- return true;
- }
-
- /*!
- @return a string representation of the last read byte
- */
- std::string get_token_string() const
- {
- std::array<char, 3> cr{{}};
- (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current));
- return std::string{cr.data()};
- }
-
- /*!
- @param[in] format the current format
- @param[in] detail a detailed error message
- @param[in] context further context information
- @return a message string to use in the parse_error exceptions
- */
- std::string exception_message(const input_format_t format,
- const std::string& detail,
- const std::string& context) const
- {
- std::string error_msg = "syntax error while parsing ";
-
- switch (format)
- {
- case input_format_t::cbor:
- error_msg += "CBOR";
- break;
-
- case input_format_t::msgpack:
- error_msg += "MessagePack";
- break;
-
- case input_format_t::ubjson:
- error_msg += "UBJSON";
- break;
-
- case input_format_t::bson:
- error_msg += "BSON";
- break;
-
- default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
- }
-
- return error_msg + " " + context + ": " + detail;
- }
-
- private:
- /// input adapter
- InputAdapterType ia;
-
- /// the current character
- char_int_type current = std::char_traits<char_type>::eof();
-
- /// the number of characters read
- std::size_t chars_read = 0;
-
- /// whether we can assume little endianess
- const bool is_little_endian = little_endianess();
-
- /// the SAX parser
- json_sax_t* sax = nullptr;
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/input/input_adapters.hpp>
-
// #include <nlohmann/detail/input/lexer.hpp>
@@ -8179,8 +5991,11 @@ class lexer : public lexer_base<BasicJsonType>
public:
using token_type = typename lexer_base<BasicJsonType>::token_type;
- explicit lexer(InputAdapterType&& adapter)
- : ia(std::move(adapter)), decimal_point_char(static_cast<char_int_type>(get_decimal_point())) {}
+ explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false)
+ : ia(std::move(adapter))
+ , ignore_comments(ignore_comments_)
+ , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
+ {}
// delete because of pointer members
lexer(const lexer&) = delete;
@@ -8198,8 +6013,8 @@ class lexer : public lexer_base<BasicJsonType>
JSON_HEDLEY_PURE
static char get_decimal_point() noexcept
{
- const auto loc = localeconv();
- assert(loc != nullptr);
+ const auto* loc = localeconv();
+ JSON_ASSERT(loc != nullptr);
return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
}
@@ -8225,7 +6040,7 @@ class lexer : public lexer_base<BasicJsonType>
int get_codepoint()
{
// this function only makes sense after reading `\u`
- assert(current == 'u');
+ JSON_ASSERT(current == 'u');
int codepoint = 0;
const auto factors = { 12u, 8u, 4u, 0u };
@@ -8233,15 +6048,15 @@ class lexer : public lexer_base<BasicJsonType>
{
get();
- if (current >= '0' and current <= '9')
+ if (current >= '0' && current <= '9')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
}
- else if (current >= 'A' and current <= 'F')
+ else if (current >= 'A' && current <= 'F')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
}
- else if (current >= 'a' and current <= 'f')
+ else if (current >= 'a' && current <= 'f')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
}
@@ -8251,7 +6066,7 @@ class lexer : public lexer_base<BasicJsonType>
}
}
- assert(0x0000 <= codepoint and codepoint <= 0xFFFF);
+ JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
return codepoint;
}
@@ -8272,13 +6087,13 @@ class lexer : public lexer_base<BasicJsonType>
*/
bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{
- assert(ranges.size() == 2 or ranges.size() == 4 or ranges.size() == 6);
+ JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
- if (JSON_HEDLEY_LIKELY(*range <= current and current <= *(++range)))
+ if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
{
add(current);
}
@@ -8313,7 +6128,7 @@ class lexer : public lexer_base<BasicJsonType>
reset();
// we entered the function by reading an open quote
- assert(current == '\"');
+ JSON_ASSERT(current == '\"');
while (true)
{
@@ -8384,10 +6199,10 @@ class lexer : public lexer_base<BasicJsonType>
}
// check if code point is a high surrogate
- if (0xD800 <= codepoint1 and codepoint1 <= 0xDBFF)
+ if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
{
// expect next \uxxxx entry
- if (JSON_HEDLEY_LIKELY(get() == '\\' and get() == 'u'))
+ if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
{
const int codepoint2 = get_codepoint();
@@ -8398,7 +6213,7 @@ class lexer : public lexer_base<BasicJsonType>
}
// check if codepoint2 is a low surrogate
- if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF))
+ if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
{
// overwrite codepoint
codepoint = static_cast<int>(
@@ -8425,7 +6240,7 @@ class lexer : public lexer_base<BasicJsonType>
}
else
{
- if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 and codepoint1 <= 0xDFFF))
+ if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
{
error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
return token_type::parse_error;
@@ -8433,7 +6248,7 @@ class lexer : public lexer_base<BasicJsonType>
}
// result of the above calculation yields a proper codepoint
- assert(0x00 <= codepoint and codepoint <= 0x10FFFF);
+ JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
// translate codepoint into bytes
if (codepoint < 0x80)
@@ -8800,7 +6615,7 @@ class lexer : public lexer_base<BasicJsonType>
case 0xDE:
case 0xDF:
{
- if (JSON_HEDLEY_UNLIKELY(not next_byte_in_range({0x80, 0xBF})))
+ if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
{
return token_type::parse_error;
}
@@ -8810,7 +6625,7 @@ class lexer : public lexer_base<BasicJsonType>
// U+0800..U+0FFF: bytes E0 A0..BF 80..BF
case 0xE0:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
+ if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -8834,7 +6649,7 @@ class lexer : public lexer_base<BasicJsonType>
case 0xEE:
case 0xEF:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
+ if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -8844,7 +6659,7 @@ class lexer : public lexer_base<BasicJsonType>
// U+D000..U+D7FF: bytes ED 80..9F 80..BF
case 0xED:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
+ if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -8854,7 +6669,7 @@ class lexer : public lexer_base<BasicJsonType>
// U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
case 0xF0:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+ if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -8866,7 +6681,7 @@ class lexer : public lexer_base<BasicJsonType>
case 0xF2:
case 0xF3:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+ if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -8876,7 +6691,7 @@ class lexer : public lexer_base<BasicJsonType>
// U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
case 0xF4:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
+ if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -8893,6 +6708,77 @@ class lexer : public lexer_base<BasicJsonType>
}
}
+ /*!
+ * @brief scan a comment
+ * @return whether comment could be scanned successfully
+ */
+ bool scan_comment()
+ {
+ switch (get())
+ {
+ // single-line comments skip input until a newline or EOF is read
+ case '/':
+ {
+ while (true)
+ {
+ switch (get())
+ {
+ case '\n':
+ case '\r':
+ case std::char_traits<char_type>::eof():
+ case '\0':
+ return true;
+
+ default:
+ break;
+ }
+ }
+ }
+
+ // multi-line comments skip input until */ is read
+ case '*':
+ {
+ while (true)
+ {
+ switch (get())
+ {
+ case std::char_traits<char_type>::eof():
+ case '\0':
+ {
+ error_message = "invalid comment; missing closing '*/'";
+ return false;
+ }
+
+ case '*':
+ {
+ switch (get())
+ {
+ case '/':
+ return true;
+
+ default:
+ {
+ unget();
+ break;
+ }
+ }
+ }
+
+ default:
+ break;
+ }
+ }
+ }
+
+ // unexpected character after reading '/'
+ default:
+ {
+ error_message = "invalid comment; expecting '/' or '*' after '/'";
+ return false;
+ }
+ }
+ }
+
JSON_HEDLEY_NON_NULL(2)
static void strtof(float& f, const char* str, char** endptr) noexcept
{
@@ -8991,7 +6877,7 @@ class lexer : public lexer_base<BasicJsonType>
// all other characters are rejected outside scan_number()
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
scan_number_minus:
@@ -9238,7 +7124,7 @@ scan_number_done:
const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
// we checked the number format before
- assert(endptr == token_buffer.data() + token_buffer.size());
+ JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
if (errno == 0)
{
@@ -9254,7 +7140,7 @@ scan_number_done:
const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
// we checked the number format before
- assert(endptr == token_buffer.data() + token_buffer.size());
+ JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
if (errno == 0)
{
@@ -9271,7 +7157,7 @@ scan_number_done:
strtof(value_float, token_buffer.data(), &endptr);
// we checked the number format before
- assert(endptr == token_buffer.data() + token_buffer.size());
+ JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
return token_type::value_float;
}
@@ -9285,7 +7171,7 @@ scan_number_done:
token_type scan_literal(const char_type* literal_text, const std::size_t length,
token_type return_type)
{
- assert(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
+ JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
for (std::size_t i = 1; i < length; ++i)
{
if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
@@ -9377,7 +7263,7 @@ scan_number_done:
if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
{
- assert(not token_string.empty());
+ JSON_ASSERT(!token_string.empty());
token_string.pop_back();
}
}
@@ -9473,7 +7359,7 @@ scan_number_done:
if (get() == 0xEF)
{
// check if we completely parse the BOM
- return get() == 0xBB and get() == 0xBF;
+ return get() == 0xBB && get() == 0xBF;
}
// the first character is not the beginning of the BOM; unget it to
@@ -9482,21 +7368,38 @@ scan_number_done:
return true;
}
+ void skip_whitespace()
+ {
+ do
+ {
+ get();
+ }
+ while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
+ }
+
token_type scan()
{
// initially, skip the BOM
- if (position.chars_read_total == 0 and not skip_bom())
+ if (position.chars_read_total == 0 && !skip_bom())
{
error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
return token_type::parse_error;
}
// read next character and ignore whitespace
- do
+ skip_whitespace();
+
+ // ignore comments
+ if (ignore_comments && current == '/')
{
- get();
+ if (!scan_comment())
+ {
+ return token_type::parse_error;
+ }
+
+ // skip following whitespace
+ skip_whitespace();
}
- while (current == ' ' or current == '\t' or current == '\n' or current == '\r');
switch (current)
{
@@ -9566,6 +7469,9 @@ scan_number_done:
/// input adapter
InputAdapterType ia;
+ /// whether comments should be ignored (true) or signaled as errors (false)
+ const bool ignore_comments = false;
+
/// the current character
char_int_type current = std::char_traits<char_type>::eof();
@@ -9595,10 +7501,2609 @@ scan_number_done:
} // namespace detail
} // namespace nlohmann
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+
+#include <cstdint> // size_t
+#include <utility> // declval
+#include <string> // string
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename T>
+using null_function_t = decltype(std::declval<T&>().null());
+
+template<typename T>
+using boolean_function_t =
+ decltype(std::declval<T&>().boolean(std::declval<bool>()));
+
+template<typename T, typename Integer>
+using number_integer_function_t =
+ decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
+
+template<typename T, typename Unsigned>
+using number_unsigned_function_t =
+ decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
+
+template<typename T, typename Float, typename String>
+using number_float_function_t = decltype(std::declval<T&>().number_float(
+ std::declval<Float>(), std::declval<const String&>()));
+
+template<typename T, typename String>
+using string_function_t =
+ decltype(std::declval<T&>().string(std::declval<String&>()));
+
+template<typename T, typename Binary>
+using binary_function_t =
+ decltype(std::declval<T&>().binary(std::declval<Binary&>()));
+
+template<typename T>
+using start_object_function_t =
+ decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
+
+template<typename T, typename String>
+using key_function_t =
+ decltype(std::declval<T&>().key(std::declval<String&>()));
+
+template<typename T>
+using end_object_function_t = decltype(std::declval<T&>().end_object());
+
+template<typename T>
+using start_array_function_t =
+ decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
+
+template<typename T>
+using end_array_function_t = decltype(std::declval<T&>().end_array());
+
+template<typename T, typename Exception>
+using parse_error_function_t = decltype(std::declval<T&>().parse_error(
+ std::declval<std::size_t>(), std::declval<const std::string&>(),
+ std::declval<const Exception&>()));
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax
+{
+ private:
+ static_assert(is_basic_json<BasicJsonType>::value,
+ "BasicJsonType must be of type basic_json<...>");
+
+ using number_integer_t = typename BasicJsonType::number_integer_t;
+ using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+ using number_float_t = typename BasicJsonType::number_float_t;
+ using string_t = typename BasicJsonType::string_t;
+ using binary_t = typename BasicJsonType::binary_t;
+ using exception_t = typename BasicJsonType::exception;
+
+ public:
+ static constexpr bool value =
+ is_detected_exact<bool, null_function_t, SAX>::value &&
+ is_detected_exact<bool, boolean_function_t, SAX>::value &&
+ is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
+ is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
+ is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
+ is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
+ is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
+ is_detected_exact<bool, start_object_function_t, SAX>::value &&
+ is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
+ is_detected_exact<bool, end_object_function_t, SAX>::value &&
+ is_detected_exact<bool, start_array_function_t, SAX>::value &&
+ is_detected_exact<bool, end_array_function_t, SAX>::value &&
+ is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
+};
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax_static_asserts
+{
+ private:
+ static_assert(is_basic_json<BasicJsonType>::value,
+ "BasicJsonType must be of type basic_json<...>");
+
+ using number_integer_t = typename BasicJsonType::number_integer_t;
+ using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+ using number_float_t = typename BasicJsonType::number_float_t;
+ using string_t = typename BasicJsonType::string_t;
+ using binary_t = typename BasicJsonType::binary_t;
+ using exception_t = typename BasicJsonType::exception;
+
+ public:
+ static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
+ "Missing/invalid function: bool null()");
+ static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+ "Missing/invalid function: bool boolean(bool)");
+ static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+ "Missing/invalid function: bool boolean(bool)");
+ static_assert(
+ is_detected_exact<bool, number_integer_function_t, SAX,
+ number_integer_t>::value,
+ "Missing/invalid function: bool number_integer(number_integer_t)");
+ static_assert(
+ is_detected_exact<bool, number_unsigned_function_t, SAX,
+ number_unsigned_t>::value,
+ "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
+ static_assert(is_detected_exact<bool, number_float_function_t, SAX,
+ number_float_t, string_t>::value,
+ "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
+ static_assert(
+ is_detected_exact<bool, string_function_t, SAX, string_t>::value,
+ "Missing/invalid function: bool string(string_t&)");
+ static_assert(
+ is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
+ "Missing/invalid function: bool binary(binary_t&)");
+ static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
+ "Missing/invalid function: bool start_object(std::size_t)");
+ static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
+ "Missing/invalid function: bool key(string_t&)");
+ static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
+ "Missing/invalid function: bool end_object()");
+ static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
+ "Missing/invalid function: bool start_array(std::size_t)");
+ static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
+ "Missing/invalid function: bool end_array()");
+ static_assert(
+ is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
+ "Missing/invalid function: bool parse_error(std::size_t, const "
+ "std::string&, const exception&)");
+};
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+
+/// how to treat CBOR tags
+enum class cbor_tag_handler_t
+{
+ error, ///< throw a parse_error exception in case of a tag
+ ignore ///< ignore tags
+};
+
+/*!
+@brief determine system byte order
+
+@return true if and only if system's byte order is little endian
+
+@note from https://stackoverflow.com/a/1001328/266378
+*/
+static inline bool little_endianess(int num = 1) noexcept
+{
+ return *reinterpret_cast<char*>(&num) == 1;
+}
+
+
+///////////////////
+// binary reader //
+///////////////////
+
+/*!
+@brief deserialization of CBOR, MessagePack, and UBJSON values
+*/
+template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
+class binary_reader
+{
+ using number_integer_t = typename BasicJsonType::number_integer_t;
+ using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+ using number_float_t = typename BasicJsonType::number_float_t;
+ using string_t = typename BasicJsonType::string_t;
+ using binary_t = typename BasicJsonType::binary_t;
+ using json_sax_t = SAX;
+ using char_type = typename InputAdapterType::char_type;
+ using char_int_type = typename std::char_traits<char_type>::int_type;
+
+ public:
+ /*!
+ @brief create a binary reader
+
+ @param[in] adapter input adapter to read from
+ */
+ explicit binary_reader(InputAdapterType&& adapter) : ia(std::move(adapter))
+ {
+ (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+ }
+
+ // make class move-only
+ binary_reader(const binary_reader&) = delete;
+ binary_reader(binary_reader&&) = default;
+ binary_reader& operator=(const binary_reader&) = delete;
+ binary_reader& operator=(binary_reader&&) = default;
+ ~binary_reader() = default;
+
+ /*!
+ @param[in] format the binary format to parse
+ @param[in] sax_ a SAX event processor
+ @param[in] strict whether to expect the input to be consumed completed
+ @param[in] tag_handler how to treat CBOR tags
+
+ @return
+ */
+ JSON_HEDLEY_NON_NULL(3)
+ bool sax_parse(const input_format_t format,
+ json_sax_t* sax_,
+ const bool strict = true,
+ const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+ {
+ sax = sax_;
+ bool result = false;
+
+ switch (format)
+ {
+ case input_format_t::bson:
+ result = parse_bson_internal();
+ break;
+
+ case input_format_t::cbor:
+ result = parse_cbor_internal(true, tag_handler);
+ break;
+
+ case input_format_t::msgpack:
+ result = parse_msgpack_internal();
+ break;
+
+ case input_format_t::ubjson:
+ result = parse_ubjson_internal();
+ break;
+
+ default: // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
+ }
+
+ // strict mode: next byte must be EOF
+ if (result && strict)
+ {
+ if (format == input_format_t::ubjson)
+ {
+ get_ignore_noop();
+ }
+ else
+ {
+ get();
+ }
+
+ if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
+ {
+ return sax->parse_error(chars_read, get_token_string(),
+ parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value")));
+ }
+ }
+
+ return result;
+ }
+
+ private:
+ //////////
+ // BSON //
+ //////////
+
+ /*!
+ @brief Reads in a BSON-object and passes it to the SAX-parser.
+ @return whether a valid BSON-value was passed to the SAX parser
+ */
+ bool parse_bson_internal()
+ {
+ std::int32_t document_size{};
+ get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
+ {
+ return false;
+ }
+
+ if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
+ {
+ return false;
+ }
+
+ return sax->end_object();
+ }
+
+ /*!
+ @brief Parses a C-style string from the BSON input.
+ @param[in, out] result A reference to the string variable where the read
+ string is to be stored.
+ @return `true` if the \x00-byte indicating the end of the string was
+ encountered before the EOF; false` indicates an unexpected EOF.
+ */
+ bool get_bson_cstr(string_t& result)
+ {
+ auto out = std::back_inserter(result);
+ while (true)
+ {
+ get();
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
+ {
+ return false;
+ }
+ if (current == 0x00)
+ {
+ return true;
+ }
+ *out++ = static_cast<typename string_t::value_type>(current);
+ }
+ }
+
+ /*!
+ @brief Parses a zero-terminated string of length @a len from the BSON
+ input.
+ @param[in] len The length (including the zero-byte at the end) of the
+ string to be read.
+ @param[in, out] result A reference to the string variable where the read
+ string is to be stored.
+ @tparam NumberType The type of the length @a len
+ @pre len >= 1
+ @return `true` if the string was successfully parsed
+ */
+ template<typename NumberType>
+ bool get_bson_string(const NumberType len, string_t& result)
+ {
+ if (JSON_HEDLEY_UNLIKELY(len < 1))
+ {
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string")));
+ }
+
+ return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
+ }
+
+ /*!
+ @brief Parses a byte array input of length @a len from the BSON input.
+ @param[in] len The length of the byte array to be read.
+ @param[in, out] result A reference to the binary variable where the read
+ array is to be stored.
+ @tparam NumberType The type of the length @a len
+ @pre len >= 0
+ @return `true` if the byte array was successfully parsed
+ */
+ template<typename NumberType>
+ bool get_bson_binary(const NumberType len, binary_t& result)
+ {
+ if (JSON_HEDLEY_UNLIKELY(len < 0))
+ {
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "byte array length cannot be negative, is " + std::to_string(len), "binary")));
+ }
+
+ // All BSON binary values have a subtype
+ std::uint8_t subtype{};
+ get_number<std::uint8_t>(input_format_t::bson, subtype);
+ result.set_subtype(subtype);
+
+ return get_binary(input_format_t::bson, len, result);
+ }
+
+ /*!
+ @brief Read a BSON document element of the given @a element_type.
+ @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
+ @param[in] element_type_parse_position The position in the input stream,
+ where the `element_type` was read.
+ @warning Not all BSON element types are supported yet. An unsupported
+ @a element_type will give rise to a parse_error.114:
+ Unsupported BSON record type 0x...
+ @return whether a valid BSON-object/array was passed to the SAX parser
+ */
+ bool parse_bson_element_internal(const char_int_type element_type,
+ const std::size_t element_type_parse_position)
+ {
+ switch (element_type)
+ {
+ case 0x01: // double
+ {
+ double number{};
+ return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+ }
+
+ case 0x02: // string
+ {
+ std::int32_t len{};
+ string_t value;
+ return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
+ }
+
+ case 0x03: // object
+ {
+ return parse_bson_internal();
+ }
+
+ case 0x04: // array
+ {
+ return parse_bson_array();
+ }
+
+ case 0x05: // binary
+ {
+ std::int32_t len{};
+ binary_t value;
+ return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
+ }
+
+ case 0x08: // boolean
+ {
+ return sax->boolean(get() != 0);
+ }
+
+ case 0x0A: // null
+ {
+ return sax->null();
+ }
+
+ case 0x10: // int32
+ {
+ std::int32_t value{};
+ return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+ }
+
+ case 0x12: // int64
+ {
+ std::int64_t value{};
+ return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+ }
+
+ default: // anything else not supported (yet)
+ {
+ std::array<char, 3> cr{{}};
+ (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type));
+ return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data())));
+ }
+ }
+ }
+
+ /*!
+ @brief Read a BSON element list (as specified in the BSON-spec)
+
+ The same binary layout is used for objects and arrays, hence it must be
+ indicated with the argument @a is_array which one is expected
+ (true --> array, false --> object).
+
+ @param[in] is_array Determines if the element list being read is to be
+ treated as an object (@a is_array == false), or as an
+ array (@a is_array == true).
+ @return whether a valid BSON-object/array was passed to the SAX parser
+ */
+ bool parse_bson_element_list(const bool is_array)
+ {
+ string_t key;
+
+ while (auto element_type = get())
+ {
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
+ {
+ return false;
+ }
+
+ const std::size_t element_type_parse_position = chars_read;
+ if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
+ {
+ return false;
+ }
+
+ if (!is_array && !sax->key(key))
+ {
+ return false;
+ }
+
+ if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
+ {
+ return false;
+ }
+
+ // get_bson_cstr only appends
+ key.clear();
+ }
+
+ return true;
+ }
+
+ /*!
+ @brief Reads an array from the BSON input and passes it to the SAX-parser.
+ @return whether a valid BSON-array was passed to the SAX parser
+ */
+ bool parse_bson_array()
+ {
+ std::int32_t document_size{};
+ get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
+ {
+ return false;
+ }
+
+ if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
+ {
+ return false;
+ }
+
+ return sax->end_array();
+ }
+
+ //////////
+ // CBOR //
+ //////////
+
+ /*!
+ @param[in] get_char whether a new character should be retrieved from the
+ input (true) or whether the last read character should
+ be considered instead (false)
+ @param[in] tag_handler how CBOR tags should be treated
+
+ @return whether a valid CBOR value was passed to the SAX parser
+ */
+ bool parse_cbor_internal(const bool get_char,
+ const cbor_tag_handler_t tag_handler)
+ {
+ switch (get_char ? get() : current)
+ {
+ // EOF
+ case std::char_traits<char_type>::eof():
+ return unexpect_eof(input_format_t::cbor, "value");
+
+ // Integer 0x00..0x17 (0..23)
+ case 0x00:
+ case 0x01:
+ case 0x02:
+ case 0x03:
+ case 0x04:
+ case 0x05:
+ case 0x06:
+ case 0x07:
+ case 0x08:
+ case 0x09:
+ case 0x0A:
+ case 0x0B:
+ case 0x0C:
+ case 0x0D:
+ case 0x0E:
+ case 0x0F:
+ case 0x10:
+ case 0x11:
+ case 0x12:
+ case 0x13:
+ case 0x14:
+ case 0x15:
+ case 0x16:
+ case 0x17:
+ return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+ case 0x18: // Unsigned integer (one-byte uint8_t follows)
+ {
+ std::uint8_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+ }
+
+ case 0x19: // Unsigned integer (two-byte uint16_t follows)
+ {
+ std::uint16_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+ }
+
+ case 0x1A: // Unsigned integer (four-byte uint32_t follows)
+ {
+ std::uint32_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+ }
+
+ case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
+ {
+ std::uint64_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+ }
+
+ // Negative integer -1-0x00..-1-0x17 (-1..-24)
+ case 0x20:
+ case 0x21:
+ case 0x22:
+ case 0x23:
+ case 0x24:
+ case 0x25:
+ case 0x26:
+ case 0x27:
+ case 0x28:
+ case 0x29:
+ case 0x2A:
+ case 0x2B:
+ case 0x2C:
+ case 0x2D:
+ case 0x2E:
+ case 0x2F:
+ case 0x30:
+ case 0x31:
+ case 0x32:
+ case 0x33:
+ case 0x34:
+ case 0x35:
+ case 0x36:
+ case 0x37:
+ return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
+
+ case 0x38: // Negative integer (one-byte uint8_t follows)
+ {
+ std::uint8_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+ }
+
+ case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
+ {
+ std::uint16_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+ }
+
+ case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
+ {
+ std::uint32_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+ }
+
+ case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
+ {
+ std::uint64_t number{};
+ return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
+ - static_cast<number_integer_t>(number));
+ }
+
+ // Binary data (0x00..0x17 bytes follow)
+ case 0x40:
+ case 0x41:
+ case 0x42:
+ case 0x43:
+ case 0x44:
+ case 0x45:
+ case 0x46:
+ case 0x47:
+ case 0x48:
+ case 0x49:
+ case 0x4A:
+ case 0x4B:
+ case 0x4C:
+ case 0x4D:
+ case 0x4E:
+ case 0x4F:
+ case 0x50:
+ case 0x51:
+ case 0x52:
+ case 0x53:
+ case 0x54:
+ case 0x55:
+ case 0x56:
+ case 0x57:
+ case 0x58: // Binary data (one-byte uint8_t for n follows)
+ case 0x59: // Binary data (two-byte uint16_t for n follow)
+ case 0x5A: // Binary data (four-byte uint32_t for n follow)
+ case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+ case 0x5F: // Binary data (indefinite length)
+ {
+ binary_t b;
+ return get_cbor_binary(b) && sax->binary(b);
+ }
+
+ // UTF-8 string (0x00..0x17 bytes follow)
+ case 0x60:
+ case 0x61:
+ case 0x62:
+ case 0x63:
+ case 0x64:
+ case 0x65:
+ case 0x66:
+ case 0x67:
+ case 0x68:
+ case 0x69:
+ case 0x6A:
+ case 0x6B:
+ case 0x6C:
+ case 0x6D:
+ case 0x6E:
+ case 0x6F:
+ case 0x70:
+ case 0x71:
+ case 0x72:
+ case 0x73:
+ case 0x74:
+ case 0x75:
+ case 0x76:
+ case 0x77:
+ case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+ case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+ case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+ case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+ case 0x7F: // UTF-8 string (indefinite length)
+ {
+ string_t s;
+ return get_cbor_string(s) && sax->string(s);
+ }
+
+ // array (0x00..0x17 data items follow)
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+ case 0x98: // array (one-byte uint8_t for n follows)
+ {
+ std::uint8_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+ }
+
+ case 0x99: // array (two-byte uint16_t for n follow)
+ {
+ std::uint16_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+ }
+
+ case 0x9A: // array (four-byte uint32_t for n follow)
+ {
+ std::uint32_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+ }
+
+ case 0x9B: // array (eight-byte uint64_t for n follow)
+ {
+ std::uint64_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+ }
+
+ case 0x9F: // array (indefinite length)
+ return get_cbor_array(std::size_t(-1), tag_handler);
+
+ // map (0x00..0x17 pairs of data items follow)
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+ case 0xB8: // map (one-byte uint8_t for n follows)
+ {
+ std::uint8_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+ }
+
+ case 0xB9: // map (two-byte uint16_t for n follow)
+ {
+ std::uint16_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+ }
+
+ case 0xBA: // map (four-byte uint32_t for n follow)
+ {
+ std::uint32_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+ }
+
+ case 0xBB: // map (eight-byte uint64_t for n follow)
+ {
+ std::uint64_t len{};
+ return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+ }
+
+ case 0xBF: // map (indefinite length)
+ return get_cbor_object(std::size_t(-1), tag_handler);
+
+ case 0xC6: // tagged item
+ case 0xC7:
+ case 0xC8:
+ case 0xC9:
+ case 0xCA:
+ case 0xCB:
+ case 0xCC:
+ case 0xCD:
+ case 0xCE:
+ case 0xCF:
+ case 0xD0:
+ case 0xD1:
+ case 0xD2:
+ case 0xD3:
+ case 0xD4:
+ case 0xD8: // tagged item (1 bytes follow)
+ case 0xD9: // tagged item (2 bytes follow)
+ case 0xDA: // tagged item (4 bytes follow)
+ case 0xDB: // tagged item (8 bytes follow)
+ {
+ switch (tag_handler)
+ {
+ case cbor_tag_handler_t::error:
+ {
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
+ }
+
+ case cbor_tag_handler_t::ignore:
+ {
+ switch (current)
+ {
+ case 0xD8:
+ {
+ std::uint8_t len{};
+ get_number(input_format_t::cbor, len);
+ break;
+ }
+ case 0xD9:
+ {
+ std::uint16_t len{};
+ get_number(input_format_t::cbor, len);
+ break;
+ }
+ case 0xDA:
+ {
+ std::uint32_t len{};
+ get_number(input_format_t::cbor, len);
+ break;
+ }
+ case 0xDB:
+ {
+ std::uint64_t len{};
+ get_number(input_format_t::cbor, len);
+ break;
+ }
+ default:
+ break;
+ }
+ return parse_cbor_internal(true, tag_handler);
+ }
+
+ default: // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
+ }
+ }
+
+ case 0xF4: // false
+ return sax->boolean(false);
+
+ case 0xF5: // true
+ return sax->boolean(true);
+
+ case 0xF6: // null
+ return sax->null();
+
+ case 0xF9: // Half-Precision Float (two-byte IEEE 754)
+ {
+ const auto byte1_raw = get();
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+ {
+ return false;
+ }
+ const auto byte2_raw = get();
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+ {
+ return false;
+ }
+
+ const auto byte1 = static_cast<unsigned char>(byte1_raw);
+ const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+ // code from RFC 7049, Appendix D, Figure 3:
+ // As half-precision floating-point numbers were only added
+ // to IEEE 754 in 2008, today's programming platforms often
+ // still only have limited support for them. It is very
+ // easy to include at least decoding support for them even
+ // without such support. An example of a small decoder for
+ // half-precision floating-point numbers in the C language
+ // is shown in Fig. 3.
+ const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
+ const double val = [&half]
+ {
+ const int exp = (half >> 10u) & 0x1Fu;
+ const unsigned int mant = half & 0x3FFu;
+ JSON_ASSERT(0 <= exp&& exp <= 32);
+ JSON_ASSERT(mant <= 1024);
+ switch (exp)
+ {
+ case 0:
+ return std::ldexp(mant, -24);
+ case 31:
+ return (mant == 0)
+ ? std::numeric_limits<double>::infinity()
+ : std::numeric_limits<double>::quiet_NaN();
+ default:
+ return std::ldexp(mant + 1024, exp - 25);
+ }
+ }();
+ return sax->number_float((half & 0x8000u) != 0
+ ? static_cast<number_float_t>(-val)
+ : static_cast<number_float_t>(val), "");
+ }
+
+ case 0xFA: // Single-Precision Float (four-byte IEEE 754)
+ {
+ float number{};
+ return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+ }
+
+ case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
+ {
+ double number{};
+ return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+ }
+
+ default: // anything else (0xFF is handled inside the other types)
+ {
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
+ }
+ }
+ }
+
+ /*!
+ @brief reads a CBOR string
+
+ This function first reads starting bytes to determine the expected
+ string length and then copies this number of bytes into a string.
+ Additionally, CBOR's strings with indefinite lengths are supported.
+
+ @param[out] result created string
+
+ @return whether string creation completed
+ */
+ bool get_cbor_string(string_t& result)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
+ {
+ return false;
+ }
+
+ switch (current)
+ {
+ // UTF-8 string (0x00..0x17 bytes follow)
+ case 0x60:
+ case 0x61:
+ case 0x62:
+ case 0x63:
+ case 0x64:
+ case 0x65:
+ case 0x66:
+ case 0x67:
+ case 0x68:
+ case 0x69:
+ case 0x6A:
+ case 0x6B:
+ case 0x6C:
+ case 0x6D:
+ case 0x6E:
+ case 0x6F:
+ case 0x70:
+ case 0x71:
+ case 0x72:
+ case 0x73:
+ case 0x74:
+ case 0x75:
+ case 0x76:
+ case 0x77:
+ {
+ return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+ }
+
+ case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+ {
+ std::uint8_t len{};
+ return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+ }
+
+ case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+ {
+ std::uint16_t len{};
+ return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+ }
+
+ case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+ {
+ std::uint32_t len{};
+ return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+ }
+
+ case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+ {
+ std::uint64_t len{};
+ return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+ }
+
+ case 0x7F: // UTF-8 string (indefinite length)
+ {
+ while (get() != 0xFF)
+ {
+ string_t chunk;
+ if (!get_cbor_string(chunk))
+ {
+ return false;
+ }
+ result.append(chunk);
+ }
+ return true;
+ }
+
+ default:
+ {
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string")));
+ }
+ }
+ }
+
+ /*!
+ @brief reads a CBOR byte array
+
+ This function first reads starting bytes to determine the expected
+ byte array length and then copies this number of bytes into the byte array.
+ Additionally, CBOR's byte arrays with indefinite lengths are supported.
+
+ @param[out] result created byte array
+
+ @return whether byte array creation completed
+ */
+ bool get_cbor_binary(binary_t& result)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
+ {
+ return false;
+ }
+
+ switch (current)
+ {
+ // Binary data (0x00..0x17 bytes follow)
+ case 0x40:
+ case 0x41:
+ case 0x42:
+ case 0x43:
+ case 0x44:
+ case 0x45:
+ case 0x46:
+ case 0x47:
+ case 0x48:
+ case 0x49:
+ case 0x4A:
+ case 0x4B:
+ case 0x4C:
+ case 0x4D:
+ case 0x4E:
+ case 0x4F:
+ case 0x50:
+ case 0x51:
+ case 0x52:
+ case 0x53:
+ case 0x54:
+ case 0x55:
+ case 0x56:
+ case 0x57:
+ {
+ return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+ }
+
+ case 0x58: // Binary data (one-byte uint8_t for n follows)
+ {
+ std::uint8_t len{};
+ return get_number(input_format_t::cbor, len) &&
+ get_binary(input_format_t::cbor, len, result);
+ }
+
+ case 0x59: // Binary data (two-byte uint16_t for n follow)
+ {
+ std::uint16_t len{};
+ return get_number(input_format_t::cbor, len) &&
+ get_binary(input_format_t::cbor, len, result);
+ }
+
+ case 0x5A: // Binary data (four-byte uint32_t for n follow)
+ {
+ std::uint32_t len{};
+ return get_number(input_format_t::cbor, len) &&
+ get_binary(input_format_t::cbor, len, result);
+ }
+
+ case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+ {
+ std::uint64_t len{};
+ return get_number(input_format_t::cbor, len) &&
+ get_binary(input_format_t::cbor, len, result);
+ }
+
+ case 0x5F: // Binary data (indefinite length)
+ {
+ while (get() != 0xFF)
+ {
+ binary_t chunk;
+ if (!get_cbor_binary(chunk))
+ {
+ return false;
+ }
+ result.insert(result.end(), chunk.begin(), chunk.end());
+ }
+ return true;
+ }
+
+ default:
+ {
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x" + last_token, "binary")));
+ }
+ }
+ }
+
+ /*!
+ @param[in] len the length of the array or std::size_t(-1) for an
+ array of indefinite size
+ @param[in] tag_handler how CBOR tags should be treated
+ @return whether array creation completed
+ */
+ bool get_cbor_array(const std::size_t len,
+ const cbor_tag_handler_t tag_handler)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+ {
+ return false;
+ }
+
+ if (len != std::size_t(-1))
+ {
+ for (std::size_t i = 0; i < len; ++i)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+ {
+ return false;
+ }
+ }
+ }
+ else
+ {
+ while (get() != 0xFF)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
+ {
+ return false;
+ }
+ }
+ }
+
+ return sax->end_array();
+ }
+
+ /*!
+ @param[in] len the length of the object or std::size_t(-1) for an
+ object of indefinite size
+ @param[in] tag_handler how CBOR tags should be treated
+ @return whether object creation completed
+ */
+ bool get_cbor_object(const std::size_t len,
+ const cbor_tag_handler_t tag_handler)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+ {
+ return false;
+ }
+
+ string_t key;
+ if (len != std::size_t(-1))
+ {
+ for (std::size_t i = 0; i < len; ++i)
+ {
+ get();
+ if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+ {
+ return false;
+ }
+
+ if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+ {
+ return false;
+ }
+ key.clear();
+ }
+ }
+ else
+ {
+ while (get() != 0xFF)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+ {
+ return false;
+ }
+
+ if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+ {
+ return false;
+ }
+ key.clear();
+ }
+ }
+
+ return sax->end_object();
+ }
+
+ /////////////
+ // MsgPack //
+ /////////////
+
+ /*!
+ @return whether a valid MessagePack value was passed to the SAX parser
+ */
+ bool parse_msgpack_internal()
+ {
+ switch (get())
+ {
+ // EOF
+ case std::char_traits<char_type>::eof():
+ return unexpect_eof(input_format_t::msgpack, "value");
+
+ // positive fixint
+ case 0x00:
+ case 0x01:
+ case 0x02:
+ case 0x03:
+ case 0x04:
+ case 0x05:
+ case 0x06:
+ case 0x07:
+ case 0x08:
+ case 0x09:
+ case 0x0A:
+ case 0x0B:
+ case 0x0C:
+ case 0x0D:
+ case 0x0E:
+ case 0x0F:
+ case 0x10:
+ case 0x11:
+ case 0x12:
+ case 0x13:
+ case 0x14:
+ case 0x15:
+ case 0x16:
+ case 0x17:
+ case 0x18:
+ case 0x19:
+ case 0x1A:
+ case 0x1B:
+ case 0x1C:
+ case 0x1D:
+ case 0x1E:
+ case 0x1F:
+ case 0x20:
+ case 0x21:
+ case 0x22:
+ case 0x23:
+ case 0x24:
+ case 0x25:
+ case 0x26:
+ case 0x27:
+ case 0x28:
+ case 0x29:
+ case 0x2A:
+ case 0x2B:
+ case 0x2C:
+ case 0x2D:
+ case 0x2E:
+ case 0x2F:
+ case 0x30:
+ case 0x31:
+ case 0x32:
+ case 0x33:
+ case 0x34:
+ case 0x35:
+ case 0x36:
+ case 0x37:
+ case 0x38:
+ case 0x39:
+ case 0x3A:
+ case 0x3B:
+ case 0x3C:
+ case 0x3D:
+ case 0x3E:
+ case 0x3F:
+ case 0x40:
+ case 0x41:
+ case 0x42:
+ case 0x43:
+ case 0x44:
+ case 0x45:
+ case 0x46:
+ case 0x47:
+ case 0x48:
+ case 0x49:
+ case 0x4A:
+ case 0x4B:
+ case 0x4C:
+ case 0x4D:
+ case 0x4E:
+ case 0x4F:
+ case 0x50:
+ case 0x51:
+ case 0x52:
+ case 0x53:
+ case 0x54:
+ case 0x55:
+ case 0x56:
+ case 0x57:
+ case 0x58:
+ case 0x59:
+ case 0x5A:
+ case 0x5B:
+ case 0x5C:
+ case 0x5D:
+ case 0x5E:
+ case 0x5F:
+ case 0x60:
+ case 0x61:
+ case 0x62:
+ case 0x63:
+ case 0x64:
+ case 0x65:
+ case 0x66:
+ case 0x67:
+ case 0x68:
+ case 0x69:
+ case 0x6A:
+ case 0x6B:
+ case 0x6C:
+ case 0x6D:
+ case 0x6E:
+ case 0x6F:
+ case 0x70:
+ case 0x71:
+ case 0x72:
+ case 0x73:
+ case 0x74:
+ case 0x75:
+ case 0x76:
+ case 0x77:
+ case 0x78:
+ case 0x79:
+ case 0x7A:
+ case 0x7B:
+ case 0x7C:
+ case 0x7D:
+ case 0x7E:
+ case 0x7F:
+ return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+ // fixmap
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x85:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x8A:
+ case 0x8B:
+ case 0x8C:
+ case 0x8D:
+ case 0x8E:
+ case 0x8F:
+ return get_msgpack_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+ // fixarray
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9A:
+ case 0x9B:
+ case 0x9C:
+ case 0x9D:
+ case 0x9E:
+ case 0x9F:
+ return get_msgpack_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+ // fixstr
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF:
+ case 0xD9: // str 8
+ case 0xDA: // str 16
+ case 0xDB: // str 32
+ {
+ string_t s;
+ return get_msgpack_string(s) && sax->string(s);
+ }
+
+ case 0xC0: // nil
+ return sax->null();
+
+ case 0xC2: // false
+ return sax->boolean(false);
+
+ case 0xC3: // true
+ return sax->boolean(true);
+
+ case 0xC4: // bin 8
+ case 0xC5: // bin 16
+ case 0xC6: // bin 32
+ case 0xC7: // ext 8
+ case 0xC8: // ext 16
+ case 0xC9: // ext 32
+ case 0xD4: // fixext 1
+ case 0xD5: // fixext 2
+ case 0xD6: // fixext 4
+ case 0xD7: // fixext 8
+ case 0xD8: // fixext 16
+ {
+ binary_t b;
+ return get_msgpack_binary(b) && sax->binary(b);
+ }
+
+ case 0xCA: // float 32
+ {
+ float number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+ }
+
+ case 0xCB: // float 64
+ {
+ double number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+ }
+
+ case 0xCC: // uint 8
+ {
+ std::uint8_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+ }
+
+ case 0xCD: // uint 16
+ {
+ std::uint16_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+ }
+
+ case 0xCE: // uint 32
+ {
+ std::uint32_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+ }
+
+ case 0xCF: // uint 64
+ {
+ std::uint64_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+ }
+
+ case 0xD0: // int 8
+ {
+ std::int8_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+ }
+
+ case 0xD1: // int 16
+ {
+ std::int16_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+ }
+
+ case 0xD2: // int 32
+ {
+ std::int32_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+ }
+
+ case 0xD3: // int 64
+ {
+ std::int64_t number{};
+ return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+ }
+
+ case 0xDC: // array 16
+ {
+ std::uint16_t len{};
+ return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+ }
+
+ case 0xDD: // array 32
+ {
+ std::uint32_t len{};
+ return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+ }
+
+ case 0xDE: // map 16
+ {
+ std::uint16_t len{};
+ return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+ }
+
+ case 0xDF: // map 32
+ {
+ std::uint32_t len{};
+ return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+ }
+
+ // negative fixint
+ case 0xE0:
+ case 0xE1:
+ case 0xE2:
+ case 0xE3:
+ case 0xE4:
+ case 0xE5:
+ case 0xE6:
+ case 0xE7:
+ case 0xE8:
+ case 0xE9:
+ case 0xEA:
+ case 0xEB:
+ case 0xEC:
+ case 0xED:
+ case 0xEE:
+ case 0xEF:
+ case 0xF0:
+ case 0xF1:
+ case 0xF2:
+ case 0xF3:
+ case 0xF4:
+ case 0xF5:
+ case 0xF6:
+ case 0xF7:
+ case 0xF8:
+ case 0xF9:
+ case 0xFA:
+ case 0xFB:
+ case 0xFC:
+ case 0xFD:
+ case 0xFE:
+ case 0xFF:
+ return sax->number_integer(static_cast<std::int8_t>(current));
+
+ default: // anything else
+ {
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack, "invalid byte: 0x" + last_token, "value")));
+ }
+ }
+ }
+
+ /*!
+ @brief reads a MessagePack string
+
+ This function first reads starting bytes to determine the expected
+ string length and then copies this number of bytes into a string.
+
+ @param[out] result created string
+
+ @return whether string creation completed
+ */
+ bool get_msgpack_string(string_t& result)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
+ {
+ return false;
+ }
+
+ switch (current)
+ {
+ // fixstr
+ case 0xA0:
+ case 0xA1:
+ case 0xA2:
+ case 0xA3:
+ case 0xA4:
+ case 0xA5:
+ case 0xA6:
+ case 0xA7:
+ case 0xA8:
+ case 0xA9:
+ case 0xAA:
+ case 0xAB:
+ case 0xAC:
+ case 0xAD:
+ case 0xAE:
+ case 0xAF:
+ case 0xB0:
+ case 0xB1:
+ case 0xB2:
+ case 0xB3:
+ case 0xB4:
+ case 0xB5:
+ case 0xB6:
+ case 0xB7:
+ case 0xB8:
+ case 0xB9:
+ case 0xBA:
+ case 0xBB:
+ case 0xBC:
+ case 0xBD:
+ case 0xBE:
+ case 0xBF:
+ {
+ return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
+ }
+
+ case 0xD9: // str 8
+ {
+ std::uint8_t len{};
+ return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+ }
+
+ case 0xDA: // str 16
+ {
+ std::uint16_t len{};
+ return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+ }
+
+ case 0xDB: // str 32
+ {
+ std::uint32_t len{};
+ return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+ }
+
+ default:
+ {
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string")));
+ }
+ }
+ }
+
+ /*!
+ @brief reads a MessagePack byte array
+
+ This function first reads starting bytes to determine the expected
+ byte array length and then copies this number of bytes into a byte array.
+
+ @param[out] result created byte array
+
+ @return whether byte array creation completed
+ */
+ bool get_msgpack_binary(binary_t& result)
+ {
+ // helper function to set the subtype
+ auto assign_and_return_true = [&result](std::int8_t subtype)
+ {
+ result.set_subtype(static_cast<std::uint8_t>(subtype));
+ return true;
+ };
+
+ switch (current)
+ {
+ case 0xC4: // bin 8
+ {
+ std::uint8_t len{};
+ return get_number(input_format_t::msgpack, len) &&
+ get_binary(input_format_t::msgpack, len, result);
+ }
+
+ case 0xC5: // bin 16
+ {
+ std::uint16_t len{};
+ return get_number(input_format_t::msgpack, len) &&
+ get_binary(input_format_t::msgpack, len, result);
+ }
+
+ case 0xC6: // bin 32
+ {
+ std::uint32_t len{};
+ return get_number(input_format_t::msgpack, len) &&
+ get_binary(input_format_t::msgpack, len, result);
+ }
+
+ case 0xC7: // ext 8
+ {
+ std::uint8_t len{};
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, len) &&
+ get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, len, result) &&
+ assign_and_return_true(subtype);
+ }
+
+ case 0xC8: // ext 16
+ {
+ std::uint16_t len{};
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, len) &&
+ get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, len, result) &&
+ assign_and_return_true(subtype);
+ }
+
+ case 0xC9: // ext 32
+ {
+ std::uint32_t len{};
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, len) &&
+ get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, len, result) &&
+ assign_and_return_true(subtype);
+ }
+
+ case 0xD4: // fixext 1
+ {
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, 1, result) &&
+ assign_and_return_true(subtype);
+ }
+
+ case 0xD5: // fixext 2
+ {
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, 2, result) &&
+ assign_and_return_true(subtype);
+ }
+
+ case 0xD6: // fixext 4
+ {
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, 4, result) &&
+ assign_and_return_true(subtype);
+ }
+
+ case 0xD7: // fixext 8
+ {
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, 8, result) &&
+ assign_and_return_true(subtype);
+ }
+
+ case 0xD8: // fixext 16
+ {
+ std::int8_t subtype{};
+ return get_number(input_format_t::msgpack, subtype) &&
+ get_binary(input_format_t::msgpack, 16, result) &&
+ assign_and_return_true(subtype);
+ }
+
+ default: // LCOV_EXCL_LINE
+ return false; // LCOV_EXCL_LINE
+ }
+ }
+
+ /*!
+ @param[in] len the length of the array
+ @return whether array creation completed
+ */
+ bool get_msgpack_array(const std::size_t len)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+ {
+ return false;
+ }
+
+ for (std::size_t i = 0; i < len; ++i)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+ {
+ return false;
+ }
+ }
+
+ return sax->end_array();
+ }
+
+ /*!
+ @param[in] len the length of the object
+ @return whether object creation completed
+ */
+ bool get_msgpack_object(const std::size_t len)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+ {
+ return false;
+ }
+
+ string_t key;
+ for (std::size_t i = 0; i < len; ++i)
+ {
+ get();
+ if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
+ {
+ return false;
+ }
+
+ if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+ {
+ return false;
+ }
+ key.clear();
+ }
+
+ return sax->end_object();
+ }
+
+ ////////////
+ // UBJSON //
+ ////////////
+
+ /*!
+ @param[in] get_char whether a new character should be retrieved from the
+ input (true, default) or whether the last read
+ character should be considered instead
+
+ @return whether a valid UBJSON value was passed to the SAX parser
+ */
+ bool parse_ubjson_internal(const bool get_char = true)
+ {
+ return get_ubjson_value(get_char ? get_ignore_noop() : current);
+ }
+
+ /*!
+ @brief reads a UBJSON string
+
+ This function is either called after reading the 'S' byte explicitly
+ indicating a string, or in case of an object key where the 'S' byte can be
+ left out.
+
+ @param[out] result created string
+ @param[in] get_char whether a new character should be retrieved from the
+ input (true, default) or whether the last read
+ character should be considered instead
+
+ @return whether string creation completed
+ */
+ bool get_ubjson_string(string_t& result, const bool get_char = true)
+ {
+ if (get_char)
+ {
+ get(); // TODO(niels): may we ignore N here?
+ }
+
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
+ {
+ return false;
+ }
+
+ switch (current)
+ {
+ case 'U':
+ {
+ std::uint8_t len{};
+ return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+ }
+
+ case 'i':
+ {
+ std::int8_t len{};
+ return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+ }
+
+ case 'I':
+ {
+ std::int16_t len{};
+ return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+ }
+
+ case 'l':
+ {
+ std::int32_t len{};
+ return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+ }
+
+ case 'L':
+ {
+ std::int64_t len{};
+ return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+ }
+
+ default:
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string")));
+ }
+ }
+
+ /*!
+ @param[out] result determined size
+ @return whether size determination completed
+ */
+ bool get_ubjson_size_value(std::size_t& result)
+ {
+ switch (get_ignore_noop())
+ {
+ case 'U':
+ {
+ std::uint8_t number{};
+ if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+ {
+ return false;
+ }
+ result = static_cast<std::size_t>(number);
+ return true;
+ }
+
+ case 'i':
+ {
+ std::int8_t number{};
+ if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+ {
+ return false;
+ }
+ result = static_cast<std::size_t>(number);
+ return true;
+ }
+
+ case 'I':
+ {
+ std::int16_t number{};
+ if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+ {
+ return false;
+ }
+ result = static_cast<std::size_t>(number);
+ return true;
+ }
+
+ case 'l':
+ {
+ std::int32_t number{};
+ if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+ {
+ return false;
+ }
+ result = static_cast<std::size_t>(number);
+ return true;
+ }
+
+ case 'L':
+ {
+ std::int64_t number{};
+ if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+ {
+ return false;
+ }
+ result = static_cast<std::size_t>(number);
+ return true;
+ }
+
+ default:
+ {
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size")));
+ }
+ }
+ }
+
+ /*!
+ @brief determine the type and size for a container
+
+ In the optimized UBJSON format, a type and a size can be provided to allow
+ for a more compact representation.
+
+ @param[out] result pair of the size and the type
+
+ @return whether pair creation completed
+ */
+ bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
+ {
+ result.first = string_t::npos; // size
+ result.second = 0; // type
+
+ get_ignore_noop();
+
+ if (current == '$')
+ {
+ result.second = get(); // must not ignore 'N', because 'N' maybe the type
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "type")))
+ {
+ return false;
+ }
+
+ get_ignore_noop();
+ if (JSON_HEDLEY_UNLIKELY(current != '#'))
+ {
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
+ {
+ return false;
+ }
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size")));
+ }
+
+ return get_ubjson_size_value(result.first);
+ }
+
+ if (current == '#')
+ {
+ return get_ubjson_size_value(result.first);
+ }
+
+ return true;
+ }
+
+ /*!
+ @param prefix the previously read or set type prefix
+ @return whether value creation completed
+ */
+ bool get_ubjson_value(const char_int_type prefix)
+ {
+ switch (prefix)
+ {
+ case std::char_traits<char_type>::eof(): // EOF
+ return unexpect_eof(input_format_t::ubjson, "value");
+
+ case 'T': // true
+ return sax->boolean(true);
+ case 'F': // false
+ return sax->boolean(false);
+
+ case 'Z': // null
+ return sax->null();
+
+ case 'U':
+ {
+ std::uint8_t number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
+ }
+
+ case 'i':
+ {
+ std::int8_t number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+ }
+
+ case 'I':
+ {
+ std::int16_t number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+ }
+
+ case 'l':
+ {
+ std::int32_t number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+ }
+
+ case 'L':
+ {
+ std::int64_t number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+ }
+
+ case 'd':
+ {
+ float number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+ }
+
+ case 'D':
+ {
+ double number{};
+ return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+ }
+
+ case 'H':
+ {
+ return get_ubjson_high_precision_number();
+ }
+
+ case 'C': // char
+ {
+ get();
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "char")))
+ {
+ return false;
+ }
+ if (JSON_HEDLEY_UNLIKELY(current > 127))
+ {
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char")));
+ }
+ string_t s(1, static_cast<typename string_t::value_type>(current));
+ return sax->string(s);
+ }
+
+ case 'S': // string
+ {
+ string_t s;
+ return get_ubjson_string(s) && sax->string(s);
+ }
+
+ case '[': // array
+ return get_ubjson_array();
+
+ case '{': // object
+ return get_ubjson_object();
+
+ default: // anything else
+ {
+ auto last_token = get_token_string();
+ return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "invalid byte: 0x" + last_token, "value")));
+ }
+ }
+ }
+
+ /*!
+ @return whether array creation completed
+ */
+ bool get_ubjson_array()
+ {
+ std::pair<std::size_t, char_int_type> size_and_type;
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+ {
+ return false;
+ }
+
+ if (size_and_type.first != string_t::npos)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
+ {
+ return false;
+ }
+
+ if (size_and_type.second != 0)
+ {
+ if (size_and_type.second != 'N')
+ {
+ for (std::size_t i = 0; i < size_and_type.first; ++i)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+ {
+ return false;
+ }
+ }
+ }
+ }
+ else
+ {
+ for (std::size_t i = 0; i < size_and_type.first; ++i)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+ {
+ return false;
+ }
+ }
+ }
+ }
+ else
+ {
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
+ {
+ return false;
+ }
+
+ while (current != ']')
+ {
+ if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
+ {
+ return false;
+ }
+ get_ignore_noop();
+ }
+ }
+
+ return sax->end_array();
+ }
+
+ /*!
+ @return whether object creation completed
+ */
+ bool get_ubjson_object()
+ {
+ std::pair<std::size_t, char_int_type> size_and_type;
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+ {
+ return false;
+ }
+
+ string_t key;
+ if (size_and_type.first != string_t::npos)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
+ {
+ return false;
+ }
+
+ if (size_and_type.second != 0)
+ {
+ for (std::size_t i = 0; i < size_and_type.first; ++i)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+ {
+ return false;
+ }
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+ {
+ return false;
+ }
+ key.clear();
+ }
+ }
+ else
+ {
+ for (std::size_t i = 0; i < size_and_type.first; ++i)
+ {
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+ {
+ return false;
+ }
+ if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+ {
+ return false;
+ }
+ key.clear();
+ }
+ }
+ }
+ else
+ {
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
+ {
+ return false;
+ }
+
+ while (current != '}')
+ {
+ if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
+ {
+ return false;
+ }
+ if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+ {
+ return false;
+ }
+ get_ignore_noop();
+ key.clear();
+ }
+ }
+
+ return sax->end_object();
+ }
+
+ // Note, no reader for UBJSON binary types is implemented because they do
+ // not exist
+
+ bool get_ubjson_high_precision_number()
+ {
+ // get size of following number string
+ std::size_t size{};
+ auto res = get_ubjson_size_value(size);
+ if (JSON_HEDLEY_UNLIKELY(!res))
+ {
+ return res;
+ }
+
+ // get number string
+ std::vector<char> number_vector;
+ for (std::size_t i = 0; i < size; ++i)
+ {
+ get();
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "number")))
+ {
+ return false;
+ }
+ number_vector.push_back(static_cast<char>(current));
+ }
+
+ // parse number string
+ auto number_ia = detail::input_adapter(std::forward<decltype(number_vector)>(number_vector));
+ auto number_lexer = detail::lexer<BasicJsonType, decltype(number_ia)>(std::move(number_ia), false);
+ const auto result_number = number_lexer.scan();
+ const auto number_string = number_lexer.get_token_string();
+ const auto result_remainder = number_lexer.scan();
+
+ using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
+
+ if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
+ {
+ return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
+ }
+
+ switch (result_number)
+ {
+ case token_type::value_integer:
+ return sax->number_integer(number_lexer.get_number_integer());
+ case token_type::value_unsigned:
+ return sax->number_unsigned(number_lexer.get_number_unsigned());
+ case token_type::value_float:
+ return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
+ default:
+ return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
+ }
+ }
+
+ ///////////////////////
+ // Utility functions //
+ ///////////////////////
+
+ /*!
+ @brief get next character from the input
+
+ This function provides the interface to the used input adapter. It does
+ not throw in case the input reached EOF, but returns a -'ve valued
+ `std::char_traits<char_type>::eof()` in that case.
+
+ @return character read from the input
+ */
+ char_int_type get()
+ {
+ ++chars_read;
+ return current = ia.get_character();
+ }
+
+ /*!
+ @return character read from the input after ignoring all 'N' entries
+ */
+ char_int_type get_ignore_noop()
+ {
+ do
+ {
+ get();
+ }
+ while (current == 'N');
+
+ return current;
+ }
+
+ /*
+ @brief read a number from the input
+
+ @tparam NumberType the type of the number
+ @param[in] format the current format (for diagnostics)
+ @param[out] result number of type @a NumberType
+
+ @return whether conversion completed
+
+ @note This function needs to respect the system's endianess, because
+ bytes in CBOR, MessagePack, and UBJSON are stored in network order
+ (big endian) and therefore need reordering on little endian systems.
+ */
+ template<typename NumberType, bool InputIsLittleEndian = false>
+ bool get_number(const input_format_t format, NumberType& result)
+ {
+ // step 1: read input into array with system's byte order
+ std::array<std::uint8_t, sizeof(NumberType)> vec;
+ for (std::size_t i = 0; i < sizeof(NumberType); ++i)
+ {
+ get();
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
+ {
+ return false;
+ }
+
+ // reverse byte order prior to conversion if necessary
+ if (is_little_endian != InputIsLittleEndian)
+ {
+ vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
+ }
+ else
+ {
+ vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
+ }
+ }
+
+ // step 2: convert array into number of type T and return
+ std::memcpy(&result, vec.data(), sizeof(NumberType));
+ return true;
+ }
+
+ /*!
+ @brief create a string by reading characters from the input
+
+ @tparam NumberType the type of the number
+ @param[in] format the current format (for diagnostics)
+ @param[in] len number of characters to read
+ @param[out] result string created by reading @a len bytes
+
+ @return whether string creation completed
+
+ @note We can not reserve @a len bytes for the result, because @a len
+ may be too large. Usually, @ref unexpect_eof() detects the end of
+ the input before we run out of string memory.
+ */
+ template<typename NumberType>
+ bool get_string(const input_format_t format,
+ const NumberType len,
+ string_t& result)
+ {
+ bool success = true;
+ for (NumberType i = 0; i < len; i++)
+ {
+ get();
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
+ {
+ success = false;
+ break;
+ }
+ result.push_back(static_cast<typename string_t::value_type>(current));
+ };
+ return success;
+ }
+
+ /*!
+ @brief create a byte array by reading bytes from the input
+
+ @tparam NumberType the type of the number
+ @param[in] format the current format (for diagnostics)
+ @param[in] len number of bytes to read
+ @param[out] result byte array created by reading @a len bytes
+
+ @return whether byte array creation completed
+
+ @note We can not reserve @a len bytes for the result, because @a len
+ may be too large. Usually, @ref unexpect_eof() detects the end of
+ the input before we run out of memory.
+ */
+ template<typename NumberType>
+ bool get_binary(const input_format_t format,
+ const NumberType len,
+ binary_t& result)
+ {
+ bool success = true;
+ for (NumberType i = 0; i < len; i++)
+ {
+ get();
+ if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
+ {
+ success = false;
+ break;
+ }
+ result.push_back(static_cast<std::uint8_t>(current));
+ }
+ return success;
+ }
+
+ /*!
+ @param[in] format the current format (for diagnostics)
+ @param[in] context further context information (for diagnostics)
+ @return whether the last read character is not EOF
+ */
+ JSON_HEDLEY_NON_NULL(3)
+ bool unexpect_eof(const input_format_t format, const char* context) const
+ {
+ if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
+ {
+ return sax->parse_error(chars_read, "<end of file>",
+ parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context)));
+ }
+ return true;
+ }
+
+ /*!
+ @return a string representation of the last read byte
+ */
+ std::string get_token_string() const
+ {
+ std::array<char, 3> cr{{}};
+ (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current));
+ return std::string{cr.data()};
+ }
+
+ /*!
+ @param[in] format the current format
+ @param[in] detail a detailed error message
+ @param[in] context further context information
+ @return a message string to use in the parse_error exceptions
+ */
+ std::string exception_message(const input_format_t format,
+ const std::string& detail,
+ const std::string& context) const
+ {
+ std::string error_msg = "syntax error while parsing ";
+
+ switch (format)
+ {
+ case input_format_t::cbor:
+ error_msg += "CBOR";
+ break;
+
+ case input_format_t::msgpack:
+ error_msg += "MessagePack";
+ break;
+
+ case input_format_t::ubjson:
+ error_msg += "UBJSON";
+ break;
+
+ case input_format_t::bson:
+ error_msg += "BSON";
+ break;
+
+ default: // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
+ }
+
+ return error_msg + " " + context + ": " + detail;
+ }
+
+ private:
+ /// input adapter
+ InputAdapterType ia;
+
+ /// the current character
+ char_int_type current = std::char_traits<char_type>::eof();
+
+ /// the number of characters read
+ std::size_t chars_read = 0;
+
+ /// whether we can assume little endianess
+ const bool is_little_endian = little_endianess();
+
+ /// the SAX parser
+ json_sax_t* sax = nullptr;
+};
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
// #include <nlohmann/detail/input/parser.hpp>
-#include <cassert> // assert
#include <cmath> // isfinite
#include <cstdint> // uint8_t
#include <functional> // function
@@ -9668,8 +10173,11 @@ class parser
/// a parser reading from an input adapter
explicit parser(InputAdapterType&& adapter,
const parser_callback_t<BasicJsonType> cb = nullptr,
- const bool allow_exceptions_ = true)
- : callback(cb), m_lexer(std::move(adapter)), allow_exceptions(allow_exceptions_)
+ const bool allow_exceptions_ = true,
+ const bool skip_comments = false)
+ : callback(cb)
+ , m_lexer(std::move(adapter), skip_comments)
+ , allow_exceptions(allow_exceptions_)
{
// read first token
get_token();
@@ -9694,7 +10202,7 @@ class parser
result.assert_invariant();
// in strict mode, input must be completely read
- if (strict and (get_token() != token_type::end_of_input))
+ if (strict && (get_token() != token_type::end_of_input))
{
sdp.parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
@@ -9723,7 +10231,7 @@ class parser
result.assert_invariant();
// in strict mode, input must be completely read
- if (strict and (get_token() != token_type::end_of_input))
+ if (strict && (get_token() != token_type::end_of_input))
{
sdp.parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
@@ -9752,7 +10260,7 @@ class parser
return sax_parse(&sax_acceptor, strict);
}
- template <typename SAX>
+ template<typename SAX>
JSON_HEDLEY_NON_NULL(2)
bool sax_parse(SAX* sax, const bool strict = true)
{
@@ -9760,7 +10268,7 @@ class parser
const bool result = sax_parse_internal(sax);
// strict mode: next byte must be EOF
- if (result and strict and (get_token() != token_type::end_of_input))
+ if (result && strict && (get_token() != token_type::end_of_input))
{
return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
@@ -9772,7 +10280,7 @@ class parser
}
private:
- template <typename SAX>
+ template<typename SAX>
JSON_HEDLEY_NON_NULL(2)
bool sax_parse_internal(SAX* sax)
{
@@ -9784,14 +10292,14 @@ class parser
while (true)
{
- if (not skip_to_state_evaluation)
+ if (!skip_to_state_evaluation)
{
// invariant: get_token() was called before each iteration
switch (last_token)
{
case token_type::begin_object:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
{
return false;
}
@@ -9799,7 +10307,7 @@ class parser
// closing } -> we are done
if (get_token() == token_type::end_object)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
+ if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
{
return false;
}
@@ -9814,7 +10322,7 @@ class parser
parse_error::create(101, m_lexer.get_position(),
exception_message(token_type::value_string, "object key")));
}
- if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
+ if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
{
return false;
}
@@ -9838,7 +10346,7 @@ class parser
case token_type::begin_array:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
{
return false;
}
@@ -9846,7 +10354,7 @@ class parser
// closing ] -> we are done
if (get_token() == token_type::end_array)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
+ if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
{
return false;
}
@@ -9864,14 +10372,14 @@ class parser
{
const auto res = m_lexer.get_number_float();
- if (JSON_HEDLEY_UNLIKELY(not std::isfinite(res)))
+ if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
{
return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
}
- if (JSON_HEDLEY_UNLIKELY(not sax->number_float(res, m_lexer.get_string())))
+ if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
{
return false;
}
@@ -9881,7 +10389,7 @@ class parser
case token_type::literal_false:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->boolean(false)))
+ if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
{
return false;
}
@@ -9890,7 +10398,7 @@ class parser
case token_type::literal_null:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->null()))
+ if (JSON_HEDLEY_UNLIKELY(!sax->null()))
{
return false;
}
@@ -9899,7 +10407,7 @@ class parser
case token_type::literal_true:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->boolean(true)))
+ if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
{
return false;
}
@@ -9908,7 +10416,7 @@ class parser
case token_type::value_integer:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->number_integer(m_lexer.get_number_integer())))
+ if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
{
return false;
}
@@ -9917,7 +10425,7 @@ class parser
case token_type::value_string:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->string(m_lexer.get_string())))
+ if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
{
return false;
}
@@ -9926,7 +10434,7 @@ class parser
case token_type::value_unsigned:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->number_unsigned(m_lexer.get_number_unsigned())))
+ if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
{
return false;
}
@@ -9976,7 +10484,7 @@ class parser
// closing ]
if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
{
- if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
+ if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
{
return false;
}
@@ -9985,7 +10493,7 @@ class parser
// new value, we need to evaluate the new state first.
// By setting skip_to_state_evaluation to false, we
// are effectively jumping to the beginning of this if.
- assert(not states.empty());
+ JSON_ASSERT(!states.empty());
states.pop_back();
skip_to_state_evaluation = true;
continue;
@@ -10010,7 +10518,7 @@ class parser
exception_message(token_type::value_string, "object key")));
}
- if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
+ if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
{
return false;
}
@@ -10032,7 +10540,7 @@ class parser
// closing }
if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
{
- if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
+ if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
{
return false;
}
@@ -10041,7 +10549,7 @@ class parser
// new value, we need to evaluate the new state first.
// By setting skip_to_state_evaluation to false, we
// are effectively jumping to the beginning of this if.
- assert(not states.empty());
+ JSON_ASSERT(!states.empty());
states.pop_back();
skip_to_state_evaluation = true;
continue;
@@ -10065,7 +10573,7 @@ class parser
{
std::string error_msg = "syntax error ";
- if (not context.empty())
+ if (!context.empty())
{
error_msg += "while parsing " + context + " ";
}
@@ -10245,8 +10753,6 @@ template<typename BasicJsonType> struct internal_iterator
typename BasicJsonType::object_t::iterator object_iterator {};
/// iterator for JSON arrays
typename BasicJsonType::array_t::iterator array_iterator {};
- /// iterator for JSON binary arrays
- typename BasicJsonType::binary_t::container_type::iterator binary_iterator {};
/// generic iterator for all other types
primitive_iterator_t primitive_iterator {};
};
@@ -10259,8 +10765,6 @@ template<typename BasicJsonType> struct internal_iterator
#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
#include <type_traits> // conditional, is_const, remove_const
-// #include <nlohmann/detail/boolean_operators.hpp>
-
// #include <nlohmann/detail/exceptions.hpp>
// #include <nlohmann/detail/iterators/internal_iterator.hpp>
@@ -10349,7 +10853,7 @@ class iter_impl
*/
explicit iter_impl(pointer object) noexcept : m_object(object)
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -10435,7 +10939,7 @@ class iter_impl
*/
void set_begin() noexcept
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -10472,7 +10976,7 @@ class iter_impl
*/
void set_end() noexcept
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -10503,19 +11007,19 @@ class iter_impl
*/
reference operator*() const
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
case value_t::object:
{
- assert(m_it.object_iterator != m_object->m_value.object->end());
+ JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
return m_it.object_iterator->second;
}
case value_t::array:
{
- assert(m_it.array_iterator != m_object->m_value.array->end());
+ JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
return *m_it.array_iterator;
}
@@ -10540,19 +11044,19 @@ class iter_impl
*/
pointer operator->() const
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
case value_t::object:
{
- assert(m_it.object_iterator != m_object->m_value.object->end());
+ JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
return &(m_it.object_iterator->second);
}
case value_t::array:
{
- assert(m_it.array_iterator != m_object->m_value.array->end());
+ JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
return &*m_it.array_iterator;
}
@@ -10585,7 +11089,7 @@ class iter_impl
*/
iter_impl& operator++()
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -10628,7 +11132,7 @@ class iter_impl
*/
iter_impl& operator--()
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -10666,7 +11170,7 @@ class iter_impl
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
}
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -10687,7 +11191,7 @@ class iter_impl
*/
bool operator!=(const iter_impl& other) const
{
- return not operator==(other);
+ return !operator==(other);
}
/*!
@@ -10702,7 +11206,7 @@ class iter_impl
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
}
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -10723,7 +11227,7 @@ class iter_impl
*/
bool operator<=(const iter_impl& other) const
{
- return not other.operator < (*this);
+ return !other.operator < (*this);
}
/*!
@@ -10732,7 +11236,7 @@ class iter_impl
*/
bool operator>(const iter_impl& other) const
{
- return not operator<=(other);
+ return !operator<=(other);
}
/*!
@@ -10741,7 +11245,7 @@ class iter_impl
*/
bool operator>=(const iter_impl& other) const
{
- return not operator<(other);
+ return !operator<(other);
}
/*!
@@ -10750,7 +11254,7 @@ class iter_impl
*/
iter_impl& operator+=(difference_type i)
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -10821,7 +11325,7 @@ class iter_impl
*/
difference_type operator-(const iter_impl& other) const
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -10842,7 +11346,7 @@ class iter_impl
*/
reference operator[](difference_type n) const
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
@@ -10873,7 +11377,7 @@ class iter_impl
*/
const typename object_t::key_type& key() const
{
- assert(m_object != nullptr);
+ JSON_ASSERT(m_object != nullptr);
if (JSON_HEDLEY_LIKELY(m_object->is_object()))
{
@@ -11030,8 +11534,8 @@ class json_reverse_iterator : public std::reverse_iterator<Base>
#include <algorithm> // all_of
-#include <cassert> // assert
#include <cctype> // isdigit
+#include <limits> // max
#include <numeric> // accumulate
#include <string> // string
#include <utility> // move
@@ -11357,12 +11861,17 @@ class json_pointer
@return integer representation of @a s
+ @throw parse_error.106 if an array index begins with '0'
+ @throw parse_error.109 if an array index begins not with a digit
@throw out_of_range.404 if string @a s could not be converted to an integer
+ @throw out_of_range.410 if an array index exceeds size_type
*/
- static int array_index(const std::string& s)
+ static typename BasicJsonType::size_type array_index(const std::string& s)
{
+ using size_type = typename BasicJsonType::size_type;
+
// error condition (cf. RFC 6901, Sect. 4)
- if (JSON_HEDLEY_UNLIKELY(s.size() > 1 and s[0] == '0'))
+ if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
{
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + s +
@@ -11370,16 +11879,16 @@ class json_pointer
}
// error condition (cf. RFC 6901, Sect. 4)
- if (JSON_HEDLEY_UNLIKELY(s.size() > 1 and not (s[0] >= '1' and s[0] <= '9')))
+ if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
{
JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number"));
}
std::size_t processed_chars = 0;
- int res = 0;
+ unsigned long long res = 0;
JSON_TRY
{
- res = std::stoi(s, &processed_chars);
+ res = std::stoull(s, &processed_chars);
}
JSON_CATCH(std::out_of_range&)
{
@@ -11392,7 +11901,14 @@ class json_pointer
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
}
- return res;
+ // only triggered on special platforms (like 32bit), see also
+ // https://github.com/nlohmann/json/pull/2203
+ if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))
+ {
+ JSON_THROW(detail::out_of_range::create(410, "array index " + s + " exceeds size_type")); // LCOV_EXCL_LINE
+ }
+
+ return static_cast<size_type>(res);
}
json_pointer top() const
@@ -11417,7 +11933,6 @@ class json_pointer
*/
BasicJsonType& get_and_create(BasicJsonType& j) const
{
- using size_type = typename BasicJsonType::size_type;
auto result = &j;
// in case no reference tokens exist, return a reference to the JSON value
@@ -11451,7 +11966,7 @@ class json_pointer
case detail::value_t::array:
{
// create an entry in the array
- result = &result->operator[](static_cast<size_type>(array_index(reference_token)));
+ result = &result->operator[](array_index(reference_token));
break;
}
@@ -11490,7 +12005,6 @@ class json_pointer
*/
BasicJsonType& get_unchecked(BasicJsonType* ptr) const
{
- using size_type = typename BasicJsonType::size_type;
for (const auto& reference_token : reference_tokens)
{
// convert null values to arrays or objects before continuing
@@ -11505,7 +12019,7 @@ class json_pointer
});
// change value to array for numbers or "-" or to object otherwise
- *ptr = (nums or reference_token == "-")
+ *ptr = (nums || reference_token == "-")
? detail::value_t::array
: detail::value_t::object;
}
@@ -11529,8 +12043,7 @@ class json_pointer
else
{
// convert array index to number; unchecked access
- ptr = &ptr->operator[](
- static_cast<size_type>(array_index(reference_token)));
+ ptr = &ptr->operator[](array_index(reference_token));
}
break;
}
@@ -11551,7 +12064,6 @@ class json_pointer
*/
BasicJsonType& get_checked(BasicJsonType* ptr) const
{
- using size_type = typename BasicJsonType::size_type;
for (const auto& reference_token : reference_tokens)
{
switch (ptr->type())
@@ -11574,7 +12086,7 @@ class json_pointer
}
// note: at performs range check
- ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
+ ptr = &ptr->at(array_index(reference_token));
break;
}
@@ -11601,7 +12113,6 @@ class json_pointer
*/
const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
{
- using size_type = typename BasicJsonType::size_type;
for (const auto& reference_token : reference_tokens)
{
switch (ptr->type())
@@ -11624,8 +12135,7 @@ class json_pointer
}
// use unchecked array access
- ptr = &ptr->operator[](
- static_cast<size_type>(array_index(reference_token)));
+ ptr = &ptr->operator[](array_index(reference_token));
break;
}
@@ -11645,7 +12155,6 @@ class json_pointer
*/
const BasicJsonType& get_checked(const BasicJsonType* ptr) const
{
- using size_type = typename BasicJsonType::size_type;
for (const auto& reference_token : reference_tokens)
{
switch (ptr->type())
@@ -11668,7 +12177,7 @@ class json_pointer
}
// note: at performs range check
- ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
+ ptr = &ptr->at(array_index(reference_token));
break;
}
@@ -11686,14 +12195,13 @@ class json_pointer
*/
bool contains(const BasicJsonType* ptr) const
{
- using size_type = typename BasicJsonType::size_type;
for (const auto& reference_token : reference_tokens)
{
switch (ptr->type())
{
case detail::value_t::object:
{
- if (not ptr->contains(reference_token))
+ if (!ptr->contains(reference_token))
{
// we did not find the key in the object
return false;
@@ -11710,21 +12218,21 @@ class json_pointer
// "-" always fails the range check
return false;
}
- if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 and not ("0" <= reference_token and reference_token <= "9")))
+ if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
{
// invalid char
return false;
}
if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
{
- if (JSON_HEDLEY_UNLIKELY(not ('1' <= reference_token[0] and reference_token[0] <= '9')))
+ if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
{
// first char should be between '1' and '9'
return false;
}
for (std::size_t i = 1; i < reference_token.size(); i++)
{
- if (JSON_HEDLEY_UNLIKELY(not ('0' <= reference_token[i] and reference_token[i] <= '9')))
+ if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
{
// other char should be between '0' and '9'
return false;
@@ -11732,7 +12240,7 @@ class json_pointer
}
}
- const auto idx = static_cast<size_type>(array_index(reference_token));
+ const auto idx = array_index(reference_token);
if (idx >= ptr->size())
{
// index out of range
@@ -11808,11 +12316,11 @@ class json_pointer
pos != std::string::npos;
pos = reference_token.find_first_of('~', pos + 1))
{
- assert(reference_token[pos] == '~');
+ JSON_ASSERT(reference_token[pos] == '~');
// ~ must be followed by 0 or 1
- if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 or
- (reference_token[pos + 1] != '0' and
+ if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
+ (reference_token[pos + 1] != '0' &&
reference_token[pos + 1] != '1')))
{
JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
@@ -11843,7 +12351,7 @@ class json_pointer
static void replace_substring(std::string& s, const std::string& f,
const std::string& t)
{
- assert(not f.empty());
+ JSON_ASSERT(!f.empty());
for (auto pos = s.find(f); // find first occurrence of f
pos != std::string::npos; // make sure f was found
s.replace(pos, f.size(), t), // replace with t, and
@@ -11938,7 +12446,7 @@ class json_pointer
static BasicJsonType
unflatten(const BasicJsonType& value)
{
- if (JSON_HEDLEY_UNLIKELY(not value.is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
{
JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
}
@@ -11948,7 +12456,7 @@ class json_pointer
// iterate the JSON object values
for (const auto& element : *value.m_value.object)
{
- if (JSON_HEDLEY_UNLIKELY(not element.second.is_primitive()))
+ if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
{
JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
}
@@ -11994,7 +12502,7 @@ class json_pointer
friend bool operator!=(json_pointer const& lhs,
json_pointer const& rhs) noexcept
{
- return not (lhs == rhs);
+ return !(lhs == rhs);
}
/// the reference tokens
@@ -12022,23 +12530,30 @@ class json_ref
using value_type = BasicJsonType;
json_ref(value_type&& value)
- : owned_value(std::move(value)), value_ref(&owned_value), is_rvalue(true)
+ : owned_value(std::move(value))
+ , value_ref(&owned_value)
+ , is_rvalue(true)
{}
json_ref(const value_type& value)
- : value_ref(const_cast<value_type*>(&value)), is_rvalue(false)
+ : value_ref(const_cast<value_type*>(&value))
+ , is_rvalue(false)
{}
json_ref(std::initializer_list<json_ref> init)
- : owned_value(init), value_ref(&owned_value), is_rvalue(true)
+ : owned_value(init)
+ , value_ref(&owned_value)
+ , is_rvalue(true)
{}
template <
class... Args,
enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
json_ref(Args && ... args)
- : owned_value(std::forward<Args>(args)...), value_ref(&owned_value),
- is_rvalue(true) {}
+ : owned_value(std::forward<Args>(args)...)
+ , value_ref(&owned_value)
+ , is_rvalue(true)
+ {}
// class should be movable only
json_ref(json_ref&&) = default;
@@ -12069,7 +12584,7 @@ class json_ref
private:
mutable value_type owned_value = nullptr;
value_type* value_ref = nullptr;
- const bool is_rvalue;
+ const bool is_rvalue = true;
};
} // namespace detail
} // namespace nlohmann
@@ -12238,6 +12753,7 @@ class binary_writer
{
using string_t = typename BasicJsonType::string_t;
using binary_t = typename BasicJsonType::binary_t;
+ using number_float_t = typename BasicJsonType::number_float_t;
public:
/*!
@@ -12247,7 +12763,7 @@ class binary_writer
*/
explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)
{
- assert(oa);
+ JSON_ASSERT(oa);
}
/*!
@@ -12404,18 +12920,7 @@ class binary_writer
}
else
{
- if (static_cast<double>(j.m_value.number_float) >= static_cast<double>(std::numeric_limits<float>::lowest()) and
- static_cast<double>(j.m_value.number_float) <= static_cast<double>((std::numeric_limits<float>::max)()) and
- static_cast<double>(static_cast<float>(j.m_value.number_float)) == static_cast<double>(j.m_value.number_float))
- {
- oa->write_character(get_cbor_float_prefix(static_cast<float>(j.m_value.number_float)));
- write_number(static_cast<float>(j.m_value.number_float));
- }
- else
- {
- oa->write_character(get_cbor_float_prefix(j.m_value.number_float));
- write_number(j.m_value.number_float);
- }
+ write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
}
break;
}
@@ -12499,6 +13004,12 @@ class binary_writer
case value_t::binary:
{
+ if (j.m_value.binary->has_subtype())
+ {
+ write_number(static_cast<std::uint8_t>(0xd8));
+ write_number(j.m_value.binary->subtype());
+ }
+
// step 1: write control byte and the binary array size
const auto N = j.m_value.binary->size();
if (N <= 0x17)
@@ -12646,28 +13157,28 @@ class binary_writer
// negative fixnum
write_number(static_cast<std::int8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() and
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
{
// int 8
oa->write_character(to_char_type(0xD0));
write_number(static_cast<std::int8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() and
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
{
// int 16
oa->write_character(to_char_type(0xD1));
write_number(static_cast<std::int16_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() and
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
{
// int 32
oa->write_character(to_char_type(0xD2));
write_number(static_cast<std::int32_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() and
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
{
// int 64
@@ -12714,8 +13225,7 @@ class binary_writer
case value_t::number_float:
{
- oa->write_character(get_msgpack_float_prefix(j.m_value.number_float));
- write_number(j.m_value.number_float);
+ write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
break;
}
@@ -12794,7 +13304,7 @@ class binary_writer
const auto N = j.m_value.binary->size();
if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
- std::uint8_t output_type;
+ std::uint8_t output_type{};
bool fixed = true;
if (use_ext)
{
@@ -12829,37 +13339,25 @@ class binary_writer
}
oa->write_character(to_char_type(output_type));
- if (not fixed)
+ if (!fixed)
{
write_number(static_cast<std::uint8_t>(N));
}
}
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
- std::uint8_t output_type;
- if (use_ext)
- {
- output_type = 0xC8; // ext 16
- }
- else
- {
- output_type = 0xC5; // bin 16
- }
+ std::uint8_t output_type = use_ext
+ ? 0xC8 // ext 16
+ : 0xC5; // bin 16
oa->write_character(to_char_type(output_type));
write_number(static_cast<std::uint16_t>(N));
}
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
- std::uint8_t output_type;
- if (use_ext)
- {
- output_type = 0xC9; // ext 32
- }
- else
- {
- output_type = 0xC6; // bin 32
- }
+ std::uint8_t output_type = use_ext
+ ? 0xC9 // ext 32
+ : 0xC6; // bin 32
oa->write_character(to_char_type(output_type));
write_number(static_cast<std::uint32_t>(N));
@@ -12985,9 +13483,9 @@ class binary_writer
}
bool prefix_required = true;
- if (use_type and not j.m_value.array->empty())
+ if (use_type && !j.m_value.array->empty())
{
- assert(use_count);
+ JSON_ASSERT(use_count);
const CharType first_prefix = ubjson_prefix(j.front());
const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
[this, first_prefix](const BasicJsonType & v)
@@ -13014,7 +13512,7 @@ class binary_writer
write_ubjson(el, use_count, use_type, prefix_required);
}
- if (not use_count)
+ if (!use_count)
{
oa->write_character(to_char_type(']'));
}
@@ -13029,9 +13527,9 @@ class binary_writer
oa->write_character(to_char_type('['));
}
- if (use_type and not j.m_value.binary->empty())
+ if (use_type && !j.m_value.binary->empty())
{
- assert(use_count);
+ JSON_ASSERT(use_count);
oa->write_character(to_char_type('$'));
oa->write_character('U');
}
@@ -13057,7 +13555,7 @@ class binary_writer
}
}
- if (not use_count)
+ if (!use_count)
{
oa->write_character(to_char_type(']'));
}
@@ -13073,9 +13571,9 @@ class binary_writer
}
bool prefix_required = true;
- if (use_type and not j.m_value.object->empty())
+ if (use_type && !j.m_value.object->empty())
{
- assert(use_count);
+ JSON_ASSERT(use_count);
const CharType first_prefix = ubjson_prefix(j.front());
const bool same_prefix = std::all_of(j.begin(), j.end(),
[this, first_prefix](const BasicJsonType & v)
@@ -13106,7 +13604,7 @@ class binary_writer
write_ubjson(el.second, use_count, use_type, prefix_required);
}
- if (not use_count)
+ if (!use_count)
{
oa->write_character(to_char_type('}'));
}
@@ -13207,7 +13705,7 @@ class binary_writer
*/
static std::size_t calc_bson_integer_size(const std::int64_t value)
{
- return (std::numeric_limits<std::int32_t>::min)() <= value and value <= (std::numeric_limits<std::int32_t>::max)()
+ return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
? sizeof(std::int32_t)
: sizeof(std::int64_t);
}
@@ -13218,7 +13716,7 @@ class binary_writer
void write_bson_integer(const string_t& name,
const std::int64_t value)
{
- if ((std::numeric_limits<std::int32_t>::min)() <= value and value <= (std::numeric_limits<std::int32_t>::max)())
+ if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
{
write_bson_entry_header(name, 0x10); // int32
write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
@@ -13367,7 +13865,7 @@ class binary_writer
// LCOV_EXCL_START
default:
- assert(false);
+ JSON_ASSERT(false);
return 0ul;
// LCOV_EXCL_STOP
}
@@ -13414,7 +13912,7 @@ class binary_writer
// LCOV_EXCL_START
default:
- assert(false);
+ JSON_ASSERT(false);
return;
// LCOV_EXCL_STOP
}
@@ -13546,18 +14044,28 @@ class binary_writer
}
else
{
- JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(n) + " cannot be represented by UBJSON as it does not fit int64"));
+ if (add_prefix)
+ {
+ oa->write_character(to_char_type('H')); // high-precision number
+ }
+
+ const auto number = BasicJsonType(n).dump();
+ write_number_with_ubjson_prefix(number.size(), true);
+ for (std::size_t i = 0; i < number.size(); ++i)
+ {
+ oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+ }
}
}
// UBJSON: write number (signed integer)
- template<typename NumberType, typename std::enable_if<
- std::is_signed<NumberType>::value and
- not std::is_floating_point<NumberType>::value, int>::type = 0>
+ template < typename NumberType, typename std::enable_if <
+ std::is_signed<NumberType>::value&&
+ !std::is_floating_point<NumberType>::value, int >::type = 0 >
void write_number_with_ubjson_prefix(const NumberType n,
const bool add_prefix)
{
- if ((std::numeric_limits<std::int8_t>::min)() <= n and n <= (std::numeric_limits<std::int8_t>::max)())
+ if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
{
if (add_prefix)
{
@@ -13565,7 +14073,7 @@ class binary_writer
}
write_number(static_cast<std::int8_t>(n));
}
- else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n and n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
+ else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
{
if (add_prefix)
{
@@ -13573,7 +14081,7 @@ class binary_writer
}
write_number(static_cast<std::uint8_t>(n));
}
- else if ((std::numeric_limits<std::int16_t>::min)() <= n and n <= (std::numeric_limits<std::int16_t>::max)())
+ else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
{
if (add_prefix)
{
@@ -13581,7 +14089,7 @@ class binary_writer
}
write_number(static_cast<std::int16_t>(n));
}
- else if ((std::numeric_limits<std::int32_t>::min)() <= n and n <= (std::numeric_limits<std::int32_t>::max)())
+ else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
{
if (add_prefix)
{
@@ -13589,7 +14097,7 @@ class binary_writer
}
write_number(static_cast<std::int32_t>(n));
}
- else if ((std::numeric_limits<std::int64_t>::min)() <= n and n <= (std::numeric_limits<std::int64_t>::max)())
+ else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
{
if (add_prefix)
{
@@ -13600,19 +14108,23 @@ class binary_writer
// LCOV_EXCL_START
else
{
- JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(n) + " cannot be represented by UBJSON as it does not fit int64"));
+ if (add_prefix)
+ {
+ oa->write_character(to_char_type('H')); // high-precision number
+ }
+
+ const auto number = BasicJsonType(n).dump();
+ write_number_with_ubjson_prefix(number.size(), true);
+ for (std::size_t i = 0; i < number.size(); ++i)
+ {
+ oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+ }
}
// LCOV_EXCL_STOP
}
/*!
@brief determine the type prefix of container values
-
- @note This function does not need to be 100% accurate when it comes to
- integer limits. In case a number exceeds the limits of int64_t,
- this will be detected by a later call to function
- write_number_with_ubjson_prefix. Therefore, we return 'L' for any
- value that does not fit the previous limits.
*/
CharType ubjson_prefix(const BasicJsonType& j) const noexcept
{
@@ -13626,24 +14138,28 @@ class binary_writer
case value_t::number_integer:
{
- if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+ if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
{
return 'i';
}
- if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+ if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
{
return 'U';
}
- if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+ if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
{
return 'I';
}
- if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+ if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
{
return 'l';
}
- // no check and assume int64_t (see note above)
- return 'L';
+ if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+ {
+ return 'L';
+ }
+ // anything else is treated as high-precision number
+ return 'H'; // LCOV_EXCL_LINE
}
case value_t::number_unsigned:
@@ -13664,8 +14180,12 @@ class binary_writer
{
return 'l';
}
- // no check and assume int64_t (see note above)
- return 'L';
+ if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+ {
+ return 'L';
+ }
+ // anything else is treated as high-precision number
+ return 'H'; // LCOV_EXCL_LINE
}
case value_t::number_float:
@@ -13728,20 +14248,40 @@ class binary_writer
oa->write_characters(vec.data(), sizeof(NumberType));
}
+ void write_compact_float(const number_float_t n, detail::input_format_t format)
+ {
+ if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
+ static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
+ static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
+ {
+ oa->write_character(format == detail::input_format_t::cbor
+ ? get_cbor_float_prefix(static_cast<float>(n))
+ : get_msgpack_float_prefix(static_cast<float>(n)));
+ write_number(static_cast<float>(n));
+ }
+ else
+ {
+ oa->write_character(format == detail::input_format_t::cbor
+ ? get_cbor_float_prefix(n)
+ : get_msgpack_float_prefix(n));
+ write_number(n);
+ }
+ }
+
public:
// The following to_char_type functions are implement the conversion
// between uint8_t and CharType. In case CharType is not unsigned,
// such a conversion is required to allow values greater than 128.
// See <https://github.com/nlohmann/json/issues/1286> for a discussion.
template < typename C = CharType,
- enable_if_t < std::is_signed<C>::value and std::is_signed<char>::value > * = nullptr >
+ enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
static constexpr CharType to_char_type(std::uint8_t x) noexcept
{
return *reinterpret_cast<char*>(&x);
}
template < typename C = CharType,
- enable_if_t < std::is_signed<C>::value and std::is_unsigned<char>::value > * = nullptr >
+ enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
static CharType to_char_type(std::uint8_t x) noexcept
{
static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
@@ -13760,8 +14300,8 @@ class binary_writer
template < typename InputCharType, typename C = CharType,
enable_if_t <
- std::is_signed<C>::value and
- std::is_signed<char>::value and
+ std::is_signed<C>::value &&
+ std::is_signed<char>::value &&
std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
> * = nullptr >
static constexpr CharType to_char_type(InputCharType x) noexcept
@@ -13786,32 +14326,26 @@ class binary_writer
#include <algorithm> // reverse, remove, fill, find, none_of
#include <array> // array
-#include <cassert> // assert
#include <clocale> // localeconv, lconv
#include <cmath> // labs, isfinite, isnan, signbit
#include <cstddef> // size_t, ptrdiff_t
#include <cstdint> // uint8_t
#include <cstdio> // snprintf
#include <limits> // numeric_limits
-#include <string> // string
+#include <string> // string, char_traits
#include <type_traits> // is_same
#include <utility> // move
-// #include <nlohmann/detail/boolean_operators.hpp>
-
// #include <nlohmann/detail/conversions/to_chars.hpp>
#include <array> // array
-#include <cassert> // assert
#include <cmath> // signbit, isfinite
#include <cstdint> // intN_t, uintN_t
#include <cstring> // memcpy, memmove
#include <limits> // numeric_limits
#include <type_traits> // conditional
-// #include <nlohmann/detail/boolean_operators.hpp>
-
// #include <nlohmann/detail/macro_scope.hpp>
@@ -13842,7 +14376,7 @@ For a detailed description of the algorithm see:
namespace dtoa_impl
{
-template <typename Target, typename Source>
+template<typename Target, typename Source>
Target reinterpret_bits(const Source source)
{
static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
@@ -13867,8 +14401,8 @@ struct diyfp // f * 2^e
*/
static diyfp sub(const diyfp& x, const diyfp& y) noexcept
{
- assert(x.e == y.e);
- assert(x.f >= y.f);
+ JSON_ASSERT(x.e == y.e);
+ JSON_ASSERT(x.f >= y.f);
return {x.f - y.f, x.e};
}
@@ -13944,7 +14478,7 @@ struct diyfp // f * 2^e
*/
static diyfp normalize(diyfp x) noexcept
{
- assert(x.f != 0);
+ JSON_ASSERT(x.f != 0);
while ((x.f >> 63u) == 0)
{
@@ -13963,8 +14497,8 @@ struct diyfp // f * 2^e
{
const int delta = x.e - target_exponent;
- assert(delta >= 0);
- assert(((x.f << delta) >> delta) == x.f);
+ JSON_ASSERT(delta >= 0);
+ JSON_ASSERT(((x.f << delta) >> delta) == x.f);
return {x.f << delta, target_exponent};
}
@@ -13983,11 +14517,11 @@ boundaries.
@pre value must be finite and positive
*/
-template <typename FloatType>
+template<typename FloatType>
boundaries compute_boundaries(FloatType value)
{
- assert(std::isfinite(value));
- assert(value > 0);
+ JSON_ASSERT(std::isfinite(value));
+ JSON_ASSERT(value > 0);
// Convert the IEEE representation into a diyfp.
//
@@ -14036,7 +14570,7 @@ boundaries compute_boundaries(FloatType value)
// -----------------+------+------+-------------+-------------+--- (B)
// v- m- v m+ v+
- const bool lower_boundary_is_closer = F == 0 and E > 1;
+ const bool lower_boundary_is_closer = F == 0 && E > 1;
const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
const diyfp m_minus = lower_boundary_is_closer
? diyfp(4 * v.f - 1, v.e - 2) // (B)
@@ -14267,18 +14801,18 @@ inline cached_power get_cached_power_for_binary_exponent(int e)
// k = ceil((kAlpha - e - 1) * 0.30102999566398114)
// for |e| <= 1500, but doesn't require floating-point operations.
// NB: log_10(2) ~= 78913 / 2^18
- assert(e >= -1500);
- assert(e <= 1500);
+ JSON_ASSERT(e >= -1500);
+ JSON_ASSERT(e <= 1500);
const int f = kAlpha - e - 1;
const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
- assert(index >= 0);
- assert(static_cast<std::size_t>(index) < kCachedPowers.size());
+ JSON_ASSERT(index >= 0);
+ JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
- assert(kAlpha <= cached.e + e + 64);
- assert(kGamma >= cached.e + e + 64);
+ JSON_ASSERT(kAlpha <= cached.e + e + 64);
+ JSON_ASSERT(kGamma >= cached.e + e + 64);
return cached;
}
@@ -14346,10 +14880,10 @@ inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
std::uint64_t rest, std::uint64_t ten_k)
{
- assert(len >= 1);
- assert(dist <= delta);
- assert(rest <= delta);
- assert(ten_k > 0);
+ JSON_ASSERT(len >= 1);
+ JSON_ASSERT(dist <= delta);
+ JSON_ASSERT(rest <= delta);
+ JSON_ASSERT(ten_k > 0);
// <--------------------------- delta ---->
// <---- dist --------->
@@ -14371,10 +14905,10 @@ inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t d
// integer arithmetic.
while (rest < dist
- and delta - rest >= ten_k
- and (rest + ten_k < dist or dist - rest > rest + ten_k - dist))
+ && delta - rest >= ten_k
+ && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
{
- assert(buf[len - 1] != '0');
+ JSON_ASSERT(buf[len - 1] != '0');
buf[len - 1]--;
rest += ten_k;
}
@@ -14402,8 +14936,8 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// Grisu2 generates the digits of M+ from left to right and stops as soon as
// V is in [M-,M+].
- assert(M_plus.e >= kAlpha);
- assert(M_plus.e <= kGamma);
+ JSON_ASSERT(M_plus.e >= kAlpha);
+ JSON_ASSERT(M_plus.e <= kGamma);
std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
@@ -14424,7 +14958,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
//
// Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
- assert(p1 > 0);
+ JSON_ASSERT(p1 > 0);
std::uint32_t pow10;
const int k = find_largest_pow10(p1, pow10);
@@ -14460,7 +14994,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
// = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
//
- assert(d <= 9);
+ JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
@@ -14547,7 +15081,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
//
// and stop as soon as 10^-m * r * 2^e <= delta * 2^e
- assert(p2 > delta);
+ JSON_ASSERT(p2 > delta);
int m = 0;
for (;;)
@@ -14558,7 +15092,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
//
- assert(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
+ JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
p2 *= 10;
const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
@@ -14567,7 +15101,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
// = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
- assert(d <= 9);
+ JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
@@ -14628,8 +15162,8 @@ JSON_HEDLEY_NON_NULL(1)
inline void grisu2(char* buf, int& len, int& decimal_exponent,
diyfp m_minus, diyfp v, diyfp m_plus)
{
- assert(m_plus.e == m_minus.e);
- assert(m_plus.e == v.e);
+ JSON_ASSERT(m_plus.e == m_minus.e);
+ JSON_ASSERT(m_plus.e == v.e);
// --------(-----------------------+-----------------------)-------- (A)
// m- v m+
@@ -14683,15 +15217,15 @@ v = buf * 10^decimal_exponent
len is the length of the buffer (number of decimal digits)
The buffer must be large enough, i.e. >= max_digits10.
*/
-template <typename FloatType>
+template<typename FloatType>
JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{
static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
"internal error: not enough precision");
- assert(std::isfinite(value));
- assert(value > 0);
+ JSON_ASSERT(std::isfinite(value));
+ JSON_ASSERT(value > 0);
// If the neighbors (and boundaries) of 'value' are always computed for double-precision
// numbers, all float's can be recovered using strtod (and strtof). However, the resulting
@@ -14727,8 +15261,8 @@ JSON_HEDLEY_NON_NULL(1)
JSON_HEDLEY_RETURNS_NON_NULL
inline char* append_exponent(char* buf, int e)
{
- assert(e > -1000);
- assert(e < 1000);
+ JSON_ASSERT(e > -1000);
+ JSON_ASSERT(e < 1000);
if (e < 0)
{
@@ -14780,8 +15314,8 @@ JSON_HEDLEY_RETURNS_NON_NULL
inline char* format_buffer(char* buf, int len, int decimal_exponent,
int min_exp, int max_exp)
{
- assert(min_exp < 0);
- assert(max_exp > 0);
+ JSON_ASSERT(min_exp < 0);
+ JSON_ASSERT(max_exp > 0);
const int k = len;
const int n = len + decimal_exponent;
@@ -14790,7 +15324,7 @@ inline char* format_buffer(char* buf, int len, int decimal_exponent,
// k is the length of the buffer (number of decimal digits)
// n is the position of the decimal point relative to the start of the buffer.
- if (k <= n and n <= max_exp)
+ if (k <= n && n <= max_exp)
{
// digits[000]
// len <= max_exp + 2
@@ -14802,19 +15336,19 @@ inline char* format_buffer(char* buf, int len, int decimal_exponent,
return buf + (static_cast<size_t>(n) + 2);
}
- if (0 < n and n <= max_exp)
+ if (0 < n && n <= max_exp)
{
// dig.its
// len <= max_digits10 + 1
- assert(k > n);
+ JSON_ASSERT(k > n);
std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
buf[n] = '.';
return buf + (static_cast<size_t>(k) + 1U);
}
- if (min_exp < n and n <= 0)
+ if (min_exp < n && n <= 0)
{
// 0.[000]digits
// len <= 2 + (-min_exp - 1) + max_digits10
@@ -14859,13 +15393,13 @@ format. Returns an iterator pointing past-the-end of the decimal representation.
@note The buffer must be large enough.
@note The result is NOT null-terminated.
*/
-template <typename FloatType>
+template<typename FloatType>
JSON_HEDLEY_NON_NULL(1, 2)
JSON_HEDLEY_RETURNS_NON_NULL
char* to_chars(char* first, const char* last, FloatType value)
{
static_cast<void>(last); // maybe unused - fix warning
- assert(std::isfinite(value));
+ JSON_ASSERT(std::isfinite(value));
// Use signbit(value) instead of (value < 0) since signbit works for -0.
if (std::signbit(value))
@@ -14883,7 +15417,7 @@ char* to_chars(char* first, const char* last, FloatType value)
return first;
}
- assert(last - first >= std::numeric_limits<FloatType>::max_digits10);
+ JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
// Compute v = buffer * 10^decimal_exponent.
// The decimal digits are stored in the buffer, which needs to be interpreted
@@ -14893,16 +15427,16 @@ char* to_chars(char* first, const char* last, FloatType value)
int decimal_exponent = 0;
dtoa_impl::grisu2(first, len, decimal_exponent, value);
- assert(len <= std::numeric_limits<FloatType>::max_digits10);
+ JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
// Format the buffer like printf("%.*g", prec, value)
constexpr int kMinExp = -4;
// Use digits10 here to increase compatibility with version 2.
constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
- assert(last - first >= kMaxExp + 2);
- assert(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
- assert(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
+ JSON_ASSERT(last - first >= kMaxExp + 2);
+ JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
+ JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
}
@@ -14960,8 +15494,8 @@ class serializer
error_handler_t error_handler_ = error_handler_t::strict)
: o(std::move(s))
, loc(std::localeconv())
- , thousands_sep(loc->thousands_sep == nullptr ? '\0' : * (loc->thousands_sep))
- , decimal_point(loc->decimal_point == nullptr ? '\0' : * (loc->decimal_point))
+ , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
+ , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
, indent_char(ichar)
, indent_string(512, indent_char)
, error_handler(error_handler_)
@@ -15036,8 +15570,8 @@ class serializer
}
// last element
- assert(i != val.m_value.object->cend());
- assert(std::next(i) == val.m_value.object->cend());
+ JSON_ASSERT(i != val.m_value.object->cend());
+ JSON_ASSERT(std::next(i) == val.m_value.object->cend());
o->write_characters(indent_string.c_str(), new_indent);
o->write_character('\"');
dump_escaped(i->first, ensure_ascii);
@@ -15064,8 +15598,8 @@ class serializer
}
// last element
- assert(i != val.m_value.object->cend());
- assert(std::next(i) == val.m_value.object->cend());
+ JSON_ASSERT(i != val.m_value.object->cend());
+ JSON_ASSERT(std::next(i) == val.m_value.object->cend());
o->write_character('\"');
dump_escaped(i->first, ensure_ascii);
o->write_characters("\":", 2);
@@ -15106,7 +15640,7 @@ class serializer
}
// last element
- assert(not val.m_value.array->empty());
+ JSON_ASSERT(!val.m_value.array->empty());
o->write_characters(indent_string.c_str(), new_indent);
dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
@@ -15127,7 +15661,7 @@ class serializer
}
// last element
- assert(not val.m_value.array->empty());
+ JSON_ASSERT(!val.m_value.array->empty());
dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
o->write_character(']');
@@ -15161,7 +15695,7 @@ class serializer
o->write_characters("\"bytes\": [", 10);
- if (not val.m_value.binary->empty())
+ if (!val.m_value.binary->empty())
{
for (auto i = val.m_value.binary->cbegin();
i != val.m_value.binary->cend() - 1; ++i)
@@ -15192,7 +15726,7 @@ class serializer
{
o->write_characters("{\"bytes\":[", 10);
- if (not val.m_value.binary->empty())
+ if (!val.m_value.binary->empty())
{
for (auto i = val.m_value.binary->cbegin();
i != val.m_value.binary->cend() - 1; ++i)
@@ -15261,7 +15795,7 @@ class serializer
}
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
}
@@ -15353,7 +15887,7 @@ class serializer
{
// escape control characters (0x00..0x1F) or, if
// ensure_ascii parameter is used, non-ASCII characters
- if ((codepoint <= 0x1F) or (ensure_ascii and (codepoint >= 0x7F)))
+ if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
{
if (codepoint <= 0xFFFF)
{
@@ -15460,14 +15994,14 @@ class serializer
}
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
break;
}
default: // decode found yet incomplete multi-byte code point
{
- if (not ensure_ascii)
+ if (!ensure_ascii)
{
// code point will not be escaped - copy byte to buffer
string_buffer[bytes++] = s[i];
@@ -15523,7 +16057,7 @@ class serializer
}
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
}
}
@@ -15571,11 +16105,11 @@ class serializer
@param[in] x integer number (signed or unsigned) to dump
@tparam NumberType either @a number_integer_t or @a number_unsigned_t
*/
- template<typename NumberType, detail::enable_if_t<
- std::is_same<NumberType, number_unsigned_t>::value or
- std::is_same<NumberType, number_integer_t>::value or
- std::is_same<NumberType, binary_char_t>::value,
- int> = 0>
+ template < typename NumberType, detail::enable_if_t <
+ std::is_same<NumberType, number_unsigned_t>::value ||
+ std::is_same<NumberType, number_integer_t>::value ||
+ std::is_same<NumberType, binary_char_t>::value,
+ int > = 0 >
void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
@@ -15604,7 +16138,7 @@ class serializer
// use a pointer to fill the buffer
auto buffer_ptr = number_buffer.begin();
- const bool is_negative = std::is_same<NumberType, number_integer_t>::value and not(x >= 0); // see issue #755
+ const bool is_negative = std::is_same<NumberType, number_integer_t>::value && !(x >= 0); // see issue #755
number_unsigned_t abs_value;
unsigned int n_chars;
@@ -15624,7 +16158,7 @@ class serializer
}
// spare 1 byte for '\0'
- assert(n_chars < number_buffer.size() - 1);
+ JSON_ASSERT(n_chars < number_buffer.size() - 1);
// jump to the end to generate the string from backward
// so we later avoid reversing the result
@@ -15665,7 +16199,7 @@ class serializer
void dump_float(number_float_t x)
{
// NaN / inf
- if (not std::isfinite(x))
+ if (!std::isfinite(x))
{
o->write_characters("null", 4);
return;
@@ -15677,8 +16211,8 @@ class serializer
//
// NB: The test below works if <long double> == <double>.
static constexpr bool is_ieee_single_or_double
- = (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 24 and std::numeric_limits<number_float_t>::max_exponent == 128) or
- (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 53 and std::numeric_limits<number_float_t>::max_exponent == 1024);
+ = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
+ (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
}
@@ -15700,9 +16234,9 @@ class serializer
std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
// negative value indicates an error
- assert(len > 0);
+ JSON_ASSERT(len > 0);
// check if buffer was large enough
- assert(static_cast<std::size_t>(len) < number_buffer.size());
+ JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
// erase thousands separator
if (thousands_sep != '\0')
@@ -15710,12 +16244,12 @@ class serializer
const auto end = std::remove(number_buffer.begin(),
number_buffer.begin() + len, thousands_sep);
std::fill(end, number_buffer.end(), '\0');
- assert((end - number_buffer.begin()) <= len);
+ JSON_ASSERT((end - number_buffer.begin()) <= len);
len = (end - number_buffer.begin());
}
// convert decimal point to '.'
- if (decimal_point != '\0' and decimal_point != '.')
+ if (decimal_point != '\0' && decimal_point != '.')
{
const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
if (dec_pos != number_buffer.end())
@@ -15731,7 +16265,7 @@ class serializer
std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
[](char c)
{
- return c == '.' or c == 'e';
+ return c == '.' || c == 'e';
});
if (value_is_int_like)
@@ -15790,7 +16324,7 @@ class serializer
: (0xFFu >> type) & (byte);
std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
- assert(index < 400);
+ JSON_ASSERT(index < 400);
state = utf8d[index];
return state;
}
@@ -15802,7 +16336,7 @@ class serializer
*/
number_unsigned_t remove_sign(number_unsigned_t x)
{
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
return x; // LCOV_EXCL_LINE
}
@@ -15817,7 +16351,7 @@ class serializer
*/
inline number_unsigned_t remove_sign(number_integer_t x) noexcept
{
- assert(x < 0 and x < (std::numeric_limits<number_integer_t>::max)());
+ JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)());
return static_cast<number_unsigned_t>(-(x + 1)) + 1;
}
@@ -15853,6 +16387,79 @@ class serializer
// #include <nlohmann/json_fwd.hpp>
+// #include <nlohmann/ordered_map.hpp>
+
+
+#include <functional> // less
+#include <memory> // allocator
+#include <utility> // pair
+#include <vector> // vector
+
+namespace nlohmann
+{
+
+/// ordered_map: a minimal map-like container that preserves insertion order
+/// for use within nlohmann::basic_json<ordered_map>
+template <class Key, class T, class IgnoredLess = std::less<Key>,
+ class Allocator = std::allocator<std::pair<const Key, T>>>
+ struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
+{
+ using key_type = Key;
+ using mapped_type = T;
+ using Container = std::vector<std::pair<const Key, T>, Allocator>;
+ using typename Container::iterator;
+ using typename Container::size_type;
+ using typename Container::value_type;
+
+ // Explicit constructors instead of `using Container::Container`
+ // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
+ ordered_map(const Allocator& alloc = Allocator()) : Container{alloc} {}
+ template <class It>
+ ordered_map(It first, It last, const Allocator& alloc = Allocator())
+ : Container{first, last, alloc} {}
+ ordered_map(std::initializer_list<T> init, const Allocator& alloc = Allocator() )
+ : Container{init, alloc} {}
+
+ std::pair<iterator, bool> emplace(key_type&& key, T&& t)
+ {
+ for (auto it = this->begin(); it != this->end(); ++it)
+ {
+ if (it->first == key)
+ {
+ return {it, false};
+ }
+ }
+ Container::emplace_back(key, t);
+ return {--this->end(), true};
+ }
+
+ T& operator[](Key&& key)
+ {
+ return emplace(std::move(key), T{}).first->second;
+ }
+
+ size_type erase(const Key& key)
+ {
+ for (auto it = this->begin(); it != this->end(); ++it)
+ {
+ if (it->first == key)
+ {
+ // Since we cannot move const Keys, re-construct them in place
+ for (auto next = it; ++next != this->end(); ++it)
+ {
+ it->~value_type(); // Destroy but keep allocation
+ new (&*it) value_type{std::move(*next)};
+ }
+ Container::pop_back();
+ return 1;
+ }
+ }
+ return 0;
+ }
+};
+
+} // namespace nlohmann
+
/*!
@brief namespace for Niels Lohmann
@@ -15977,10 +16584,12 @@ class basic_json
static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
InputAdapterType adapter,
detail::parser_callback_t<basic_json>cb = nullptr,
- bool allow_exceptions = true
- )
+ const bool allow_exceptions = true,
+ const bool ignore_comments = false
+ )
{
- return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter), std::move(cb), allow_exceptions);
+ return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
+ std::move(cb), allow_exceptions, ignore_comments);
}
using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
@@ -16009,6 +16618,8 @@ class basic_json
using json_serializer = JSONSerializer<T, SFINAE>;
/// how to treat decoding errors
using error_handler_t = detail::error_handler_t;
+ /// how to treat CBOR tags
+ using cbor_tag_handler_t = detail::cbor_tag_handler_t;
/// helper type for initializer lists of basic_json values
using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
@@ -16121,7 +16732,7 @@ class basic_json
{
basic_json result;
- result["copyright"] = "(C) 2013-2017 Niels Lohmann";
+ result["copyright"] = "(C) 2013-2020 Niels Lohmann";
result["name"] = "JSON for Modern C++";
result["url"] = "https://github.com/nlohmann/json";
result["version"]["string"] =
@@ -16703,7 +17314,7 @@ class basic_json
};
std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
- assert(object != nullptr);
+ JSON_ASSERT(object != nullptr);
return object.release();
}
@@ -16829,7 +17440,7 @@ class basic_json
object = nullptr; // silence warning, see #821
if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
{
- JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.8.0")); // LCOV_EXCL_LINE
+ JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.9.0")); // LCOV_EXCL_LINE
}
break;
}
@@ -16916,7 +17527,7 @@ class basic_json
}
}
- while (not stack.empty())
+ while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
@@ -16998,10 +17609,10 @@ class basic_json
*/
void assert_invariant() const noexcept
{
- assert(m_type != value_t::object or m_value.object != nullptr);
- assert(m_type != value_t::array or m_value.array != nullptr);
- assert(m_type != value_t::string or m_value.string != nullptr);
- assert(m_type != value_t::binary or m_value.binary != nullptr);
+ JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
+ JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
+ JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
+ JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
}
public:
@@ -17209,10 +17820,10 @@ class basic_json
@since version 2.1.0
*/
- template <typename CompatibleType,
- typename U = detail::uncvref_t<CompatibleType>,
- detail::enable_if_t<
- not detail::is_basic_json<U>::value and detail::is_compatible_type<basic_json_t, U>::value, int> = 0>
+ template < typename CompatibleType,
+ typename U = detail::uncvref_t<CompatibleType>,
+ detail::enable_if_t <
+ !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
basic_json(CompatibleType && val) noexcept(noexcept(
JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
std::forward<CompatibleType>(val))))
@@ -17247,9 +17858,9 @@ class basic_json
@since version 3.2.0
*/
- template <typename BasicJsonType,
- detail::enable_if_t<
- detail::is_basic_json<BasicJsonType>::value and not std::is_same<basic_json, BasicJsonType>::value, int> = 0>
+ template < typename BasicJsonType,
+ detail::enable_if_t <
+ detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
basic_json(const BasicJsonType& val)
{
using other_boolean_t = typename BasicJsonType::boolean_t;
@@ -17294,7 +17905,7 @@ class basic_json
m_type = value_t::discarded;
break;
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
assert_invariant();
}
@@ -17382,11 +17993,11 @@ class basic_json
bool is_an_object = std::all_of(init.begin(), init.end(),
[](const detail::json_ref<basic_json>& element_ref)
{
- return element_ref->is_array() and element_ref->size() == 2 and (*element_ref)[0].is_string();
+ return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
});
// adjust type if type deduction is not wanted
- if (not type_deduction)
+ if (!type_deduction)
{
// if array is wanted, do not create an object though possible
if (manual_type == value_t::array)
@@ -17395,7 +18006,7 @@ class basic_json
}
// if object is wanted but impossible, throw an exception
- if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object and not is_an_object))
+ if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
{
JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
}
@@ -17689,13 +18300,13 @@ class basic_json
@since version 1.0.0
*/
- template<class InputIT, typename std::enable_if<
- std::is_same<InputIT, typename basic_json_t::iterator>::value or
- std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int>::type = 0>
+ template < class InputIT, typename std::enable_if <
+ std::is_same<InputIT, typename basic_json_t::iterator>::value ||
+ std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
basic_json(InputIT first, InputIT last)
{
- assert(first.m_object != nullptr);
- assert(last.m_object != nullptr);
+ JSON_ASSERT(first.m_object != nullptr);
+ JSON_ASSERT(last.m_object != nullptr);
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
@@ -17715,8 +18326,8 @@ class basic_json
case value_t::number_unsigned:
case value_t::string:
{
- if (JSON_HEDLEY_UNLIKELY(not first.m_it.primitive_iterator.is_begin()
- or not last.m_it.primitive_iterator.is_end()))
+ if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
+ || !last.m_it.primitive_iterator.is_end()))
{
JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
}
@@ -17792,9 +18403,9 @@ class basic_json
// other constructors and destructor //
///////////////////////////////////////
- template <typename JsonRef,
- detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
- std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
+ template<typename JsonRef,
+ detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
+ std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
/*!
@@ -17949,9 +18560,9 @@ class basic_json
@since version 1.0.0
*/
basic_json& operator=(basic_json other) noexcept (
- std::is_nothrow_move_constructible<value_t>::value and
- std::is_nothrow_move_assignable<value_t>::value and
- std::is_nothrow_move_constructible<json_value>::value and
+ std::is_nothrow_move_constructible<value_t>::value&&
+ std::is_nothrow_move_assignable<value_t>::value&&
+ std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value
)
{
@@ -18017,7 +18628,8 @@ class basic_json
@param[in] error_handler how to react on decoding errors; there are three
possible values: `strict` (throws and exception in case a decoding error
occurs; default), `replace` (replace invalid UTF-8 sequences with U+FFFD),
- and `ignore` (ignore invalid UTF-8 sequences during serialization).
+ and `ignore` (ignore invalid UTF-8 sequences during serialization; all
+ bytes are copied to the output unchanged).
@return string containing the serialization of the JSON value
@@ -18130,7 +18742,7 @@ class basic_json
*/
constexpr bool is_primitive() const noexcept
{
- return is_null() or is_string() or is_boolean() or is_number() or is_binary();
+ return is_null() || is_string() || is_boolean() || is_number() || is_binary();
}
/*!
@@ -18157,7 +18769,7 @@ class basic_json
*/
constexpr bool is_structured() const noexcept
{
- return is_array() or is_object();
+ return is_array() || is_object();
}
/*!
@@ -18231,7 +18843,7 @@ class basic_json
*/
constexpr bool is_number() const noexcept
{
- return is_number_integer() or is_number_float();
+ return is_number_integer() || is_number_float();
}
/*!
@@ -18260,7 +18872,7 @@ class basic_json
*/
constexpr bool is_number_integer() const noexcept
{
- return m_type == value_t::number_integer or m_type == value_t::number_unsigned;
+ return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
}
/*!
@@ -18641,9 +19253,9 @@ class basic_json
@since version 3.2.0
*/
- template<typename BasicJsonType, detail::enable_if_t<
- not std::is_same<BasicJsonType, basic_json>::value and
- detail::is_basic_json<BasicJsonType>::value, int> = 0>
+ template < typename BasicJsonType, detail::enable_if_t <
+ !std::is_same<BasicJsonType, basic_json>::value&&
+ detail::is_basic_json<BasicJsonType>::value, int > = 0 >
BasicJsonType get() const
{
return *this;
@@ -18688,19 +19300,19 @@ class basic_json
@since version 2.1.0
*/
- template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
- detail::enable_if_t <
- not detail::is_basic_json<ValueType>::value and
- detail::has_from_json<basic_json_t, ValueType>::value and
- not detail::has_non_default_from_json<basic_json_t, ValueType>::value,
- int> = 0>
+ template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
+ detail::enable_if_t <
+ !detail::is_basic_json<ValueType>::value &&
+ detail::has_from_json<basic_json_t, ValueType>::value &&
+ !detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+ int > = 0 >
ValueType get() const noexcept(noexcept(
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
{
// we cannot static_assert on ValueTypeCV being non-const, because
// there is support for get<const basic_json_t>(), which is why we
// still need the uncvref
- static_assert(not std::is_reference<ValueTypeCV>::value,
+ static_assert(!std::is_reference<ValueTypeCV>::value,
"get() cannot be used with reference types, you might want to use get_ref()");
static_assert(std::is_default_constructible<ValueType>::value,
"types must be DefaultConstructible when used with get()");
@@ -18741,14 +19353,14 @@ class basic_json
@since version 2.1.0
*/
- template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
- detail::enable_if_t<not std::is_same<basic_json_t, ValueType>::value and
- detail::has_non_default_from_json<basic_json_t, ValueType>::value,
- int> = 0>
+ template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
+ detail::enable_if_t < !std::is_same<basic_json_t, ValueType>::value &&
+ detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+ int > = 0 >
ValueType get() const noexcept(noexcept(
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
{
- static_assert(not std::is_reference<ValueTypeCV>::value,
+ static_assert(!std::is_reference<ValueTypeCV>::value,
"get() cannot be used with reference types, you might want to use get_ref()");
return JSONSerializer<ValueType>::from_json(*this);
}
@@ -18786,11 +19398,11 @@ class basic_json
@since version 3.3.0
*/
- template<typename ValueType,
- detail::enable_if_t <
- not detail::is_basic_json<ValueType>::value and
- detail::has_from_json<basic_json_t, ValueType>::value,
- int> = 0>
+ template < typename ValueType,
+ detail::enable_if_t <
+ !detail::is_basic_json<ValueType>::value&&
+ detail::has_from_json<basic_json_t, ValueType>::value,
+ int > = 0 >
ValueType & get_to(ValueType& v) const noexcept(noexcept(
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
{
@@ -18798,6 +19410,18 @@ class basic_json
return v;
}
+ // specialization to allow to call get_to with a basic_json value
+ // see https://github.com/nlohmann/json/issues/2175
+ template<typename ValueType,
+ detail::enable_if_t <
+ detail::is_basic_json<ValueType>::value,
+ int> = 0>
+ ValueType & get_to(ValueType& v) const
+ {
+ v = *this;
+ return v;
+ }
+
template <
typename T, std::size_t N,
typename Array = T (&)[N],
@@ -18850,9 +19474,9 @@ class basic_json
@brief get a pointer value (implicit)
@copydoc get_ptr()
*/
- template<typename PointerType, typename std::enable_if<
- std::is_pointer<PointerType>::value and
- std::is_const<typename std::remove_pointer<PointerType>::type>::value, int>::type = 0>
+ template < typename PointerType, typename std::enable_if <
+ std::is_pointer<PointerType>::value&&
+ std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
{
// delegate the call to get_impl_ptr<>() const
@@ -18944,9 +19568,9 @@ class basic_json
@brief get a reference value (implicit)
@copydoc get_ref()
*/
- template<typename ReferenceType, typename std::enable_if<
- std::is_reference<ReferenceType>::value and
- std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int>::type = 0>
+ template < typename ReferenceType, typename std::enable_if <
+ std::is_reference<ReferenceType>::value&&
+ std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
ReferenceType get_ref() const
{
// delegate call to get_ref_impl
@@ -18983,17 +19607,17 @@ class basic_json
@since version 1.0.0
*/
template < typename ValueType, typename std::enable_if <
- not std::is_pointer<ValueType>::value and
- not std::is_same<ValueType, detail::json_ref<basic_json>>::value and
- not std::is_same<ValueType, typename string_t::value_type>::value and
- not detail::is_basic_json<ValueType>::value
- and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
-#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) and _MSC_VER >= 1910 and _MSC_VER <= 1914))
- and not std::is_same<ValueType, typename std::string_view>::value
+ !std::is_pointer<ValueType>::value&&
+ !std::is_same<ValueType, detail::json_ref<basic_json>>::value&&
+ !std::is_same<ValueType, typename string_t::value_type>::value&&
+ !detail::is_basic_json<ValueType>::value
+ && !std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
+#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
+ && !std::is_same<ValueType, typename std::string_view>::value
#endif
- and detail::is_detected<detail::get_template_function, const basic_json_t&, ValueType>::value
+ && detail::is_detected<detail::get_template_function, const basic_json_t&, ValueType>::value
, int >::type = 0 >
- operator ValueType() const
+ JSON_EXPLICIT operator ValueType() const
{
// delegate the call to get<>() const
return get<ValueType>();
@@ -19010,7 +19634,7 @@ class basic_json
*/
binary_t& get_binary()
{
- if (not is_binary())
+ if (!is_binary())
{
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
}
@@ -19021,7 +19645,7 @@ class basic_json
/// @copydoc get_binary()
const binary_t& get_binary() const
{
- if (not is_binary())
+ if (!is_binary())
{
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
}
@@ -19399,7 +20023,7 @@ class basic_json
// const operator[] only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
- assert(m_value.object->find(key) != m_value.object->end());
+ JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
return m_value.object->find(key)->second;
}
@@ -19491,7 +20115,7 @@ class basic_json
// at only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
- assert(m_value.object->find(key) != m_value.object->end());
+ JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
return m_value.object->find(key)->second;
}
@@ -19548,9 +20172,10 @@ class basic_json
@since version 1.0.0
*/
- template<class ValueType, typename std::enable_if<
- std::is_convertible<basic_json_t, ValueType>::value
- and not std::is_same<value_t, ValueType>::value, int>::type = 0>
+ // using std::is_convertible in a std::enable_if will fail when using explicit conversions
+ template < class ValueType, typename std::enable_if <
+ detail::is_getable<basic_json_t, ValueType>::value
+ && !std::is_same<value_t, ValueType>::value, int >::type = 0 >
ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
{
// at only works for objects
@@ -19560,7 +20185,7 @@ class basic_json
const auto it = find(key);
if (it != end())
{
- return *it;
+ return it->template get<ValueType>();
}
return default_value;
@@ -19622,7 +20247,7 @@ class basic_json
@since version 2.0.2
*/
template<class ValueType, typename std::enable_if<
- std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
+ detail::is_getable<basic_json_t, ValueType>::value, int>::type = 0>
ValueType value(const json_pointer& ptr, const ValueType& default_value) const
{
// at only works for objects
@@ -19631,7 +20256,7 @@ class basic_json
// if pointer resolves a value, return it or use default value
JSON_TRY
{
- return ptr.get_checked(this);
+ return ptr.get_checked(this).template get<ValueType>();
}
JSON_INTERNAL_CATCH (out_of_range&)
{
@@ -19784,10 +20409,10 @@ class basic_json
@since version 1.0.0
*/
- template<class IteratorType, typename std::enable_if<
- std::is_same<IteratorType, typename basic_json_t::iterator>::value or
- std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
- = 0>
+ template < class IteratorType, typename std::enable_if <
+ std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+ std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
+ = 0 >
IteratorType erase(IteratorType pos)
{
// make sure iterator fits the current value
@@ -19807,7 +20432,7 @@ class basic_json
case value_t::string:
case value_t::binary:
{
- if (JSON_HEDLEY_UNLIKELY(not pos.m_it.primitive_iterator.is_begin()))
+ if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
{
JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
}
@@ -19897,14 +20522,14 @@ class basic_json
@since version 1.0.0
*/
- template<class IteratorType, typename std::enable_if<
- std::is_same<IteratorType, typename basic_json_t::iterator>::value or
- std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
- = 0>
+ template < class IteratorType, typename std::enable_if <
+ std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+ std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
+ = 0 >
IteratorType erase(IteratorType first, IteratorType last)
{
// make sure iterator fits the current value
- if (JSON_HEDLEY_UNLIKELY(this != first.m_object or this != last.m_object))
+ if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
{
JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
}
@@ -19920,8 +20545,8 @@ class basic_json
case value_t::string:
case value_t::binary:
{
- if (JSON_HEDLEY_LIKELY(not first.m_it.primitive_iterator.is_begin()
- or not last.m_it.primitive_iterator.is_end()))
+ if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
+ || !last.m_it.primitive_iterator.is_end()))
{
JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
}
@@ -20166,11 +20791,11 @@ class basic_json
@since version 3.6.0
*/
- template<typename KeyT, typename std::enable_if<
- not std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int>::type = 0>
+ template < typename KeyT, typename std::enable_if <
+ !std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int >::type = 0 >
bool contains(KeyT && key) const
{
- return is_object() and m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
+ return is_object() && m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
}
/*!
@@ -20988,7 +21613,7 @@ class basic_json
void push_back(basic_json&& val)
{
// push_back only works for null objects or arrays
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
+ if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
}
@@ -21023,7 +21648,7 @@ class basic_json
void push_back(const basic_json& val)
{
// push_back only works for null objects or arrays
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
+ if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
}
@@ -21073,7 +21698,7 @@ class basic_json
void push_back(const typename object_t::value_type& val)
{
// push_back only works for null objects or objects
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_object())))
+ if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
{
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
}
@@ -21127,7 +21752,7 @@ class basic_json
*/
void push_back(initializer_list_t init)
{
- if (is_object() and init.size() == 2 and (*init.begin())->is_string())
+ if (is_object() && init.size() == 2 && (*init.begin())->is_string())
{
basic_json&& key = init.begin()->moved_or_copied();
push_back(typename object_t::value_type(
@@ -21176,7 +21801,7 @@ class basic_json
reference emplace_back(Args&& ... args)
{
// emplace_back only works for null objects or arrays
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
+ if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
}
@@ -21229,7 +21854,7 @@ class basic_json
std::pair<iterator, bool> emplace(Args&& ... args)
{
// emplace only works for null objects or arrays
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_object())))
+ if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
{
JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
}
@@ -21259,7 +21884,7 @@ class basic_json
iterator insert_iterator(const_iterator pos, Args&& ... args)
{
iterator result(this);
- assert(m_value.array != nullptr);
+ JSON_ASSERT(m_value.array != nullptr);
auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
@@ -21396,7 +22021,7 @@ class basic_json
iterator insert(const_iterator pos, const_iterator first, const_iterator last)
{
// insert only works for arrays
- if (JSON_HEDLEY_UNLIKELY(not is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!is_array()))
{
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
}
@@ -21449,7 +22074,7 @@ class basic_json
iterator insert(const_iterator pos, initializer_list_t ilist)
{
// insert only works for arrays
- if (JSON_HEDLEY_UNLIKELY(not is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!is_array()))
{
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
}
@@ -21490,7 +22115,7 @@ class basic_json
void insert(const_iterator first, const_iterator last)
{
// insert only works for objects
- if (JSON_HEDLEY_UNLIKELY(not is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
}
@@ -21502,7 +22127,7 @@ class basic_json
}
// passed iterators must belong to objects
- if (JSON_HEDLEY_UNLIKELY(not first.m_object->is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
{
JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
}
@@ -21539,11 +22164,11 @@ class basic_json
assert_invariant();
}
- if (JSON_HEDLEY_UNLIKELY(not is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
}
- if (JSON_HEDLEY_UNLIKELY(not j.is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
{
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
}
@@ -21590,7 +22215,7 @@ class basic_json
assert_invariant();
}
- if (JSON_HEDLEY_UNLIKELY(not is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
}
@@ -21602,8 +22227,8 @@ class basic_json
}
// passed iterators must belong to objects
- if (JSON_HEDLEY_UNLIKELY(not first.m_object->is_object()
- or not last.m_object->is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()
+ || !last.m_object->is_object()))
{
JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
}
@@ -21632,9 +22257,9 @@ class basic_json
@since version 1.0.0
*/
void swap(reference other) noexcept (
- std::is_nothrow_move_constructible<value_t>::value and
- std::is_nothrow_move_assignable<value_t>::value and
- std::is_nothrow_move_constructible<json_value>::value and
+ std::is_nothrow_move_constructible<value_t>::value&&
+ std::is_nothrow_move_assignable<value_t>::value&&
+ std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value
)
{
@@ -21646,6 +22271,34 @@ class basic_json
/*!
@brief exchanges the values
+ Exchanges the contents of the JSON value from @a left with those of @a right. Does not
+ invoke any move, copy, or swap operations on individual elements. All
+ iterators and references remain valid. The past-the-end iterator is
+ invalidated. implemented as a friend function callable via ADL.
+
+ @param[in,out] left JSON value to exchange the contents with
+ @param[in,out] right JSON value to exchange the contents with
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how JSON values can be swapped with
+ `swap()`.,swap__reference}
+
+ @since version 1.0.0
+ */
+ friend void swap(reference left, reference right) noexcept (
+ std::is_nothrow_move_constructible<value_t>::value&&
+ std::is_nothrow_move_assignable<value_t>::value&&
+ std::is_nothrow_move_constructible<json_value>::value&&
+ std::is_nothrow_move_assignable<json_value>::value
+ )
+ {
+ left.swap(right);
+ }
+
+ /*!
+ @brief exchanges the values
+
Exchanges the contents of a JSON array with those of @a other. Does not
invoke any move, copy, or swap operations on individual elements. All
iterators and references remain valid. The past-the-end iterator is
@@ -21894,27 +22547,27 @@ class basic_json
return false;
}
}
- else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+ else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
{
return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
}
- else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+ else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
{
return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
}
- else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
+ else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
{
return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
}
- else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
+ else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
{
return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
}
- else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
+ else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
{
return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
}
- else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
+ else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
{
return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
}
@@ -21964,7 +22617,7 @@ class basic_json
*/
friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
{
- return not (lhs == rhs);
+ return !(lhs == rhs);
}
/*!
@@ -22057,27 +22710,27 @@ class basic_json
return false;
}
}
- else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+ else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
{
return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
}
- else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+ else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
{
return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
}
- else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
+ else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
{
return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
}
- else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
+ else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
{
return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
}
- else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
+ else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
{
return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
}
- else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
+ else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
{
return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
}
@@ -22131,7 +22784,7 @@ class basic_json
*/
friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
{
- return not (rhs < lhs);
+ return !(rhs < lhs);
}
/*!
@@ -22177,7 +22830,7 @@ class basic_json
*/
friend bool operator>(const_reference lhs, const_reference rhs) noexcept
{
- return not (lhs <= rhs);
+ return !(lhs <= rhs);
}
/*!
@@ -22223,7 +22876,7 @@ class basic_json
*/
friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
{
- return not (lhs < rhs);
+ return !(lhs < rhs);
}
/*!
@@ -22344,6 +22997,9 @@ class basic_json
(optional)
@param[in] allow_exceptions whether to throw exceptions in case of a
parse error (optional, true by default)
+ @param[in] ignore_comments whether comments should be ignored and treated
+ like whitespace (true) or yield a parse error (true); (optional, false by
+ default)
@return deserialized JSON value; in case of a parse error and
@a allow_exceptions set to `false`, the return value will be
@@ -22372,16 +23028,18 @@ class basic_json
@liveexample{The example below demonstrates the `parse()` function reading
from a contiguous container.,parse__contiguouscontainer__parser_callback_t}
- @since version 2.0.3 (contiguous containers)
+ @since version 2.0.3 (contiguous containers); version 3.9.0 allowed to
+ ignore comments.
*/
template<typename InputType>
JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json parse(InputType&& i,
const parser_callback_t cb = nullptr,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const bool ignore_comments = false)
{
basic_json result;
- parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions).parse(true, result);
+ parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
return result;
}
@@ -22398,6 +23056,9 @@ class basic_json
(optional)
@param[in] allow_exceptions whether to throw exceptions in case of a
parse error (optional, true by default)
+ @param[in] ignore_comments whether comments should be ignored and treated
+ like whitespace (true) or yield a parse error (true); (optional, false by
+ default)
@return deserialized JSON value; in case of a parse error and
@a allow_exceptions set to `false`, the return value will be
@@ -22413,10 +23074,11 @@ class basic_json
static basic_json parse(IteratorType first,
IteratorType last,
const parser_callback_t cb = nullptr,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const bool ignore_comments = false)
{
basic_json result;
- parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions).parse(true, result);
+ parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
return result;
}
@@ -22424,10 +23086,11 @@ class basic_json
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
static basic_json parse(detail::span_input_adapter&& i,
const parser_callback_t cb = nullptr,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const bool ignore_comments = false)
{
basic_json result;
- parser(i.get(), cb, allow_exceptions).parse(true, result);
+ parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
return result;
}
@@ -22447,6 +23110,9 @@ class basic_json
iterators.
@param[in] i input to read from
+ @param[in] ignore_comments whether comments should be ignored and treated
+ like whitespace (true) or yield a parse error (true); (optional, false by
+ default)
@return Whether the input read from @a i is valid JSON.
@@ -22459,22 +23125,25 @@ class basic_json
from a string.,accept__string}
*/
template<typename InputType>
- static bool accept(InputType&& i)
+ static bool accept(InputType&& i,
+ const bool ignore_comments = false)
{
- return parser(detail::input_adapter(std::forward<InputType>(i))).accept(true);
+ return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
}
template<typename IteratorType>
- static bool accept(IteratorType first, IteratorType last)
+ static bool accept(IteratorType first, IteratorType last,
+ const bool ignore_comments = false)
{
- return parser(detail::input_adapter(std::move(first), std::move(last))).accept(true);
+ return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
}
JSON_HEDLEY_WARN_UNUSED_RESULT
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
- static bool accept(detail::span_input_adapter&& i)
+ static bool accept(detail::span_input_adapter&& i,
+ const bool ignore_comments = false)
{
- return parser(i.get()).accept(true);
+ return parser(i.get(), nullptr, false, ignore_comments).accept(true);
}
/*!
@@ -22494,6 +23163,9 @@ class basic_json
@param[in,out] sax SAX event listener
@param[in] format the format to parse (JSON, CBOR, MessagePack, or UBJSON)
@param[in] strict whether the input has to be consumed completely
+ @param[in] ignore_comments whether comments should be ignored and treated
+ like whitespace (true) or yield a parse error (true); (optional, false by
+ default); only applies to the JSON file format.
@return return value of the last processed SAX event
@@ -22518,11 +23190,12 @@ class basic_json
JSON_HEDLEY_NON_NULL(2)
static bool sax_parse(InputType&& i, SAX* sax,
input_format_t format = input_format_t::json,
- const bool strict = true)
+ const bool strict = true,
+ const bool ignore_comments = false)
{
auto ia = detail::input_adapter(std::forward<InputType>(i));
return format == input_format_t::json
- ? parser(std::move(ia)).sax_parse(sax, strict)
+ ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
}
@@ -22530,11 +23203,12 @@ class basic_json
JSON_HEDLEY_NON_NULL(3)
static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
input_format_t format = input_format_t::json,
- const bool strict = true)
+ const bool strict = true,
+ const bool ignore_comments = false)
{
auto ia = detail::input_adapter(std::move(first), std::move(last));
return format == input_format_t::json
- ? parser(std::move(ia)).sax_parse(sax, strict)
+ ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
}
@@ -22543,11 +23217,12 @@ class basic_json
JSON_HEDLEY_NON_NULL(2)
static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
input_format_t format = input_format_t::json,
- const bool strict = true)
+ const bool strict = true,
+ const bool ignore_comments = false)
{
auto ia = i.get();
return format == input_format_t::json
- ? parser(std::move(ia)).sax_parse(sax, strict)
+ ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
}
@@ -22749,7 +23424,6 @@ class basic_json
- bignum (0xC2..0xC3)
- decimal fraction (0xC4)
- bigfloat (0xC5)
- - tagged items (0xC6..0xD4, 0xD8..0xDB)
- expected conversions (0xD5..0xD7)
- simple values (0xE0..0xF3, 0xF8)
- undefined (0xF7)
@@ -22765,7 +23439,7 @@ class basic_json
vector in CBOR format.,to_cbor}
@sa http://cbor.io
- @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+ @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
analogous deserialization
@sa @ref to_msgpack(const basic_json&) for the related MessagePack format
@sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
@@ -22821,7 +23495,8 @@ class basic_json
number_unsigned | 256..65535 | uint 16 | 0xCD
number_unsigned | 65536..4294967295 | uint 32 | 0xCE
number_unsigned | 4294967296..18446744073709551615 | uint 64 | 0xCF
- number_float | *any value* | float 64 | 0xCB
+ number_float | *any value representable by a float* | float 32 | 0xCA
+ number_float | *any value NOT representable by a float* | float 64 | 0xCB
string | *length*: 0..31 | fixstr | 0xA0..0xBF
string | *length*: 32..255 | str 8 | 0xD9
string | *length*: 256..65535 | str 16 | 0xDA
@@ -22845,9 +23520,6 @@ class basic_json
- arrays with more than 4294967295 elements
- objects with more than 4294967295 elements
- @note The following MessagePack types are not used in the conversion:
- - float 32 (0xCA)
-
@note Any MessagePack output created @ref to_msgpack can be successfully
parsed by @ref from_msgpack.
@@ -22916,6 +23588,7 @@ class basic_json
number_unsigned | 256..32767 | int16 | `I`
number_unsigned | 32768..2147483647 | int32 | `l`
number_unsigned | 2147483648..9223372036854775807 | int64 | `L`
+ number_unsigned | 2147483649..18446744073709551615 | high-precision | `H`
number_float | *any value* | float64 | `D`
string | *with shortest length indicator* | string | `S`
array | *see notes on optimized format* | array | `[`
@@ -22926,7 +23599,6 @@ class basic_json
@note The following values can **not** be converted to a UBJSON value:
- strings with more than 9223372036854775807 bytes (theoretical)
- - unsigned integer numbers above 9223372036854775807
@note The following markers are not used in the conversion:
- `Z`: no-op values are not created.
@@ -23138,7 +23810,6 @@ class basic_json
- bignum (0xC2..0xC3)
- decimal fraction (0xC4)
- bigfloat (0xC5)
- - tagged items (0xC6..0xD4, 0xD8..0xDB)
- expected conversions (0xD5..0xD7)
- simple values (0xE0..0xF3, 0xF8)
- undefined (0xF7)
@@ -23155,6 +23826,7 @@ class basic_json
(true by default)
@param[in] allow_exceptions whether to throw exceptions in case of a
parse error (optional, true by default)
+ @param[in] tag_handler how to treat CBOR tags (optional, error by default)
@return deserialized JSON value; in case of a parse error and
@a allow_exceptions set to `false`, the return value will be
@@ -23181,34 +23853,36 @@ class basic_json
@since version 2.0.9; parameter @a start_index since 2.1.1; changed to
consume input adapters, removed start_index parameter, and added
@a strict parameter since 3.0.0; added @a allow_exceptions parameter
- since 3.2.0
+ since 3.2.0; added @a tag_handler parameter since 3.9.0.
*/
template<typename InputType>
JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json from_cbor(InputType&& i,
const bool strict = true,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
{
basic_json result;
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
auto ia = detail::input_adapter(std::forward<InputType>(i));
- const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict);
+ const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
return res ? result : basic_json(value_t::discarded);
}
/*!
- @copydoc from_cbor(detail::input_adapter&&, const bool, const bool)
+ @copydoc from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t)
*/
template<typename IteratorType>
JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json from_cbor(IteratorType first, IteratorType last,
const bool strict = true,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
{
basic_json result;
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
auto ia = detail::input_adapter(std::move(first), std::move(last));
- const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict);
+ const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
return res ? result : basic_json(value_t::discarded);
}
@@ -23217,9 +23891,10 @@ class basic_json
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
static basic_json from_cbor(const T* ptr, std::size_t len,
const bool strict = true,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
{
- return from_cbor(ptr, ptr + len, strict, allow_exceptions);
+ return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
}
@@ -23227,12 +23902,13 @@ class basic_json
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
static basic_json from_cbor(detail::span_input_adapter&& i,
const bool strict = true,
- const bool allow_exceptions = true)
+ const bool allow_exceptions = true,
+ const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
{
basic_json result;
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
auto ia = i.get();
- const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict);
+ const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
return res ? result : basic_json(value_t::discarded);
}
@@ -23310,7 +23986,7 @@ class basic_json
@sa http://msgpack.org
@sa @ref to_msgpack(const basic_json&) for the analogous serialization
- @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+ @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
related CBOR format
@sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for
the related UBJSON format
@@ -23397,6 +24073,7 @@ class basic_json
int16 | number_integer | `I`
int32 | number_integer | `l`
int64 | number_integer | `L`
+ high-precision number | number_integer, number_unsigned, or number_float - depends on number string | 'H'
string | string | `S`
char | string | `C`
array | array (optimized values are supported) | `[`
@@ -23428,7 +24105,7 @@ class basic_json
@sa http://ubjson.org
@sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
analogous serialization
- @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+ @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
related CBOR format
@sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
the related MessagePack format
@@ -23543,7 +24220,7 @@ class basic_json
@sa http://bsonspec.org/spec.html
@sa @ref to_bson(const basic_json&) for the analogous serialization
- @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+ @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
related CBOR format
@sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
the related MessagePack format
@@ -23962,7 +24639,7 @@ class basic_json
else
{
const auto idx = json_pointer::array_index(last_path);
- if (JSON_HEDLEY_UNLIKELY(static_cast<size_type>(idx) > parent.size()))
+ if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
{
// avoid undefined behavior
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
@@ -23976,7 +24653,7 @@ class basic_json
// if there exists a parent it cannot be primitive
default: // LCOV_EXCL_LINE
- assert(false); // LCOV_EXCL_LINE
+ JSON_ASSERT(false); // LCOV_EXCL_LINE
}
};
@@ -24005,12 +24682,12 @@ class basic_json
else if (parent.is_array())
{
// note erase performs range check
- parent.erase(static_cast<size_type>(json_pointer::array_index(last_path)));
+ parent.erase(json_pointer::array_index(last_path));
}
};
// type check: top level value must be an array
- if (JSON_HEDLEY_UNLIKELY(not json_patch.is_array()))
+ if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
{
JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
}
@@ -24036,7 +24713,7 @@ class basic_json
}
// check if result is of type string
- if (JSON_HEDLEY_UNLIKELY(string_type and not it->second.is_string()))
+ if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
{
JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
}
@@ -24046,14 +24723,14 @@ class basic_json
};
// type check: every element of the array must be an object
- if (JSON_HEDLEY_UNLIKELY(not val.is_object()))
+ if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
{
JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
}
// collect mandatory members
- const std::string op = get_value("op", "op", true);
- const std::string path = get_value(op, "path", true);
+ const auto op = get_value("op", "op", true).template get<std::string>();
+ const auto path = get_value(op, "path", true).template get<std::string>();
json_pointer ptr(path);
switch (get_op(op))
@@ -24079,7 +24756,7 @@ class basic_json
case patch_operations::move:
{
- const std::string from_path = get_value("move", "from", true);
+ const auto from_path = get_value("move", "from", true).template get<std::string>();
json_pointer from_ptr(from_path);
// the "from" location must exist - use at()
@@ -24096,7 +24773,7 @@ class basic_json
case patch_operations::copy:
{
- const std::string from_path = get_value("copy", "from", true);
+ const auto from_path = get_value("copy", "from", true).template get<std::string>();
const json_pointer from_ptr(from_path);
// the "from" location must exist - use at()
@@ -24124,7 +24801,7 @@ class basic_json
}
// throw an exception if test fails
- if (JSON_HEDLEY_UNLIKELY(not success))
+ if (JSON_HEDLEY_UNLIKELY(!success))
{
JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
}
@@ -24206,7 +24883,7 @@ class basic_json
{
// first pass: traverse common elements
std::size_t i = 0;
- while (i < source.size() and i < target.size())
+ while (i < source.size() && i < target.size())
{
// recursive call to compare array values at index i
auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
@@ -24357,7 +25034,7 @@ class basic_json
{
if (apply_patch.is_object())
{
- if (not is_object())
+ if (!is_object())
{
*this = object();
}
@@ -24417,9 +25094,7 @@ struct hash<nlohmann::json>
*/
std::size_t operator()(const nlohmann::json& j) const
{
- // a naive hashing via the string representation
- const auto& h = hash<nlohmann::json::string_t>();
- return h(j.dump());
+ return nlohmann::detail::hash(j);
}
};
@@ -24440,6 +25115,9 @@ struct less<::nlohmann::detail::value_t>
}
};
+// C++20 prohibit function specialization in the std namespace.
+#ifndef JSON_HAS_CPP_20
+
/*!
@brief exchanges the values of two JSON objects
@@ -24447,13 +25125,15 @@ struct less<::nlohmann::detail::value_t>
*/
template<>
inline void swap<nlohmann::json>(nlohmann::json& j1, nlohmann::json& j2) noexcept(
- is_nothrow_move_constructible<nlohmann::json>::value and
+ is_nothrow_move_constructible<nlohmann::json>::value&&
is_nothrow_move_assignable<nlohmann::json>::value
-)
+ )
{
j1.swap(j2);
}
+#endif
+
} // namespace std
/*!
@@ -24506,6 +25186,7 @@ inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std
#endif
// clean up
+#undef JSON_ASSERT
#undef JSON_INTERNAL_CATCH
#undef JSON_CATCH
#undef JSON_THROW
@@ -24514,6 +25195,7 @@ inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std
#undef JSON_HAS_CPP_17
#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
#undef NLOHMANN_BASIC_JSON_TPL
+#undef JSON_EXPLICIT
// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
#undef JSON_HEDLEY_ALWAYS_INLINE
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index fdf5ac5b..76ba31d8 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -95,6 +95,7 @@ set(files
src/unit-algorithms.cpp
src/unit-allocator.cpp
src/unit-alt-string.cpp
+ src/unit-assert_macro.cpp
src/unit-bson.cpp
src/unit-capacity.cpp
src/unit-cbor.cpp
@@ -111,6 +112,7 @@ set(files
src/unit-deserialization.cpp
src/unit-element_access1.cpp
src/unit-element_access2.cpp
+ src/unit-hash.cpp
src/unit-inspection.cpp
src/unit-items.cpp
src/unit-iterators1.cpp
@@ -123,6 +125,7 @@ set(files
src/unit-modifiers.cpp
src/unit-msgpack.cpp
src/unit-noexcept.cpp
+ src/unit-ordered_json.cpp
src/unit-pointer_access.cpp
src/unit-readme.cpp
src/unit-reference_access.cpp
@@ -132,6 +135,7 @@ set(files
src/unit-to_chars.cpp
src/unit-ubjson.cpp
src/unit-udt.cpp
+ src/unit-udt_macro.cpp
src/unit-unicode.cpp
src/unit-user_defined_input.cpp
src/unit-wstring.cpp)
@@ -189,3 +193,4 @@ add_subdirectory(cmake_import)
add_subdirectory(cmake_import_minver)
add_subdirectory(cmake_add_subdirectory)
add_subdirectory(cmake_fetch_content)
+add_subdirectory(cmake_target_include_directories)
diff --git a/test/Makefile b/test/Makefile
index bcf8de7d..2d08a8f7 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -1,98 +1,13 @@
-##########################################################################
-# unit tests
-##########################################################################
+##############################################################################
+# OSS-Fuzz
+##############################################################################
+
+# The following targets realize the integration to OSS-Fuzz.
+# See <https://github.com/google/oss-fuzz/blob/master/projects/json/build.sh> for more information.
# additional flags
-CXXFLAGS += -std=c++11 -Wall -Wextra -pedantic -Wcast-align -Wcast-qual -Wno-ctor-dtor-privacy -Wdisabled-optimization -Wformat=2 -Winit-self -Wmissing-declarations -Wmissing-include-dirs -Wold-style-cast -Woverloaded-virtual -Wredundant-decls -Wshadow -Wsign-conversion -Wsign-promo -Wstrict-overflow=5 -Wswitch -Wundef -Wno-unused -Wnon-virtual-dtor -Wreorder -Wdeprecated -Wno-float-equal
-CPPFLAGS += -I ../single_include -I . -I thirdparty/doctest -I thirdparty/fifo_map -DDOCTEST_CONFIG_SUPER_FAST_ASSERTS
-
-SOURCES = src/unit.cpp \
- src/unit-algorithms.cpp \
- src/unit-allocator.cpp \
- src/unit-alt-string.cpp \
- src/unit-bson.cpp \
- src/unit-capacity.cpp \
- src/unit-cbor.cpp \
- src/unit-class_const_iterator.cpp \
- src/unit-class_iterator.cpp \
- src/unit-class_lexer.cpp \
- src/unit-class_parser.cpp \
- src/unit-comparison.cpp \
- src/unit-concepts.cpp \
- src/unit-constructor1.cpp \
- src/unit-constructor2.cpp \
- src/unit-convenience.cpp \
- src/unit-conversions.cpp \
- src/unit-deserialization.cpp \
- src/unit-element_access1.cpp \
- src/unit-element_access2.cpp \
- src/unit-inspection.cpp \
- src/unit-items.cpp \
- src/unit-iterators1.cpp \
- src/unit-iterators2.cpp \
- src/unit-merge_patch.cpp \
- src/unit-json_patch.cpp \
- src/unit-json_pointer.cpp \
- src/unit-meta.cpp \
- src/unit-modifiers.cpp \
- src/unit-msgpack.cpp \
- src/unit-pointer_access.cpp \
- src/unit-readme.cpp \
- src/unit-reference_access.cpp \
- src/unit-regression.cpp \
- src/unit-serialization.cpp \
- src/unit-testsuites.cpp \
- src/unit-ubjson.cpp \
- src/unit-unicode.cpp \
- src/unit-user_defined_input.cpp \
- src/unit-wstring.cpp
-
-OBJECTS = $(SOURCES:.cpp=.o)
-
-TESTCASES = $(patsubst src/unit-%.cpp,test-%,$(wildcard src/unit-*.cpp))
-
-##############################################################################
-# main rules
-##############################################################################
-
-all: $(TESTCASES)
-
-clean:
- rm -fr json_unit $(OBJECTS) $(SOURCES:.cpp=.gcno) $(SOURCES:.cpp=.gcda) $(TESTCASES) $(FUZZERS) test_data.hpp
-
-test_data.hpp:
- @echo "#define TEST_DATA_DIRECTORY" > $@
-
-##############################################################################
-# single test file
-##############################################################################
-
-json_unit: $(OBJECTS) ../single_include/nlohmann/json.hpp thirdparty/doctest/doctest.h
- @echo "[CXXLD] $@"
- @$(CXX) $(CXXFLAGS) $(LDFLAGS) $(OBJECTS) -o $@
-
-%.o: %.cpp ../single_include/nlohmann/json.hpp thirdparty/doctest/doctest.h test_data.hpp
- @echo "[CXX] $@"
- @$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $< -o $@
-
-
-##############################################################################
-# individual test cases
-##############################################################################
-
-test-%: src/unit-%.o src/unit.o ../single_include/nlohmann/json.hpp thirdparty/doctest/doctest.h test_data.hpp
- @echo "[CXXLD] $@"
- @$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS) $< src/unit.o -o $@
-
-TEST_PATTERN ?= "*"
-TEST_PREFIX = ""
-check: $(OBJECTS) $(TESTCASES)
- @cd .. ; for testcase in $(TESTCASES); do echo "Executing $$testcase..."; $(TEST_PREFIX)test/$$testcase $(TEST_PATTERN) || exit 1; done
-
-
-##############################################################################
-# fuzzer
-##############################################################################
+CXXFLAGS += -std=c++11
+CPPFLAGS += -I ../single_include
FUZZER_ENGINE = src/fuzzer-driver_afl.cpp
FUZZERS = parse_afl_fuzzer parse_bson_fuzzer parse_cbor_fuzzer parse_msgpack_fuzzer parse_ubjson_fuzzer
diff --git a/test/cmake_fetch_content/CMakeLists.txt b/test/cmake_fetch_content/CMakeLists.txt
index 6d92d149..0b0d9f65 100644
--- a/test/cmake_fetch_content/CMakeLists.txt
+++ b/test/cmake_fetch_content/CMakeLists.txt
@@ -11,8 +11,10 @@ if (${CMAKE_VERSION} VERSION_GREATER "3.11.0")
)
set_tests_properties(cmake_fetch_content_configure PROPERTIES
FIXTURES_SETUP cmake_fetch_content
+ LABELS git_required
)
set_tests_properties(cmake_fetch_content_build PROPERTIES
FIXTURES_REQUIRED cmake_fetch_content
+ LABELS git_required
)
endif()
diff --git a/test/cmake_fetch_content/project/CMakeLists.txt b/test/cmake_fetch_content/project/CMakeLists.txt
index 742a112b..fd8fbdd5 100644
--- a/test/cmake_fetch_content/project/CMakeLists.txt
+++ b/test/cmake_fetch_content/project/CMakeLists.txt
@@ -4,9 +4,8 @@ project(DummyImport CXX)
include(FetchContent)
-FetchContent_Declare(json
- GIT_REPOSITORY ${CMAKE_CURRENT_SOURCE_DIR}/../../..
- GIT_TAG HEAD)
+get_filename_component(GIT_REPOSITORY_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../../.. ABSOLUTE)
+FetchContent_Declare(json GIT_REPOSITORY ${GIT_REPOSITORY_DIRECTORY} GIT_TAG HEAD)
FetchContent_GetProperties(json)
if(NOT json_POPULATED)
diff --git a/test/cmake_target_include_directories/CMakeLists.txt b/test/cmake_target_include_directories/CMakeLists.txt
new file mode 100644
index 00000000..da738ea4
--- /dev/null
+++ b/test/cmake_target_include_directories/CMakeLists.txt
@@ -0,0 +1,16 @@
+add_test(NAME cmake_target_include_directories_configure
+ COMMAND ${CMAKE_COMMAND}
+ -G "${CMAKE_GENERATOR}"
+ -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+ -Dnlohmann_json_source=${PROJECT_SOURCE_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}/project
+)
+add_test(NAME cmake_target_include_directories_build
+ COMMAND ${CMAKE_COMMAND} --build .
+)
+set_tests_properties(cmake_target_include_directories_configure PROPERTIES
+ FIXTURES_SETUP cmake_target_include_directories
+)
+set_tests_properties(cmake_target_include_directories_build PROPERTIES
+ FIXTURES_REQUIRED cmake_target_include_directories
+)
diff --git a/test/cmake_target_include_directories/project/Bar.cpp b/test/cmake_target_include_directories/project/Bar.cpp
new file mode 100644
index 00000000..ed39e284
--- /dev/null
+++ b/test/cmake_target_include_directories/project/Bar.cpp
@@ -0,0 +1,3 @@
+#include "Bar.hpp"
+
+class Bar;
diff --git a/test/cmake_target_include_directories/project/Bar.hpp b/test/cmake_target_include_directories/project/Bar.hpp
new file mode 100644
index 00000000..bdb1d9b5
--- /dev/null
+++ b/test/cmake_target_include_directories/project/Bar.hpp
@@ -0,0 +1,4 @@
+#include <nlohmann/json.hpp>
+#include "Foo.hpp"
+
+class Bar : public Foo{};
diff --git a/test/cmake_target_include_directories/project/CMakeLists.txt b/test/cmake_target_include_directories/project/CMakeLists.txt
new file mode 100644
index 00000000..f56786c0
--- /dev/null
+++ b/test/cmake_target_include_directories/project/CMakeLists.txt
@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.1)
+
+project(DummyImport CXX)
+
+add_executable(with_private_target main.cpp)
+target_include_directories(with_private_target PRIVATE ${nlohmann_json_source}/include)
+set_target_properties(with_private_target PROPERTIES CXX_STANDARD 11)
+
+add_executable(with_private_system_target main.cpp)
+target_include_directories(with_private_system_target PRIVATE SYSTEM ${nlohmann_json_source}/include)
+set_target_properties(with_private_system_target PROPERTIES CXX_STANDARD 11)
+
+# regression from https://github.com/nlohmann/json/discussions/2281
+add_library(Foo STATIC Foo.cpp Bar.cpp)
+target_include_directories(Foo PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${nlohmann_json_source}/include)
+set_target_properties(Foo PROPERTIES CXX_STANDARD 11)
+
+add_library(Bar STATIC Bar.cpp)
+target_link_libraries(Bar PRIVATE Foo)
+target_include_directories(Bar PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${nlohmann_json_source}/include)
+set_target_properties(Bar PROPERTIES CXX_STANDARD 11)
diff --git a/test/cmake_target_include_directories/project/Foo.cpp b/test/cmake_target_include_directories/project/Foo.cpp
new file mode 100644
index 00000000..6a2ff91a
--- /dev/null
+++ b/test/cmake_target_include_directories/project/Foo.cpp
@@ -0,0 +1,3 @@
+#include "Foo.hpp"
+
+class Foo;
diff --git a/test/cmake_target_include_directories/project/Foo.hpp b/test/cmake_target_include_directories/project/Foo.hpp
new file mode 100644
index 00000000..fd6b1ffa
--- /dev/null
+++ b/test/cmake_target_include_directories/project/Foo.hpp
@@ -0,0 +1,4 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+class Foo{};
diff --git a/test/cmake_target_include_directories/project/main.cpp b/test/cmake_target_include_directories/project/main.cpp
new file mode 100644
index 00000000..d2d118b8
--- /dev/null
+++ b/test/cmake_target_include_directories/project/main.cpp
@@ -0,0 +1,8 @@
+#include <nlohmann/json.hpp>
+
+int main(int argc, char **argv)
+{
+ nlohmann::json j;
+
+ return 0;
+}
diff --git a/test/src/fuzzer-driver_afl.cpp b/test/src/fuzzer-driver_afl.cpp
index a14ceaac..a9368ca9 100644
--- a/test/src/fuzzer-driver_afl.cpp
+++ b/test/src/fuzzer-driver_afl.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (fuzz test support)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
This file implements a driver for American Fuzzy Lop (afl-fuzz). It relies on
diff --git a/test/src/fuzzer-parse_bson.cpp b/test/src/fuzzer-parse_bson.cpp
index 9a43d203..1d26a776 100644
--- a/test/src/fuzzer-parse_bson.cpp
+++ b/test/src/fuzzer-parse_bson.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (fuzz test support)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
This file implements a parser test suitable for fuzz testing. Given a byte
diff --git a/test/src/fuzzer-parse_cbor.cpp b/test/src/fuzzer-parse_cbor.cpp
index 43061e06..7d312306 100644
--- a/test/src/fuzzer-parse_cbor.cpp
+++ b/test/src/fuzzer-parse_cbor.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (fuzz test support)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
This file implements a parser test suitable for fuzz testing. Given a byte
diff --git a/test/src/fuzzer-parse_json.cpp b/test/src/fuzzer-parse_json.cpp
index 1b193f6d..4bc54bab 100644
--- a/test/src/fuzzer-parse_json.cpp
+++ b/test/src/fuzzer-parse_json.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (fuzz test support)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
This file implements a parser test suitable for fuzz testing. Given a byte
diff --git a/test/src/fuzzer-parse_msgpack.cpp b/test/src/fuzzer-parse_msgpack.cpp
index c771c546..8d17b5d9 100644
--- a/test/src/fuzzer-parse_msgpack.cpp
+++ b/test/src/fuzzer-parse_msgpack.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (fuzz test support)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
This file implements a parser test suitable for fuzz testing. Given a byte
diff --git a/test/src/fuzzer-parse_ubjson.cpp b/test/src/fuzzer-parse_ubjson.cpp
index dd30c36e..3d99abbe 100644
--- a/test/src/fuzzer-parse_ubjson.cpp
+++ b/test/src/fuzzer-parse_ubjson.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (fuzz test support)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
This file implements a parser test suitable for fuzz testing. Given a byte
diff --git a/test/src/test_utils.hpp b/test/src/test_utils.hpp
new file mode 100644
index 00000000..12c260e7
--- /dev/null
+++ b/test/src/test_utils.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <cstdint> // uint8_t
+#include <fstream> // ifstream, istreambuf_iterator, ios
+#include <vector> // vector
+
+namespace utils
+{
+
+inline std::vector<std::uint8_t> read_binary_file(const std::string& filename)
+{
+ std::ifstream file(filename, std::ios::binary);
+ file.unsetf(std::ios::skipws);
+
+ file.seekg(0, std::ios::end);
+ const auto size = file.tellg();
+ file.seekg(0, std::ios::beg);
+
+ std::vector<std::uint8_t> byte_vector;
+ byte_vector.reserve(static_cast<std::size_t>(size));
+ byte_vector.insert(byte_vector.begin(), std::istream_iterator<std::uint8_t>(file), std::istream_iterator<std::uint8_t>());
+ return byte_vector;
+}
+
+} // namespace utils
diff --git a/test/src/unit-algorithms.cpp b/test/src/unit-algorithms.cpp
index 7311aaa3..d59c090c 100644
--- a/test/src/unit-algorithms.cpp
+++ b/test/src/unit-algorithms.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -55,7 +55,7 @@ TEST_CASE("algorithms")
{
CHECK(std::any_of(j_array.begin(), j_array.end(), [](const json & value)
{
- return value.is_string() and value.get<std::string>() == "foo";
+ return value.is_string() && value.get<std::string>() == "foo";
}));
CHECK(std::any_of(j_object.begin(), j_object.end(), [](const json & value)
{
@@ -139,14 +139,14 @@ TEST_CASE("algorithms")
{
CHECK(std::equal(j_array.begin(), j_array.end(), j_array.begin()));
CHECK(std::equal(j_object.begin(), j_object.end(), j_object.begin()));
- CHECK(not std::equal(j_array.begin(), j_array.end(), j_object.begin()));
+ CHECK(!std::equal(j_array.begin(), j_array.end(), j_object.begin()));
}
SECTION("using user-defined comparison")
{
// compare objects only by size of its elements
json j_array2 = {13, 29, 3, {"Hello", "World"}, true, false, {{"one", 1}, {"two", 2}, {"three", 3}}, "foo", "baz"};
- CHECK(not std::equal(j_array.begin(), j_array.end(), j_array2.begin()));
+ CHECK(!std::equal(j_array.begin(), j_array.end(), j_array2.begin()));
CHECK(std::equal(j_array.begin(), j_array.end(), j_array2.begin(),
[](const json & a, const json & b)
{
@@ -213,7 +213,7 @@ TEST_CASE("algorithms")
return v.is_string();
});
CHECK(std::distance(j_array.begin(), it) == 2);
- CHECK(not it[2].is_string());
+ CHECK(!it[2].is_string());
}
}
diff --git a/test/src/unit-allocator.cpp b/test/src/unit-allocator.cpp
index 233b5539..58f4c63a 100644
--- a/test/src/unit-allocator.cpp
+++ b/test/src/unit-allocator.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-alt-string.cpp b/test/src/unit-alt-string.cpp
index 93618273..d5131040 100644
--- a/test/src/unit-alt-string.cpp
+++ b/test/src/unit-alt-string.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-assert_macro.cpp b/test/src/unit-assert_macro.cpp
new file mode 100644
index 00000000..b2a71be9
--- /dev/null
+++ b/test/src/unit-assert_macro.cpp
@@ -0,0 +1,65 @@
+/*
+ __ _____ _____ _____
+ __| | __| | | | JSON for Modern C++ (test suite)
+| | |__ | | | | | | version 3.9.0
+|_____|_____|_____|_|___| https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+// avoid warning when assert does not abort
+#if defined(__GNUC__)
+ #pragma GCC diagnostic ignored "-Wstrict-overflow"
+#endif
+
+#include "doctest_compatibility.h"
+
+/// global variable to record side effect of assert calls
+static int assert_counter;
+
+/// set failure variable to true instead of calling assert(x)
+#define JSON_ASSERT(x) {if (!(x)) ++assert_counter; }
+
+#include <nlohmann/json.hpp>
+using nlohmann::json;
+
+// the test assumes exceptions to work
+#if !defined(JSON_NOEXCEPTION)
+TEST_CASE("JSON_ASSERT(x)")
+{
+ SECTION("basic_json(first, second)")
+ {
+ assert_counter = 0;
+ CHECK(assert_counter == 0);
+
+ json::iterator it;
+ json j;
+
+ // in case assertions do not abort execution, an exception is thrown
+ CHECK_THROWS_WITH_AS(json(it, j.end()), "[json.exception.invalid_iterator.201] iterators are not compatible", json::invalid_iterator);
+
+ // check that assertion actually happened
+ CHECK(assert_counter == 1);
+ }
+}
+#endif
diff --git a/test/src/unit-bson.cpp b/test/src/unit-bson.cpp
index c1489956..42dae1f2 100644
--- a/test/src/unit-bson.cpp
+++ b/test/src/unit-bson.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -35,6 +35,7 @@ using nlohmann::json;
#include <fstream>
#include <sstream>
#include <test_data.hpp>
+#include "test_utils.hpp"
TEST_CASE("BSON")
{
@@ -766,7 +767,7 @@ TEST_CASE("Incomplete BSON Input")
CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
SaxCountdown scp(0);
- CHECK(not json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
+ CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
}
SECTION("Incomplete BSON Input 2")
@@ -784,7 +785,7 @@ TEST_CASE("Incomplete BSON Input")
CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
SaxCountdown scp(0);
- CHECK(not json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
+ CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
}
SECTION("Incomplete BSON Input 3")
@@ -808,7 +809,7 @@ TEST_CASE("Incomplete BSON Input")
CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
SaxCountdown scp(1);
- CHECK(not json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
+ CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
}
SECTION("Incomplete BSON Input 4")
@@ -825,7 +826,7 @@ TEST_CASE("Incomplete BSON Input")
CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
SaxCountdown scp(0);
- CHECK(not json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
+ CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
}
SECTION("Improve coverage")
@@ -835,7 +836,7 @@ TEST_CASE("Incomplete BSON Input")
json j = {{"key", "value"}};
auto bson_vec = json::to_bson(j);
SaxCountdown scp(2);
- CHECK(not json::sax_parse(bson_vec, &scp, json::input_format_t::bson));
+ CHECK(!json::sax_parse(bson_vec, &scp, json::input_format_t::bson));
}
SECTION("array")
@@ -846,7 +847,7 @@ TEST_CASE("Incomplete BSON Input")
};
auto bson_vec = json::to_bson(j);
SaxCountdown scp(2);
- CHECK(not json::sax_parse(bson_vec, &scp, json::input_format_t::bson));
+ CHECK(!json::sax_parse(bson_vec, &scp, json::input_format_t::bson));
}
}
}
@@ -887,7 +888,7 @@ TEST_CASE("Unsupported BSON input")
CHECK(json::from_bson(bson, true, false).is_discarded());
SaxCountdown scp(0);
- CHECK(not json::sax_parse(bson, &scp, json::input_format_t::bson));
+ CHECK(!json::sax_parse(bson, &scp, json::input_format_t::bson));
}
TEST_CASE("BSON numerical data")
@@ -1263,10 +1264,7 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
json j1 = json::parse(f_json);
// parse BSON file
- std::ifstream f_bson(filename + ".bson", std::ios::binary);
- std::vector<std::uint8_t> packed(
- (std::istreambuf_iterator<char>(f_bson)),
- std::istreambuf_iterator<char>());
+ auto packed = utils::read_binary_file(filename + ".bson");
json j2;
CHECK_NOTHROW(j2 = json::from_bson(packed));
@@ -1296,10 +1294,7 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
json j1 = json::parse(f_json);
// parse BSON file
- std::ifstream f_bson(filename + ".bson", std::ios::binary);
- std::vector<std::uint8_t> packed(
- (std::istreambuf_iterator<char>(f_bson)),
- std::istreambuf_iterator<char>());
+ auto packed = utils::read_binary_file(filename + ".bson");
json j2;
CHECK_NOTHROW(j2 = json::from_bson({packed.data(), packed.size()}));
@@ -1314,10 +1309,7 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
json j1 = json::parse(f_json);
// parse BSON file
- std::ifstream f_bson(filename + ".bson", std::ios::binary);
- std::vector<std::uint8_t> packed(
- (std::istreambuf_iterator<char>(f_bson)),
- std::istreambuf_iterator<char>());
+ auto packed = utils::read_binary_file(filename + ".bson");
{
INFO_WITH_TEMP(filename + ": output adapters: std::vector<std::uint8_t>");
diff --git a/test/src/unit-capacity.cpp b/test/src/unit-capacity.cpp
index 0942e5ea..cbe0d6b0 100644
--- a/test/src/unit-capacity.cpp
+++ b/test/src/unit-capacity.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-cbor.cpp b/test/src/unit-cbor.cpp
index b1c1a43e..0a8dbf6f 100644
--- a/test/src/unit-cbor.cpp
+++ b/test/src/unit-cbor.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -39,6 +39,7 @@ using nlohmann::json;
#include <iostream>
#include <set>
#include <test_data.hpp>
+#include "test_utils.hpp"
namespace
{
@@ -1011,21 +1012,21 @@ TEST_CASE("CBOR")
SECTION("0 (0 00000 0000000000)")
{
json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x00, 0x00}));
- json::number_float_t d = j;
+ json::number_float_t d{j};
CHECK(d == 0.0);
}
SECTION("-0 (1 00000 0000000000)")
{
json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x80, 0x00}));
- json::number_float_t d = j;
+ json::number_float_t d{j};
CHECK(d == -0.0);
}
SECTION("2**-24 (0 00000 0000000001)")
{
json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x00, 0x01}));
- json::number_float_t d = j;
+ json::number_float_t d{j};
CHECK(d == std::pow(2.0, -24.0));
}
}
@@ -1035,7 +1036,7 @@ TEST_CASE("CBOR")
SECTION("infinity (0 11111 0000000000)")
{
json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c, 0x00}));
- json::number_float_t d = j;
+ json::number_float_t d{j};
CHECK(d == std::numeric_limits<json::number_float_t>::infinity());
CHECK(j.dump() == "null");
}
@@ -1043,7 +1044,7 @@ TEST_CASE("CBOR")
SECTION("-infinity (1 11111 0000000000)")
{
json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0xfc, 0x00}));
- json::number_float_t d = j;
+ json::number_float_t d{j};
CHECK(d == -std::numeric_limits<json::number_float_t>::infinity());
CHECK(j.dump() == "null");
}
@@ -1054,21 +1055,21 @@ TEST_CASE("CBOR")
SECTION("1 (0 01111 0000000000)")
{
json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x3c, 0x00}));
- json::number_float_t d = j;
+ json::number_float_t d{j};
CHECK(d == 1);
}
SECTION("-2 (1 10000 0000000000)")
{
json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0xc0, 0x00}));
- json::number_float_t d = j;
+ json::number_float_t d{j};
CHECK(d == -2);
}
SECTION("65504 (0 11110 1111111111)")
{
json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7b, 0xff}));
- json::number_float_t d = j;
+ json::number_float_t d{j};
CHECK(d == 65504);
}
}
@@ -1076,15 +1077,15 @@ TEST_CASE("CBOR")
SECTION("infinity")
{
json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c, 0x00}));
- json::number_float_t d = j;
- CHECK(not std::isfinite(d));
+ json::number_float_t d{j};
+ CHECK(!std::isfinite(d));
CHECK(j.dump() == "null");
}
SECTION("NaN")
{
json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7e, 0x00}));
- json::number_float_t d = j;
+ json::number_float_t d{j};
CHECK(std::isnan(d));
CHECK(j.dump() == "null");
}
@@ -1869,7 +1870,7 @@ TEST_CASE("CBOR")
{
const auto result = json::from_cbor(vec, false);
CHECK(result == json());
- CHECK(not json::from_cbor(vec, false, false).is_discarded());
+ CHECK(!json::from_cbor(vec, false, false).is_discarded());
}
SECTION("strict mode")
@@ -1889,21 +1890,21 @@ TEST_CASE("CBOR")
{
std::vector<uint8_t> v = {0x83, 0x01, 0x02, 0x03};
SaxCountdown scp(0);
- CHECK(not json::sax_parse(v, &scp, json::input_format_t::cbor));
+ CHECK(!json::sax_parse(v, &scp, json::input_format_t::cbor));
}
SECTION("start_object(len)")
{
std::vector<uint8_t> v = {0xA1, 0x63, 0x66, 0x6F, 0x6F, 0xF4};
SaxCountdown scp(0);
- CHECK(not json::sax_parse(v, &scp, json::input_format_t::cbor));
+ CHECK(!json::sax_parse(v, &scp, json::input_format_t::cbor));
}
SECTION("key()")
{
std::vector<uint8_t> v = {0xA1, 0x63, 0x66, 0x6F, 0x6F, 0xF4};
SaxCountdown scp(1);
- CHECK(not json::sax_parse(v, &scp, json::input_format_t::cbor));
+ CHECK(!json::sax_parse(v, &scp, json::input_format_t::cbor));
}
}
}
@@ -1920,9 +1921,7 @@ TEST_CASE("single CBOR roundtrip")
json j1 = json::parse(f_json);
// parse CBOR file
- std::ifstream f_cbor(filename + ".cbor", std::ios::binary);
- std::vector<uint8_t> packed((std::istreambuf_iterator<char>(f_cbor)),
- std::istreambuf_iterator<char>());
+ auto packed = utils::read_binary_file(filename + ".cbor");
json j2;
CHECK_NOTHROW(j2 = json::from_cbor(packed));
@@ -1954,7 +1953,7 @@ TEST_CASE("single CBOR roundtrip")
}
}
-#if not defined(JSON_NOEXCEPTION)
+#if !defined(JSON_NOEXCEPTION)
TEST_CASE("CBOR regressions")
{
SECTION("fuzz test results")
@@ -1994,10 +1993,7 @@ TEST_CASE("CBOR regressions")
try
{
// parse CBOR file
- std::ifstream f_cbor(filename, std::ios::binary);
- std::vector<uint8_t> vec1(
- (std::istreambuf_iterator<char>(f_cbor)),
- std::istreambuf_iterator<char>());
+ auto vec1 = utils::read_binary_file(filename);
json j1 = json::from_cbor(vec1);
try
@@ -2204,10 +2200,7 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
json j1 = json::parse(f_json);
// parse CBOR file
- std::ifstream f_cbor(filename + ".cbor", std::ios::binary);
- std::vector<uint8_t> packed(
- (std::istreambuf_iterator<char>(f_cbor)),
- std::istreambuf_iterator<char>());
+ auto packed = utils::read_binary_file(filename + ".cbor");
json j2;
CHECK_NOTHROW(j2 = json::from_cbor(packed));
@@ -2237,10 +2230,7 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
json j1 = json::parse(f_json);
// parse CBOR file
- std::ifstream f_cbor(filename + ".cbor", std::ios::binary);
- std::vector<uint8_t> packed(
- (std::istreambuf_iterator<char>(f_cbor)),
- std::istreambuf_iterator<char>());
+ auto packed = utils::read_binary_file(filename + ".cbor");
json j2;
CHECK_NOTHROW(j2 = json::from_cbor({packed.data(), packed.size()}));
@@ -2255,10 +2245,7 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
json j1 = json::parse(f_json);
// parse CBOR file
- std::ifstream f_cbor(filename + ".cbor", std::ios::binary);
- std::vector<uint8_t> packed(
- (std::istreambuf_iterator<char>(f_cbor)),
- std::istreambuf_iterator<char>());
+ auto packed = utils::read_binary_file(filename + ".cbor");
if (!exclude_packed.count(filename))
{
@@ -2274,7 +2261,7 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
}
}
-#if not defined(JSON_NOEXCEPTION)
+#if !defined(JSON_NOEXCEPTION)
TEST_CASE("all CBOR first bytes")
{
// these bytes will fail immediately with exception parse_error.112
@@ -2493,16 +2480,14 @@ TEST_CASE("examples from RFC 7049 Appendix A")
SECTION("byte arrays")
{
- std::ifstream f_cbor(TEST_DATA_DIRECTORY "/binary_data/cbor_binary.cbor", std::ios::binary);
- std::vector<uint8_t> packed((std::istreambuf_iterator<char>(f_cbor)),
- std::istreambuf_iterator<char>());
+ auto packed = utils::read_binary_file(TEST_DATA_DIRECTORY "/binary_data/cbor_binary.cbor");
json j;
CHECK_NOTHROW(j = json::from_cbor(packed));
- std::ifstream f_bin(TEST_DATA_DIRECTORY "/binary_data/cbor_binary.out", std::ios::binary);
- std::vector<uint8_t> expected((std::istreambuf_iterator<char>(f_bin)),
- std::istreambuf_iterator<char>());
+ auto expected = utils::read_binary_file(TEST_DATA_DIRECTORY "/binary_data/cbor_binary.out");
CHECK(j == json::binary(expected));
+
+ CHECK(json::to_cbor(json::binary(std::vector<uint8_t> {}, 0x42)) == std::vector<uint8_t> {0xd8, 0x42, 0x40});
}
SECTION("arrays")
@@ -2548,3 +2533,197 @@ TEST_CASE("examples from RFC 7049 Appendix A")
CHECK(json::parse("{\"Fun\": true, \"Amt\": -2}") == json::from_cbor(std::vector<uint8_t>({0xbf, 0x63, 0x46, 0x75, 0x6e, 0xf5, 0x63, 0x41, 0x6d, 0x74, 0x21, 0xff})));
}
}
+
+TEST_CASE("Tagged values")
+{
+ json j = "s";
+ auto v = json::to_cbor(j);
+
+ SECTION("0xC6..0xD4")
+ {
+ for (auto b : std::vector<std::uint8_t>
+ {
+ 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4
+ })
+ {
+ // add tag to value
+ auto v_tagged = v;
+ v_tagged.insert(v_tagged.begin(), b);
+
+ // check that parsing fails in error mode
+ CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+ CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+
+ // check that parsing succeeds and gets original value in ignore mode
+ auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
+ CHECK(j_tagged == j);
+ }
+ }
+
+ SECTION("0xD8 - 1 byte follows")
+ {
+ SECTION("success")
+ {
+ // add tag to value
+ auto v_tagged = v;
+ v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0xD8); // tag
+
+ // check that parsing fails in error mode
+ CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+ CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+
+ // check that parsing succeeds and gets original value in ignore mode
+ auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
+ CHECK(j_tagged == j);
+ }
+
+ SECTION("missing byte after tag")
+ {
+ // add tag to value
+ auto v_tagged = v;
+ v_tagged.insert(v_tagged.begin(), 0xD8); // tag
+
+ // check that parsing fails in all modes
+ CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+ CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+ CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore), json::parse_error);
+ }
+ }
+
+ SECTION("0xD9 - 2 byte follow")
+ {
+ SECTION("success")
+ {
+ // add tag to value
+ auto v_tagged = v;
+ v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0xD9); // tag
+
+ // check that parsing fails in error mode
+ CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+ CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+
+ // check that parsing succeeds and gets original value in ignore mode
+ auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
+ CHECK(j_tagged == j);
+ }
+
+ SECTION("missing byte after tag")
+ {
+ // add tag to value
+ auto v_tagged = v;
+ v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0xD9); // tag
+
+ // check that parsing fails in all modes
+ CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+ CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+ CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore), json::parse_error);
+ }
+ }
+
+ SECTION("0xDA - 4 bytes follow")
+ {
+ SECTION("success")
+ {
+ // add tag to value
+ auto v_tagged = v;
+ v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0xDA); // tag
+
+ // check that parsing fails in error mode
+ CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+ CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+
+ // check that parsing succeeds and gets original value in ignore mode
+ auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
+ CHECK(j_tagged == j);
+ }
+
+ SECTION("missing bytes after tag")
+ {
+ // add tag to value
+ auto v_tagged = v;
+ v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0xDA); // tag
+
+ // check that parsing fails in all modes
+ CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+ CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+ CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore), json::parse_error);
+ }
+ }
+
+ SECTION("0xDB - 8 bytes follow")
+ {
+ SECTION("success")
+ {
+ // add tag to value
+ auto v_tagged = v;
+ v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0xDB); // tag
+
+ // check that parsing fails in error mode
+ CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+ CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+
+ // check that parsing succeeds and gets original value in ignore mode
+ auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
+ CHECK(j_tagged == j);
+ }
+
+ SECTION("missing byte after tag")
+ {
+ // add tag to value
+ auto v_tagged = v;
+ v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
+ v_tagged.insert(v_tagged.begin(), 0xDB); // tag
+
+ // check that parsing fails in all modes
+ CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+ CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+ CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore), json::parse_error);
+ }
+ }
+
+ SECTION("tagged binary")
+ {
+ // create a binary value of subtype 42
+ json j_binary;
+ j_binary["binary"] = json::binary({0xCA, 0xFE, 0xBA, 0xBE}, 42);
+
+ // convert to CBOR
+ const auto vec = json::to_cbor(j_binary);
+ CHECK(vec == std::vector<std::uint8_t> {0xA1, 0x66, 0x62, 0x69, 0x6E, 0x61, 0x72, 0x79, 0xD8, 0x2A, 0x44, 0xCA, 0xFE, 0xBA, 0xBE});
+
+ // parse error when parsing tagged value
+ CHECK_THROWS_AS(json::from_cbor(vec), json::parse_error);
+ CHECK_THROWS_WITH(json::from_cbor(vec), "[json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: invalid byte: 0xD8");
+
+ // binary without subtype when tags are ignored
+ json jb = json::from_cbor(vec, true, true, json::cbor_tag_handler_t::ignore);
+ CHECK(jb.is_object());
+ CHECK(jb["binary"].is_binary());
+ CHECK(!jb["binary"].get_binary().has_subtype());
+ }
+}
diff --git a/test/src/unit-class_const_iterator.cpp b/test/src/unit-class_const_iterator.cpp
index 71730773..f75c4831 100644
--- a/test/src/unit-class_const_iterator.cpp
+++ b/test/src/unit-class_const_iterator.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -224,7 +224,7 @@ TEST_CASE("const_iterator class")
json::const_iterator it = j.cbegin();
CHECK((it.m_it.primitive_iterator.m_it == 1));
it++;
- CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+ CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
}
SECTION("number")
@@ -235,7 +235,7 @@ TEST_CASE("const_iterator class")
it++;
CHECK((it.m_it.primitive_iterator.m_it == 1));
it++;
- CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+ CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
}
SECTION("object")
@@ -275,7 +275,7 @@ TEST_CASE("const_iterator class")
json::const_iterator it = j.cbegin();
CHECK((it.m_it.primitive_iterator.m_it == 1));
++it;
- CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+ CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
}
SECTION("number")
@@ -286,7 +286,7 @@ TEST_CASE("const_iterator class")
++it;
CHECK((it.m_it.primitive_iterator.m_it == 1));
++it;
- CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+ CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
}
SECTION("object")
@@ -335,7 +335,7 @@ TEST_CASE("const_iterator class")
it--;
CHECK((it.m_it.primitive_iterator.m_it == 0));
it--;
- CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+ CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
}
SECTION("object")
@@ -384,7 +384,7 @@ TEST_CASE("const_iterator class")
--it;
CHECK((it.m_it.primitive_iterator.m_it == 0));
--it;
- CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+ CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
}
SECTION("object")
diff --git a/test/src/unit-class_iterator.cpp b/test/src/unit-class_iterator.cpp
index 7d20e1f2..0a85e7ad 100644
--- a/test/src/unit-class_iterator.cpp
+++ b/test/src/unit-class_iterator.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -208,7 +208,7 @@ TEST_CASE("iterator class")
json::iterator it = j.begin();
CHECK((it.m_it.primitive_iterator.m_it == 1));
it++;
- CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+ CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
}
SECTION("number")
@@ -219,7 +219,7 @@ TEST_CASE("iterator class")
it++;
CHECK((it.m_it.primitive_iterator.m_it == 1));
it++;
- CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+ CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
}
SECTION("object")
@@ -259,7 +259,7 @@ TEST_CASE("iterator class")
json::iterator it = j.begin();
CHECK((it.m_it.primitive_iterator.m_it == 1));
++it;
- CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+ CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
}
SECTION("number")
@@ -270,7 +270,7 @@ TEST_CASE("iterator class")
++it;
CHECK((it.m_it.primitive_iterator.m_it == 1));
++it;
- CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+ CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
}
SECTION("object")
@@ -319,7 +319,7 @@ TEST_CASE("iterator class")
it--;
CHECK((it.m_it.primitive_iterator.m_it == 0));
it--;
- CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+ CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
}
SECTION("object")
@@ -368,7 +368,7 @@ TEST_CASE("iterator class")
--it;
CHECK((it.m_it.primitive_iterator.m_it == 0));
--it;
- CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+ CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
}
SECTION("object")
diff --git a/test/src/unit-class_lexer.cpp b/test/src/unit-class_lexer.cpp
index 0e1b5378..0f544d55 100644
--- a/test/src/unit-class_lexer.cpp
+++ b/test/src/unit-class_lexer.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -37,14 +37,23 @@ using nlohmann::json;
namespace
{
// shortcut to scan a string literal
-json::lexer::token_type scan_string(const char* s);
-json::lexer::token_type scan_string(const char* s)
+json::lexer::token_type scan_string(const char* s, const bool ignore_comments = false);
+json::lexer::token_type scan_string(const char* s, const bool ignore_comments)
{
auto ia = nlohmann::detail::input_adapter(s);
- return nlohmann::detail::lexer<json, decltype(ia)>(std::move(ia)).scan();
+ return nlohmann::detail::lexer<json, decltype(ia)>(std::move(ia), ignore_comments).scan();
}
}
+std::string get_error_message(const char* s, const bool ignore_comments = false);
+std::string get_error_message(const char* s, const bool ignore_comments)
+{
+ auto ia = nlohmann::detail::input_adapter(s);
+ auto lexer = nlohmann::detail::lexer<json, decltype(ia)>(std::move(ia), ignore_comments);
+ lexer.scan();
+ return lexer.get_error_message();
+}
+
TEST_CASE("lexer class")
{
SECTION("scan")
@@ -127,6 +136,8 @@ TEST_CASE("lexer class")
// store scan() result
const auto res = scan_string(s.c_str());
+ CAPTURE(s);
+
switch (c)
{
// single characters that are valid tokens
@@ -179,4 +190,56 @@ TEST_CASE("lexer class")
s += "\"";
CHECK((scan_string(s.c_str()) == json::lexer::token_type::value_string));
}
+
+ SECTION("fail on comments")
+ {
+ CHECK((scan_string("/", false) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/", false) == "invalid literal");
+
+ CHECK((scan_string("/!", false) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/!", false) == "invalid literal");
+ CHECK((scan_string("/*", false) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/*", false) == "invalid literal");
+ CHECK((scan_string("/**", false) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/**", false) == "invalid literal");
+
+ CHECK((scan_string("//", false) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("//", false) == "invalid literal");
+ CHECK((scan_string("/**/", false) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/**/", false) == "invalid literal");
+ CHECK((scan_string("/** /", false) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/** /", false) == "invalid literal");
+
+ CHECK((scan_string("/***/", false) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/***/", false) == "invalid literal");
+ CHECK((scan_string("/* true */", false) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/* true */", false) == "invalid literal");
+ CHECK((scan_string("/*/**/", false) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/*/**/", false) == "invalid literal");
+ CHECK((scan_string("/*/* */", false) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/*/* */", false) == "invalid literal");
+ }
+
+ SECTION("ignore comments")
+ {
+ CHECK((scan_string("/", true) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/", true) == "invalid comment; expecting '/' or '*' after '/'");
+
+ CHECK((scan_string("/!", true) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/!", true) == "invalid comment; expecting '/' or '*' after '/'");
+ CHECK((scan_string("/*", true) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/*", true) == "invalid comment; missing closing '*/'");
+ CHECK((scan_string("/**", true) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/**", true) == "invalid comment; missing closing '*/'");
+
+ CHECK((scan_string("//", true) == json::lexer::token_type::end_of_input));
+ CHECK((scan_string("/**/", true) == json::lexer::token_type::end_of_input));
+ CHECK((scan_string("/** /", true) == json::lexer::token_type::parse_error));
+ CHECK(get_error_message("/** /", true) == "invalid comment; missing closing '*/'");
+
+ CHECK((scan_string("/***/", true) == json::lexer::token_type::end_of_input));
+ CHECK((scan_string("/* true */", true) == json::lexer::token_type::end_of_input));
+ CHECK((scan_string("/*/**/", true) == json::lexer::token_type::end_of_input));
+ CHECK((scan_string("/*/* */", true) == json::lexer::token_type::end_of_input));
+ }
}
diff --git a/test/src/unit-class_parser.cpp b/test/src/unit-class_parser.cpp
index 1912094a..2c93a753 100644
--- a/test/src/unit-class_parser.cpp
+++ b/test/src/unit-class_parser.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -224,6 +224,7 @@ class SaxCountdown : public nlohmann::json::json_sax_t
json parser_helper(const std::string& s);
bool accept_helper(const std::string& s);
+void comments_helper(const std::string& s);
json parser_helper(const std::string& s)
{
@@ -241,6 +242,8 @@ json parser_helper(const std::string& s)
json::sax_parse(s, &sdp);
CHECK(j_sax == j);
+ comments_helper(s);
+
return j;
}
@@ -251,7 +254,7 @@ bool accept_helper(const std::string& s)
// 1. parse s without exceptions
json j;
CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter(s), nullptr, false).parse(true, j));
- const bool ok_noexcept = not j.is_discarded();
+ const bool ok_noexcept = !j.is_discarded();
// 2. accept s
const bool ok_accept = json::parser(nlohmann::detail::input_adapter(s)).accept(true);
@@ -262,7 +265,7 @@ bool accept_helper(const std::string& s)
// 4. parse with SAX (compare with relaxed accept result)
SaxEventLogger el;
CHECK_NOTHROW(json::sax_parse(s, &el, json::input_format_t::json, false));
- CHECK(json::parser(nlohmann::detail::input_adapter(s)).accept(false) == not el.errored);
+ CHECK(json::parser(nlohmann::detail::input_adapter(s)).accept(false) == !el.errored);
// 5. parse with simple callback
json::parser_callback_t cb = [](int, json::parse_event_t, json&)
@@ -270,16 +273,56 @@ bool accept_helper(const std::string& s)
return true;
};
json j_cb = json::parse(s, cb, false);
- const bool ok_noexcept_cb = not j_cb.is_discarded();
+ const bool ok_noexcept_cb = !j_cb.is_discarded();
// 6. check if this approach came to the same result
CHECK(ok_noexcept == ok_noexcept_cb);
- // 7. return result
+ // 7. check if comments are properly ignored
+ if (ok_accept)
+ {
+ comments_helper(s);
+ }
+
+ // 8. return result
return ok_accept;
}
+
+void comments_helper(const std::string& s)
+{
+ json _;
+
+ // parse/accept with default parser
+ CHECK_NOTHROW(_ = json::parse(s));
+ CHECK(json::accept(s));
+
+ // parse/accept while skipping comments
+ CHECK_NOTHROW(_ = json::parse(s, nullptr, false, true));
+ CHECK(json::accept(s, true));
+
+ std::vector<std::string> json_with_comments;
+
+ // start with a comment
+ json_with_comments.push_back(std::string("// this is a comment\n") + s);
+ json_with_comments.push_back(std::string("/* this is a comment */") + s);
+ // end with a comment
+ json_with_comments.push_back(s + "// this is a comment");
+ json_with_comments.push_back(s + "/* this is a comment */");
+
+ // check all strings
+ for (const auto& json_with_comment : json_with_comments)
+ {
+ CAPTURE(json_with_comment)
+ CHECK_THROWS_AS(_ = json::parse(json_with_comment), json::parse_error);
+ CHECK(!json::accept(json_with_comment));
+
+ CHECK_NOTHROW(_ = json::parse(json_with_comment, nullptr, true, true));
+ CHECK(json::accept(json_with_comment, true));
+ }
}
+} // namespace
+
TEST_CASE("parser class")
{
SECTION("parse")
@@ -898,7 +941,7 @@ TEST_CASE("parser class")
SECTION("overflow")
{
// overflows during parsing
- CHECK(not accept_helper("1.18973e+4932"));
+ CHECK(!accept_helper("1.18973e+4932"));
}
SECTION("invalid numbers")
@@ -1573,7 +1616,7 @@ TEST_CASE("parser class")
{
json j_filtered1 = json::parse(structured_array, [](int, json::parse_event_t e, const json & parsed)
{
- if (e == json::parse_event_t::object_end and parsed.contains("foo"))
+ if (e == json::parse_event_t::object_end && parsed.contains("foo"))
{
return false;
}
@@ -1612,7 +1655,7 @@ TEST_CASE("parser class")
json j_object = json::parse(s_object, [](int, json::parse_event_t e, const json&)
{
static bool first = true;
- if (e == json::parse_event_t::object_end and first)
+ if (e == json::parse_event_t::object_end && first)
{
first = false;
return false;
@@ -1631,7 +1674,7 @@ TEST_CASE("parser class")
json j_array = json::parse(s_array, [](int, json::parse_event_t e, const json&)
{
static bool first = true;
- if (e == json::parse_event_t::array_end and first)
+ if (e == json::parse_event_t::array_end && first)
{
first = false;
return false;
@@ -1834,4 +1877,10 @@ TEST_CASE("parser class")
}
}
}
+
+ SECTION("error messages for comments")
+ {
+ CHECK_THROWS_WITH_AS(json::parse("/a", nullptr, true, true), "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid comment; expecting '/' or '*' after '/'; last read: '/a'", json::parse_error);
+ CHECK_THROWS_WITH_AS(json::parse("/*", nullptr, true, true), "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid comment; missing closing '*/'; last read: '/*<U+0000>'", json::parse_error);
+ }
}
diff --git a/test/src/unit-comparison.cpp b/test/src/unit-comparison.cpp
index 43f1dc08..b0984a5b 100644
--- a/test/src/unit-comparison.cpp
+++ b/test/src/unit-comparison.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -165,7 +165,7 @@ TEST_CASE("lexicographical comparison operators")
CAPTURE(i)
CAPTURE(j)
// check definition
- CHECK( (j_values[i] != j_values[j]) == not(j_values[i] == j_values[j]) );
+ CHECK( (j_values[i] != j_values[j]) == !(j_values[i] == j_values[j]) );
}
}
@@ -173,8 +173,8 @@ TEST_CASE("lexicographical comparison operators")
json j_null;
CHECK( (j_null != nullptr) == false);
CHECK( (nullptr != j_null) == false);
- CHECK( (j_null != nullptr) == not(j_null == nullptr));
- CHECK( (nullptr != j_null) == not(nullptr == j_null));
+ CHECK( (j_null != nullptr) == !(j_null == nullptr));
+ CHECK( (nullptr != j_null) == !(nullptr == j_null));
}
SECTION("comparison: less")
@@ -234,7 +234,7 @@ TEST_CASE("lexicographical comparison operators")
CAPTURE(i)
CAPTURE(j)
// check definition
- CHECK( (j_values[i] <= j_values[j]) == not(j_values[j] < j_values[i]) );
+ CHECK( (j_values[i] <= j_values[j]) == !(j_values[j] < j_values[i]) );
}
}
}
@@ -262,7 +262,7 @@ TEST_CASE("lexicographical comparison operators")
CAPTURE(i)
CAPTURE(j)
// check definition
- CHECK( (j_values[i] >= j_values[j]) == not(j_values[i] < j_values[j]) );
+ CHECK( (j_values[i] >= j_values[j]) == !(j_values[i] < j_values[j]) );
}
}
}
diff --git a/test/src/unit-concepts.cpp b/test/src/unit-concepts.cpp
index 02ca3614..49f2f865 100644
--- a/test/src/unit-concepts.cpp
+++ b/test/src/unit-concepts.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -154,7 +154,7 @@ TEST_CASE("concepts")
json j {1, 2, 3};
json::iterator it1 = j.begin();
json::iterator it2 = j.end();
- std::swap(it1, it2);
+ swap(it1, it2);
CHECK(it1 == j.end());
CHECK(it2 == j.begin());
}
@@ -162,7 +162,7 @@ TEST_CASE("concepts")
json j {1, 2, 3};
json::const_iterator it1 = j.cbegin();
json::const_iterator it2 = j.cend();
- std::swap(it1, it2);
+ swap(it1, it2);
CHECK(it1 == j.end());
CHECK(it2 == j.begin());
}
diff --git a/test/src/unit-constructor1.cpp b/test/src/unit-constructor1.cpp
index 80ab39f4..70f52fd2 100644
--- a/test/src/unit-constructor1.cpp
+++ b/test/src/unit-constructor1.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -341,7 +341,7 @@ TEST_CASE("constructors")
CHECK(j.type() == json::value_t::array);
CHECK(j == json({1, 2, 3, 4, 5}));
- std::valarray<int> jva = j;
+ auto jva = j.get<std::valarray<int>>();
CHECK(jva.size() == va.size());
for (size_t i = 0; i < jva.size(); ++i)
{
@@ -356,7 +356,7 @@ TEST_CASE("constructors")
CHECK(j.type() == json::value_t::array);
CHECK(j == json({1.2, 2.3, 3.4, 4.5, 5.6}));
- std::valarray<double> jva = j;
+ auto jva = j.get<std::valarray<double>>();
CHECK(jva.size() == va.size());
for (size_t i = 0; i < jva.size(); ++i)
{
@@ -846,8 +846,8 @@ TEST_CASE("constructors")
CHECK(j.type() == json::value_t::number_float);
// check round trip of NaN
- json::number_float_t d = j;
- CHECK((std::isnan(d) and std::isnan(n)) == true);
+ json::number_float_t d{j};
+ CHECK((std::isnan(d) && std::isnan(n)) == true);
// check that NaN is serialized to null
CHECK(j.dump() == "null");
@@ -861,7 +861,7 @@ TEST_CASE("constructors")
CHECK(j.type() == json::value_t::number_float);
// check round trip of infinity
- json::number_float_t d = j;
+ json::number_float_t d{j};
CHECK(d == n);
// check that inf is serialized to null
diff --git a/test/src/unit-constructor2.cpp b/test/src/unit-constructor2.cpp
index a7152939..a7bf0e50 100644
--- a/test/src/unit-constructor2.cpp
+++ b/test/src/unit-constructor2.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-convenience.cpp b/test/src/unit-convenience.cpp
index eb8929c1..41955b3f 100644
--- a/test/src/unit-convenience.cpp
+++ b/test/src/unit-convenience.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-conversions.cpp b/test/src/unit-conversions.cpp
index ba31e05d..32e15ace 100644
--- a/test/src/unit-conversions.cpp
+++ b/test/src/unit-conversions.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -189,6 +189,7 @@ TEST_CASE("value conversion")
}
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("get an object (implicit)")
{
json::object_t o_reference = {{"object", json::object()},
@@ -230,6 +231,7 @@ TEST_CASE("value conversion")
CHECK(json(o) == j);
}
}
+#endif
SECTION("get an array (explicit)")
{
@@ -272,11 +274,12 @@ TEST_CASE("value conversion")
json(json::value_t::null).get<std::vector<json>>(),
"[json.exception.type_error.302] type must be array, but is null");
-#if not defined(JSON_NOEXCEPTION)
+#if !defined(JSON_NOEXCEPTION)
SECTION("reserve is called on containers that supports it")
{
// make sure all values are properly copied
- std::vector<int> v2 = json({1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+ json j2({1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+ auto v2 = j2.get<std::vector<int>>();
CHECK(v2.size() == 10);
}
#endif
@@ -405,6 +408,7 @@ TEST_CASE("value conversion")
}
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("get an array (implicit)")
{
json::array_t a_reference{json(1), json(1u), json(2.2),
@@ -441,6 +445,7 @@ TEST_CASE("value conversion")
CHECK(json(a) == j);
}
}
+#endif
SECTION("get a string (explicit)")
{
@@ -598,6 +603,7 @@ TEST_CASE("value conversion")
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("get a string (implicit)")
{
json::string_t s_reference{"Hello world"};
@@ -623,6 +629,7 @@ TEST_CASE("value conversion")
CHECK(json(s) == j);
}
}
+#endif
SECTION("get a boolean (explicit)")
{
@@ -695,6 +702,7 @@ TEST_CASE("value conversion")
}
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("get a boolean (implicit)")
{
json::boolean_t b_reference{true};
@@ -712,6 +720,7 @@ TEST_CASE("value conversion")
CHECK(json(b) == j);
}
}
+#endif
SECTION("get an integer number (explicit)")
{
@@ -962,6 +971,7 @@ TEST_CASE("value conversion")
}
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("get an integer number (implicit)")
{
json::number_integer_t n_reference{42};
@@ -1173,6 +1183,7 @@ TEST_CASE("value conversion")
CHECK(json(n) == j_unsigned);
}
}
+#endif
SECTION("get a floating-point number (explicit)")
{
@@ -1234,6 +1245,7 @@ TEST_CASE("value conversion")
}
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("get a floating-point number (implicit)")
{
json::number_float_t n_reference{42.23};
@@ -1257,6 +1269,7 @@ TEST_CASE("value conversion")
CHECK(json(n).m_value.number_float == Approx(j.m_value.number_float));
}
}
+#endif
SECTION("get a binary value (explicit)")
{
@@ -1364,6 +1377,7 @@ TEST_CASE("value conversion")
}
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("get a binary value (implicit)")
{
json::binary_t n_reference{{1, 2, 3}};
@@ -1375,6 +1389,7 @@ TEST_CASE("value conversion")
CHECK(*json(b).m_value.binary == *j.m_value.binary);
}
}
+#endif
SECTION("get an enum")
{
@@ -1481,15 +1496,15 @@ TEST_CASE("value conversion")
SECTION("std::array is larger than JSON")
{
std::array<int, 6> arr6 = {{1, 2, 3, 4, 5, 6}};
- CHECK_THROWS_AS(arr6 = j1, json::out_of_range&);
- CHECK_THROWS_WITH(arr6 = j1, "[json.exception.out_of_range.401] "
+ CHECK_THROWS_AS(j1.get_to(arr6), json::out_of_range&);
+ CHECK_THROWS_WITH(j1.get_to(arr6), "[json.exception.out_of_range.401] "
"array index 4 is out of range");
}
SECTION("std::array is smaller than JSON")
{
std::array<int, 2> arr2 = {{8, 9}};
- arr2 = j1;
+ j1.get_to(arr2);
CHECK(arr2[0] == 1);
CHECK(arr2[1] == 2);
}
diff --git a/test/src/unit-deserialization.cpp b/test/src/unit-deserialization.cpp
index aa3b1fc2..66556617 100644
--- a/test/src/unit-deserialization.cpp
+++ b/test/src/unit-deserialization.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -289,14 +289,14 @@ TEST_CASE("deserialization")
CHECK_THROWS_AS(_ = json::parse(ss1), json::parse_error&);
CHECK_THROWS_WITH(_ = json::parse(ss2),
"[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'");
- CHECK(not json::accept(ss3));
+ CHECK(!json::accept(ss3));
json j_error;
CHECK_NOTHROW(j_error = json::parse(ss4, nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(ss5, &l));
+ CHECK(!json::sax_parse(ss5, &l));
CHECK(l.events.size() == 11);
CHECK(l.events == std::vector<std::string>(
{
@@ -314,14 +314,14 @@ TEST_CASE("deserialization")
CHECK_THROWS_AS(_ = json::parse(s), json::parse_error&);
CHECK_THROWS_WITH(_ = json::parse(s),
"[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'");
- CHECK(not json::accept(s));
+ CHECK(!json::accept(s));
json j_error;
CHECK_NOTHROW(j_error = json::parse(s, nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(s, &l));
+ CHECK(!json::sax_parse(s, &l));
CHECK(l.events.size() == 11);
CHECK(l.events == std::vector<std::string>(
{
@@ -450,10 +450,10 @@ TEST_CASE("deserialization")
std::vector<uint8_t> v;
json _;
CHECK_THROWS_AS(_ = json::parse(v), json::parse_error&);
- CHECK(not json::accept(v));
+ CHECK(!json::accept(v));
SaxEventLogger l;
- CHECK(not json::sax_parse(v, &l));
+ CHECK(!json::sax_parse(v, &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(1)"}));
}
@@ -538,10 +538,10 @@ TEST_CASE("deserialization")
{
std::vector<uint8_t> v;
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(1)"}));
}
@@ -554,14 +554,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u'};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(10)"}));
}
@@ -570,14 +570,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u', '1'};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(11)"}));
}
@@ -586,14 +586,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u', '1', '1', '1', '1', '1', '1', '1', '1'};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(18)"}));
}
@@ -602,14 +602,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', 'u', '1', '1', '1', '1', '1', '1', '1', '1', '\\'};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(18)"}));
}
@@ -618,14 +618,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 0x7F, 0xC1};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(3)"}));
}
@@ -637,14 +637,14 @@ TEST_CASE("deserialization")
CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
CHECK_THROWS_WITH(_ = json::parse(std::begin(v), std::end(v)),
"[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing value - invalid string: ill-formed UTF-8 byte; last read: '\"\x7f\xdf\x7f'");
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
}
@@ -653,14 +653,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 0x7F, 0xDF, 0xC0};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
}
@@ -669,14 +669,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 0x7F, 0xE0, 0x9F};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
}
@@ -685,14 +685,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 0x7F, 0xEF, 0xC0};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
}
@@ -701,14 +701,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 0x7F, 0xED, 0x7F};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
}
@@ -717,14 +717,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 0x7F, 0xF0, 0x8F};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
}
@@ -733,14 +733,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 0x7F, 0xF0, 0xC0};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
}
@@ -749,14 +749,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 0x7F, 0xF3, 0x7F};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
}
@@ -765,14 +765,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 0x7F, 0xF3, 0xC0};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
}
@@ -781,14 +781,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'\"', 0x7F, 0xF4, 0x7F};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
}
@@ -797,14 +797,14 @@ TEST_CASE("deserialization")
{
uint8_t v[] = {'{', '\"', '\"', ':', '1', '1'};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
- CHECK(not json::accept(std::begin(v), std::end(v)));
+ CHECK(!json::accept(std::begin(v), std::end(v)));
json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded());
SaxEventLogger l;
- CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+ CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
CHECK(l.events.size() == 4);
CHECK(l.events == std::vector<std::string>(
{
@@ -831,7 +831,7 @@ TEST_CASE("deserialization")
"[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing value - unexpected end of input; expected '[', '{', or a literal");
SaxEventLogger l;
- CHECK(not json::sax_parse(bom, &l));
+ CHECK(!json::sax_parse(bom, &l));
CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>(
{
@@ -871,8 +871,8 @@ TEST_CASE("deserialization")
"[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid BOM; must be 0xEF 0xBB 0xBF if given; last read: '\xEF\xBB'");
SaxEventLogger l1, l2;
- CHECK(not json::sax_parse(std::istringstream(bom.substr(0, 2)), &l1));
- CHECK(not json::sax_parse(bom.substr(0, 2), &l2));
+ CHECK(!json::sax_parse(std::istringstream(bom.substr(0, 2)), &l1));
+ CHECK(!json::sax_parse(bom.substr(0, 2), &l2));
CHECK(l1.events.size() == 1);
CHECK(l1.events == std::vector<std::string>(
{
@@ -897,8 +897,8 @@ TEST_CASE("deserialization")
"[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid BOM; must be 0xEF 0xBB 0xBF if given; last read: '\xEF'");
SaxEventLogger l1, l2;
- CHECK(not json::sax_parse(std::istringstream(bom.substr(0, 1)), &l1));
- CHECK(not json::sax_parse(bom.substr(0, 1), &l2));
+ CHECK(!json::sax_parse(std::istringstream(bom.substr(0, 1)), &l1));
+ CHECK(!json::sax_parse(bom.substr(0, 1), &l2));
CHECK(l1.events.size() == 1);
CHECK(l1.events == std::vector<std::string>(
{
@@ -931,7 +931,7 @@ TEST_CASE("deserialization")
s.push_back(static_cast<char>(bom[1] + i1));
s.push_back(static_cast<char>(bom[2] + i2));
- if (i0 == 0 and i1 == 0 and i2 == 0)
+ if (i0 == 0 && i1 == 0 && i2 == 0)
{
// without any variation, we skip the BOM
CHECK(json::parse(s + "null") == json());
@@ -953,7 +953,7 @@ TEST_CASE("deserialization")
CHECK_THROWS_AS(_ = json::parse(std::istringstream(s + "null")), json::parse_error&);
SaxEventLogger l;
- CHECK(not json::sax_parse(s + "null", &l));
+ CHECK(!json::sax_parse(s + "null", &l));
CHECK(l.events.size() == 1);
if (i0 != 0)
diff --git a/test/src/unit-element_access1.cpp b/test/src/unit-element_access1.cpp
index 64ed2ed2..a619b249 100644
--- a/test/src/unit-element_access1.cpp
+++ b/test/src/unit-element_access1.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-element_access2.cpp b/test/src/unit-element_access2.cpp
index 0a73964a..4abf3dba 100644
--- a/test/src/unit-element_access2.cpp
+++ b/test/src/unit-element_access2.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1072,7 +1072,7 @@ TEST_CASE("element access 2")
}
}
-#if not defined(JSON_NOEXCEPTION)
+#if !defined(JSON_NOEXCEPTION)
TEST_CASE("element access 2 (throwing tests)")
{
SECTION("object")
diff --git a/test/src/unit-hash.cpp b/test/src/unit-hash.cpp
new file mode 100644
index 00000000..ea35300f
--- /dev/null
+++ b/test/src/unit-hash.cpp
@@ -0,0 +1,84 @@
+/*
+ __ _____ _____ _____
+ __| | __| | | | JSON for Modern C++ (test suite)
+| | |__ | | | | | | version 3.9.0
+|_____|_____|_____|_|___| https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "doctest_compatibility.h"
+
+#include <nlohmann/json.hpp>
+using json = nlohmann::json;
+
+#include <set>
+
+TEST_CASE("hash")
+{
+ // Collect hashes for different JSON values and make sure that they are distinct
+ // We cannot compare against fixed values, because the implementation of
+ // std::hash may differ between compilers.
+
+ std::set<std::size_t> hashes;
+
+ // null
+ hashes.insert(std::hash<json> {}(json(nullptr)));
+
+ // boolean
+ hashes.insert(std::hash<json> {}(json(true)));
+ hashes.insert(std::hash<json> {}(json(false)));
+
+ // string
+ hashes.insert(std::hash<json> {}(json("")));
+ hashes.insert(std::hash<json> {}(json("foo")));
+
+ // number
+ hashes.insert(std::hash<json> {}(json(0)));
+ hashes.insert(std::hash<json> {}(json(unsigned(0))));
+
+ hashes.insert(std::hash<json> {}(json(-1)));
+ hashes.insert(std::hash<json> {}(json(0.0)));
+ hashes.insert(std::hash<json> {}(json(42.23)));
+
+ // array
+ hashes.insert(std::hash<json> {}(json::array()));
+ hashes.insert(std::hash<json> {}(json::array({1, 2, 3})));
+
+ // object
+ hashes.insert(std::hash<json> {}(json::object()));
+ hashes.insert(std::hash<json> {}(json::object({{"foo", "bar"}})));
+
+ // binary
+ hashes.insert(std::hash<json> {}(json::binary({})));
+ hashes.insert(std::hash<json> {}(json::binary({}, 0)));
+ hashes.insert(std::hash<json> {}(json::binary({}, 42)));
+ hashes.insert(std::hash<json> {}(json::binary({1, 2, 3})));
+ hashes.insert(std::hash<json> {}(json::binary({1, 2, 3}, 0)));
+ hashes.insert(std::hash<json> {}(json::binary({1, 2, 3}, 42)));
+
+ // discarded
+ hashes.insert(std::hash<json> {}(json(json::value_t::discarded)));
+
+ CHECK(hashes.size() == 21);
+}
diff --git a/test/src/unit-inspection.cpp b/test/src/unit-inspection.cpp
index 118087de..02502e07 100644
--- a/test/src/unit-inspection.cpp
+++ b/test/src/unit-inspection.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -43,36 +43,36 @@ TEST_CASE("object inspection")
SECTION("object")
{
json j {{"foo", 1}, {"bar", false}};
- CHECK(not j.is_null());
- CHECK(not j.is_boolean());
- CHECK(not j.is_number());
- CHECK(not j.is_number_integer());
- CHECK(not j.is_number_unsigned());
- CHECK(not j.is_number_float());
- CHECK(not j.is_binary());
+ CHECK(!j.is_null());
+ CHECK(!j.is_boolean());
+ CHECK(!j.is_number());
+ CHECK(!j.is_number_integer());
+ CHECK(!j.is_number_unsigned());
+ CHECK(!j.is_number_float());
+ CHECK(!j.is_binary());
CHECK(j.is_object());
- CHECK(not j.is_array());
- CHECK(not j.is_string());
- CHECK(not j.is_discarded());
- CHECK(not j.is_primitive());
+ CHECK(!j.is_array());
+ CHECK(!j.is_string());
+ CHECK(!j.is_discarded());
+ CHECK(!j.is_primitive());
CHECK(j.is_structured());
}
SECTION("array")
{
json j {"foo", 1, 1u, 42.23, false};
- CHECK(not j.is_null());
- CHECK(not j.is_boolean());
- CHECK(not j.is_number());
- CHECK(not j.is_number_integer());
- CHECK(not j.is_number_unsigned());
- CHECK(not j.is_number_float());
- CHECK(not j.is_binary());
- CHECK(not j.is_object());
+ CHECK(!j.is_null());
+ CHECK(!j.is_boolean());
+ CHECK(!j.is_number());
+ CHECK(!j.is_number_integer());
+ CHECK(!j.is_number_unsigned());
+ CHECK(!j.is_number_float());
+ CHECK(!j.is_binary());
+ CHECK(!j.is_object());
CHECK(j.is_array());
- CHECK(not j.is_string());
- CHECK(not j.is_discarded());
- CHECK(not j.is_primitive());
+ CHECK(!j.is_string());
+ CHECK(!j.is_discarded());
+ CHECK(!j.is_primitive());
CHECK(j.is_structured());
}
@@ -80,144 +80,144 @@ TEST_CASE("object inspection")
{
json j(nullptr);
CHECK(j.is_null());
- CHECK(not j.is_boolean());
- CHECK(not j.is_number());
- CHECK(not j.is_number_integer());
- CHECK(not j.is_number_unsigned());
- CHECK(not j.is_number_float());
- CHECK(not j.is_binary());
- CHECK(not j.is_object());
- CHECK(not j.is_array());
- CHECK(not j.is_string());
- CHECK(not j.is_discarded());
+ CHECK(!j.is_boolean());
+ CHECK(!j.is_number());
+ CHECK(!j.is_number_integer());
+ CHECK(!j.is_number_unsigned());
+ CHECK(!j.is_number_float());
+ CHECK(!j.is_binary());
+ CHECK(!j.is_object());
+ CHECK(!j.is_array());
+ CHECK(!j.is_string());
+ CHECK(!j.is_discarded());
CHECK(j.is_primitive());
- CHECK(not j.is_structured());
+ CHECK(!j.is_structured());
}
SECTION("boolean")
{
json j(true);
- CHECK(not j.is_null());
+ CHECK(!j.is_null());
CHECK(j.is_boolean());
- CHECK(not j.is_number());
- CHECK(not j.is_number_integer());
- CHECK(not j.is_number_unsigned());
- CHECK(not j.is_number_float());
- CHECK(not j.is_binary());
- CHECK(not j.is_object());
- CHECK(not j.is_array());
- CHECK(not j.is_string());
- CHECK(not j.is_discarded());
+ CHECK(!j.is_number());
+ CHECK(!j.is_number_integer());
+ CHECK(!j.is_number_unsigned());
+ CHECK(!j.is_number_float());
+ CHECK(!j.is_binary());
+ CHECK(!j.is_object());
+ CHECK(!j.is_array());
+ CHECK(!j.is_string());
+ CHECK(!j.is_discarded());
CHECK(j.is_primitive());
- CHECK(not j.is_structured());
+ CHECK(!j.is_structured());
}
SECTION("string")
{
json j("Hello world");
- CHECK(not j.is_null());
- CHECK(not j.is_boolean());
- CHECK(not j.is_number());
- CHECK(not j.is_number_integer());
- CHECK(not j.is_number_unsigned());
- CHECK(not j.is_number_float());
- CHECK(not j.is_binary());
- CHECK(not j.is_object());
- CHECK(not j.is_array());
+ CHECK(!j.is_null());
+ CHECK(!j.is_boolean());
+ CHECK(!j.is_number());
+ CHECK(!j.is_number_integer());
+ CHECK(!j.is_number_unsigned());
+ CHECK(!j.is_number_float());
+ CHECK(!j.is_binary());
+ CHECK(!j.is_object());
+ CHECK(!j.is_array());
CHECK(j.is_string());
- CHECK(not j.is_discarded());
+ CHECK(!j.is_discarded());
CHECK(j.is_primitive());
- CHECK(not j.is_structured());
+ CHECK(!j.is_structured());
}
SECTION("number (integer)")
{
json j(42);
- CHECK(not j.is_null());
- CHECK(not j.is_boolean());
+ CHECK(!j.is_null());
+ CHECK(!j.is_boolean());
CHECK(j.is_number());
CHECK(j.is_number_integer());
- CHECK(not j.is_number_unsigned());
- CHECK(not j.is_number_float());
- CHECK(not j.is_binary());
- CHECK(not j.is_object());
- CHECK(not j.is_array());
- CHECK(not j.is_string());
- CHECK(not j.is_discarded());
+ CHECK(!j.is_number_unsigned());
+ CHECK(!j.is_number_float());
+ CHECK(!j.is_binary());
+ CHECK(!j.is_object());
+ CHECK(!j.is_array());
+ CHECK(!j.is_string());
+ CHECK(!j.is_discarded());
CHECK(j.is_primitive());
- CHECK(not j.is_structured());
+ CHECK(!j.is_structured());
}
SECTION("number (unsigned)")
{
json j(42u);
- CHECK(not j.is_null());
- CHECK(not j.is_boolean());
+ CHECK(!j.is_null());
+ CHECK(!j.is_boolean());
CHECK(j.is_number());
CHECK(j.is_number_integer());
CHECK(j.is_number_unsigned());
- CHECK(not j.is_number_float());
- CHECK(not j.is_binary());
- CHECK(not j.is_object());
- CHECK(not j.is_array());
- CHECK(not j.is_string());
- CHECK(not j.is_discarded());
+ CHECK(!j.is_number_float());
+ CHECK(!j.is_binary());
+ CHECK(!j.is_object());
+ CHECK(!j.is_array());
+ CHECK(!j.is_string());
+ CHECK(!j.is_discarded());
CHECK(j.is_primitive());
- CHECK(not j.is_structured());
+ CHECK(!j.is_structured());
}
SECTION("number (floating-point)")
{
json j(42.23);
- CHECK(not j.is_null());
- CHECK(not j.is_boolean());
+ CHECK(!j.is_null());
+ CHECK(!j.is_boolean());
CHECK(j.is_number());
- CHECK(not j.is_number_integer());
- CHECK(not j.is_number_unsigned());
+ CHECK(!j.is_number_integer());
+ CHECK(!j.is_number_unsigned());
CHECK(j.is_number_float());
- CHECK(not j.is_binary());
- CHECK(not j.is_object());
- CHECK(not j.is_array());
- CHECK(not j.is_string());
- CHECK(not j.is_discarded());
+ CHECK(!j.is_binary());
+ CHECK(!j.is_object());
+ CHECK(!j.is_array());
+ CHECK(!j.is_string());
+ CHECK(!j.is_discarded());
CHECK(j.is_primitive());
- CHECK(not j.is_structured());
+ CHECK(!j.is_structured());
}
SECTION("binary")
{
json j(json::value_t::binary);
- CHECK(not j.is_null());
- CHECK(not j.is_boolean());
- CHECK(not j.is_number());
- CHECK(not j.is_number_integer());
- CHECK(not j.is_number_unsigned());
- CHECK(not j.is_number_float());
+ CHECK(!j.is_null());
+ CHECK(!j.is_boolean());
+ CHECK(!j.is_number());
+ CHECK(!j.is_number_integer());
+ CHECK(!j.is_number_unsigned());
+ CHECK(!j.is_number_float());
CHECK(j.is_binary());
- CHECK(not j.is_object());
- CHECK(not j.is_array());
- CHECK(not j.is_string());
- CHECK(not j.is_discarded());
+ CHECK(!j.is_object());
+ CHECK(!j.is_array());
+ CHECK(!j.is_string());
+ CHECK(!j.is_discarded());
CHECK(j.is_primitive());
- CHECK(not j.is_structured());
+ CHECK(!j.is_structured());
}
SECTION("discarded")
{
json j(json::value_t::discarded);
- CHECK(not j.is_null());
- CHECK(not j.is_boolean());
- CHECK(not j.is_number());
- CHECK(not j.is_number_integer());
- CHECK(not j.is_number_unsigned());
- CHECK(not j.is_number_float());
- CHECK(not j.is_binary());
- CHECK(not j.is_object());
- CHECK(not j.is_array());
- CHECK(not j.is_string());
+ CHECK(!j.is_null());
+ CHECK(!j.is_boolean());
+ CHECK(!j.is_number());
+ CHECK(!j.is_number_integer());
+ CHECK(!j.is_number_unsigned());
+ CHECK(!j.is_number_float());
+ CHECK(!j.is_binary());
+ CHECK(!j.is_object());
+ CHECK(!j.is_array());
+ CHECK(!j.is_string());
CHECK(j.is_discarded());
- CHECK(not j.is_primitive());
- CHECK(not j.is_structured());
+ CHECK(!j.is_primitive());
+ CHECK(!j.is_structured());
}
}
diff --git a/test/src/unit-items.cpp b/test/src/unit-items.cpp
index 8043fb39..a3f808b2 100644
--- a/test/src/unit-items.cpp
+++ b/test/src/unit-items.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-iterators1.cpp b/test/src/unit-iterators1.cpp
index 633d398d..d389b9f6 100644
--- a/test/src/unit-iterators1.cpp
+++ b/test/src/unit-iterators1.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -231,12 +231,12 @@ TEST_CASE("iterators 1")
{
SECTION("!(begin != begin)")
{
- CHECK(not(j.begin() != j.begin()));
+ CHECK(!(j.begin() != j.begin()));
}
SECTION("!(end != end)")
{
- CHECK(not(j.end() != j.end()));
+ CHECK(!(j.end() != j.end()));
}
SECTION("begin < end")
@@ -286,7 +286,7 @@ TEST_CASE("iterators 1")
SECTION("!(begin == end)")
{
- CHECK(not(j.begin() == j.end()));
+ CHECK(!(j.begin() == j.end()));
}
SECTION("begin != end")
diff --git a/test/src/unit-iterators2.cpp b/test/src/unit-iterators2.cpp
index 58f4c654..c3378e0d 100644
--- a/test/src/unit-iterators2.cpp
+++ b/test/src/unit-iterators2.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -56,26 +56,26 @@ TEST_CASE("iterators 2")
// comparison: equal
{
CHECK(it1 == it1);
- CHECK(not (it1 == it2));
- CHECK(not (it1 == it3));
- CHECK(not (it2 == it3));
+ CHECK(!(it1 == it2));
+ CHECK(!(it1 == it3));
+ CHECK(!(it2 == it3));
CHECK(it1_c == it1_c);
- CHECK(not (it1_c == it2_c));
- CHECK(not (it1_c == it3_c));
- CHECK(not (it2_c == it3_c));
+ CHECK(!(it1_c == it2_c));
+ CHECK(!(it1_c == it3_c));
+ CHECK(!(it2_c == it3_c));
}
// comparison: not equal
{
// check definition
- CHECK( (it1 != it1) == not(it1 == it1) );
- CHECK( (it1 != it2) == not(it1 == it2) );
- CHECK( (it1 != it3) == not(it1 == it3) );
- CHECK( (it2 != it3) == not(it2 == it3) );
- CHECK( (it1_c != it1_c) == not(it1_c == it1_c) );
- CHECK( (it1_c != it2_c) == not(it1_c == it2_c) );
- CHECK( (it1_c != it3_c) == not(it1_c == it3_c) );
- CHECK( (it2_c != it3_c) == not(it2_c == it3_c) );
+ CHECK( (it1 != it1) == !(it1 == it1) );
+ CHECK( (it1 != it2) == !(it1 == it2) );
+ CHECK( (it1 != it3) == !(it1 == it3) );
+ CHECK( (it2 != it3) == !(it2 == it3) );
+ CHECK( (it1_c != it1_c) == !(it1_c == it1_c) );
+ CHECK( (it1_c != it2_c) == !(it1_c == it2_c) );
+ CHECK( (it1_c != it3_c) == !(it1_c == it3_c) );
+ CHECK( (it2_c != it3_c) == !(it2_c == it3_c) );
}
// comparison: smaller
@@ -101,11 +101,11 @@ TEST_CASE("iterators 2")
}
else
{
- CHECK(not (it1 < it1));
+ CHECK(!(it1 < it1));
CHECK(it1 < it2);
CHECK(it1 < it3);
CHECK(it2 < it3);
- CHECK(not (it1_c < it1_c));
+ CHECK(!(it1_c < it1_c));
CHECK(it1_c < it2_c);
CHECK(it1_c < it3_c);
CHECK(it2_c < it3_c);
@@ -136,14 +136,14 @@ TEST_CASE("iterators 2")
else
{
// check definition
- CHECK( (it1 <= it1) == not(it1 < it1) );
- CHECK( (it1 <= it2) == not(it2 < it1) );
- CHECK( (it1 <= it3) == not(it3 < it1) );
- CHECK( (it2 <= it3) == not(it3 < it2) );
- CHECK( (it1_c <= it1_c) == not(it1_c < it1_c) );
- CHECK( (it1_c <= it2_c) == not(it2_c < it1_c) );
- CHECK( (it1_c <= it3_c) == not(it3_c < it1_c) );
- CHECK( (it2_c <= it3_c) == not(it3_c < it2_c) );
+ CHECK( (it1 <= it1) == !(it1 < it1) );
+ CHECK( (it1 <= it2) == !(it2 < it1) );
+ CHECK( (it1 <= it3) == !(it3 < it1) );
+ CHECK( (it2 <= it3) == !(it3 < it2) );
+ CHECK( (it1_c <= it1_c) == !(it1_c < it1_c) );
+ CHECK( (it1_c <= it2_c) == !(it2_c < it1_c) );
+ CHECK( (it1_c <= it3_c) == !(it3_c < it1_c) );
+ CHECK( (it2_c <= it3_c) == !(it3_c < it2_c) );
}
}
@@ -206,14 +206,14 @@ TEST_CASE("iterators 2")
else
{
// check definition
- CHECK( (it1 >= it1) == not(it1 < it1) );
- CHECK( (it1 >= it2) == not(it1 < it2) );
- CHECK( (it1 >= it3) == not(it1 < it3) );
- CHECK( (it2 >= it3) == not(it2 < it3) );
- CHECK( (it1_c >= it1_c) == not(it1_c < it1_c) );
- CHECK( (it1_c >= it2_c) == not(it1_c < it2_c) );
- CHECK( (it1_c >= it3_c) == not(it1_c < it3_c) );
- CHECK( (it2_c >= it3_c) == not(it2_c < it3_c) );
+ CHECK( (it1 >= it1) == !(it1 < it1) );
+ CHECK( (it1 >= it2) == !(it1 < it2) );
+ CHECK( (it1 >= it3) == !(it1 < it3) );
+ CHECK( (it2 >= it3) == !(it2 < it3) );
+ CHECK( (it1_c >= it1_c) == !(it1_c < it1_c) );
+ CHECK( (it1_c >= it2_c) == !(it1_c < it2_c) );
+ CHECK( (it1_c >= it3_c) == !(it1_c < it3_c) );
+ CHECK( (it2_c >= it3_c) == !(it2_c < it3_c) );
}
}
}
@@ -491,26 +491,26 @@ TEST_CASE("iterators 2")
// comparison: equal
{
CHECK(it1 == it1);
- CHECK(not (it1 == it2));
- CHECK(not (it1 == it3));
- CHECK(not (it2 == it3));
+ CHECK(!(it1 == it2));
+ CHECK(!(it1 == it3));
+ CHECK(!(it2 == it3));
CHECK(it1_c == it1_c);
- CHECK(not (it1_c == it2_c));
- CHECK(not (it1_c == it3_c));
- CHECK(not (it2_c == it3_c));
+ CHECK(!(it1_c == it2_c));
+ CHECK(!(it1_c == it3_c));
+ CHECK(!(it2_c == it3_c));
}
// comparison: not equal
{
// check definition
- CHECK( (it1 != it1) == not(it1 == it1) );
- CHECK( (it1 != it2) == not(it1 == it2) );
- CHECK( (it1 != it3) == not(it1 == it3) );
- CHECK( (it2 != it3) == not(it2 == it3) );
- CHECK( (it1_c != it1_c) == not(it1_c == it1_c) );
- CHECK( (it1_c != it2_c) == not(it1_c == it2_c) );
- CHECK( (it1_c != it3_c) == not(it1_c == it3_c) );
- CHECK( (it2_c != it3_c) == not(it2_c == it3_c) );
+ CHECK( (it1 != it1) == !(it1 == it1) );
+ CHECK( (it1 != it2) == !(it1 == it2) );
+ CHECK( (it1 != it3) == !(it1 == it3) );
+ CHECK( (it2 != it3) == !(it2 == it3) );
+ CHECK( (it1_c != it1_c) == !(it1_c == it1_c) );
+ CHECK( (it1_c != it2_c) == !(it1_c == it2_c) );
+ CHECK( (it1_c != it3_c) == !(it1_c == it3_c) );
+ CHECK( (it2_c != it3_c) == !(it2_c == it3_c) );
}
// comparison: smaller
@@ -536,11 +536,11 @@ TEST_CASE("iterators 2")
}
else
{
- CHECK(not (it1 < it1));
+ CHECK(!(it1 < it1));
CHECK(it1 < it2);
CHECK(it1 < it3);
CHECK(it2 < it3);
- CHECK(not (it1_c < it1_c));
+ CHECK(!(it1_c < it1_c));
CHECK(it1_c < it2_c);
CHECK(it1_c < it3_c);
CHECK(it2_c < it3_c);
@@ -571,14 +571,14 @@ TEST_CASE("iterators 2")
else
{
// check definition
- CHECK( (it1 <= it1) == not(it1 < it1) );
- CHECK( (it1 <= it2) == not(it2 < it1) );
- CHECK( (it1 <= it3) == not(it3 < it1) );
- CHECK( (it2 <= it3) == not(it3 < it2) );
- CHECK( (it1_c <= it1_c) == not(it1_c < it1_c) );
- CHECK( (it1_c <= it2_c) == not(it2_c < it1_c) );
- CHECK( (it1_c <= it3_c) == not(it3_c < it1_c) );
- CHECK( (it2_c <= it3_c) == not(it3_c < it2_c) );
+ CHECK( (it1 <= it1) == !(it1 < it1) );
+ CHECK( (it1 <= it2) == !(it2 < it1) );
+ CHECK( (it1 <= it3) == !(it3 < it1) );
+ CHECK( (it2 <= it3) == !(it3 < it2) );
+ CHECK( (it1_c <= it1_c) == !(it1_c < it1_c) );
+ CHECK( (it1_c <= it2_c) == !(it2_c < it1_c) );
+ CHECK( (it1_c <= it3_c) == !(it3_c < it1_c) );
+ CHECK( (it2_c <= it3_c) == !(it3_c < it2_c) );
}
}
@@ -641,14 +641,14 @@ TEST_CASE("iterators 2")
else
{
// check definition
- CHECK( (it1 >= it1) == not(it1 < it1) );
- CHECK( (it1 >= it2) == not(it1 < it2) );
- CHECK( (it1 >= it3) == not(it1 < it3) );
- CHECK( (it2 >= it3) == not(it2 < it3) );
- CHECK( (it1_c >= it1_c) == not(it1_c < it1_c) );
- CHECK( (it1_c >= it2_c) == not(it1_c < it2_c) );
- CHECK( (it1_c >= it3_c) == not(it1_c < it3_c) );
- CHECK( (it2_c >= it3_c) == not(it2_c < it3_c) );
+ CHECK( (it1 >= it1) == !(it1 < it1) );
+ CHECK( (it1 >= it2) == !(it1 < it2) );
+ CHECK( (it1 >= it3) == !(it1 < it3) );
+ CHECK( (it2 >= it3) == !(it2 < it3) );
+ CHECK( (it1_c >= it1_c) == !(it1_c < it1_c) );
+ CHECK( (it1_c >= it2_c) == !(it1_c < it2_c) );
+ CHECK( (it1_c >= it3_c) == !(it1_c < it3_c) );
+ CHECK( (it2_c >= it3_c) == !(it2_c < it3_c) );
}
}
}
diff --git a/test/src/unit-json_patch.cpp b/test/src/unit-json_patch.cpp
index f82e34b0..23f59b0f 100644
--- a/test/src/unit-json_patch.cpp
+++ b/test/src/unit-json_patch.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-json_pointer.cpp b/test/src/unit-json_pointer.cpp
index ca11efa4..7d320bcc 100644
--- a/test/src/unit-json_pointer.cpp
+++ b/test/src/unit-json_pointer.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -101,10 +101,10 @@ TEST_CASE("JSON pointers")
CHECK(j["/foo/1"_json_pointer] == j["foo"][1]);
CHECK(j.contains(json::json_pointer("/foo/0")));
CHECK(j.contains(json::json_pointer("/foo/1")));
- CHECK(not j.contains(json::json_pointer("/foo/3")));
- CHECK(not j.contains(json::json_pointer("/foo/+")));
- CHECK(not j.contains(json::json_pointer("/foo/1+2")));
- CHECK(not j.contains(json::json_pointer("/foo/-")));
+ CHECK(!j.contains(json::json_pointer("/foo/3")));
+ CHECK(!j.contains(json::json_pointer("/foo/+")));
+ CHECK(!j.contains(json::json_pointer("/foo/1+2")));
+ CHECK(!j.contains(json::json_pointer("/foo/-")));
// checked array access
CHECK(j.at(json::json_pointer("/foo/0")) == j["foo"][0]);
@@ -147,19 +147,19 @@ TEST_CASE("JSON pointers")
// unescaped access
// access to nonexisting values yield object creation
- CHECK(not j.contains(json::json_pointer("/a/b")));
+ CHECK(!j.contains(json::json_pointer("/a/b")));
CHECK_NOTHROW(j[json::json_pointer("/a/b")] = 42);
CHECK(j.contains(json::json_pointer("/a/b")));
CHECK(j["a"]["b"] == json(42));
- CHECK(not j.contains(json::json_pointer("/a/c/1")));
+ CHECK(!j.contains(json::json_pointer("/a/c/1")));
CHECK_NOTHROW(j[json::json_pointer("/a/c/1")] = 42);
CHECK(j["a"]["c"] == json({nullptr, 42}));
CHECK(j.contains(json::json_pointer("/a/c/1")));
- CHECK(not j.contains(json::json_pointer("/a/d/-")));
+ CHECK(!j.contains(json::json_pointer("/a/d/-")));
CHECK_NOTHROW(j[json::json_pointer("/a/d/-")] = 42);
- CHECK(not j.contains(json::json_pointer("/a/d/-")));
+ CHECK(!j.contains(json::json_pointer("/a/d/-")));
CHECK(j["a"]["d"] == json::array({42}));
// "/a/b" works for JSON {"a": {"b": 42}}
CHECK(json({{"a", {{"b", 42}}}})[json::json_pointer("/a/b")] == json(42));
@@ -172,7 +172,7 @@ TEST_CASE("JSON pointers")
CHECK_THROWS_AS(j_primitive.at("/foo"_json_pointer), json::out_of_range&);
CHECK_THROWS_WITH(j_primitive.at("/foo"_json_pointer),
"[json.exception.out_of_range.404] unresolved reference token 'foo'");
- CHECK(not j_primitive.contains(json::json_pointer("/foo")));
+ CHECK(!j_primitive.contains(json::json_pointer("/foo")));
}
SECTION("const access")
@@ -272,7 +272,7 @@ TEST_CASE("JSON pointers")
CHECK(j.contains("/foo"_json_pointer));
CHECK(j.contains("/foo/0"_json_pointer));
CHECK(j.contains("/foo/1"_json_pointer));
- CHECK(not j.contains("/foo/-"_json_pointer));
+ CHECK(!j.contains("/foo/-"_json_pointer));
}
}
@@ -314,10 +314,10 @@ TEST_CASE("JSON pointers")
CHECK_THROWS_WITH(j_const.at("/01"_json_pointer),
"[json.exception.parse_error.106] parse error: array index '01' must not begin with '0'");
- CHECK(not j.contains("/01"_json_pointer));
- CHECK(not j.contains("/01"_json_pointer));
- CHECK(not j_const.contains("/01"_json_pointer));
- CHECK(not j_const.contains("/01"_json_pointer));
+ CHECK(!j.contains("/01"_json_pointer));
+ CHECK(!j.contains("/01"_json_pointer));
+ CHECK(!j_const.contains("/01"_json_pointer));
+ CHECK(!j_const.contains("/01"_json_pointer));
// error with incorrect numbers
CHECK_THROWS_AS(j["/one"_json_pointer] = 1, json::parse_error&);
@@ -348,12 +348,29 @@ TEST_CASE("JSON pointers")
CHECK_THROWS_WITH(j_const["/1+1"_json_pointer] == 1,
"[json.exception.out_of_range.404] unresolved reference token '1+1'");
- CHECK_THROWS_AS(j["/111111111111111111111111"_json_pointer] = 1, json::out_of_range&);
- CHECK_THROWS_WITH(j["/111111111111111111111111"_json_pointer] = 1,
- "[json.exception.out_of_range.404] unresolved reference token '111111111111111111111111'");
- CHECK_THROWS_AS(j_const["/111111111111111111111111"_json_pointer] == 1, json::out_of_range&);
- CHECK_THROWS_WITH(j_const["/111111111111111111111111"_json_pointer] == 1,
- "[json.exception.out_of_range.404] unresolved reference token '111111111111111111111111'");
+ {
+ auto too_large_index = std::to_string((std::numeric_limits<unsigned long long>::max)()) + "1";
+ json::json_pointer jp(std::string("/") + too_large_index);
+ std::string throw_msg = std::string("[json.exception.out_of_range.404] unresolved reference token '") + too_large_index + "'";
+
+ CHECK_THROWS_AS(j[jp] = 1, json::out_of_range&);
+ CHECK_THROWS_WITH(j[jp] = 1, throw_msg.c_str());
+ CHECK_THROWS_AS(j_const[jp] == 1, json::out_of_range&);
+ CHECK_THROWS_WITH(j_const[jp] == 1, throw_msg.c_str());
+ }
+
+ if (sizeof(typename json::size_type) < sizeof(unsigned long long))
+ {
+ auto size_type_max_uul = static_cast<unsigned long long>((std::numeric_limits<json::size_type>::max)());
+ auto too_large_index = std::to_string(size_type_max_uul);
+ json::json_pointer jp(std::string("/") + too_large_index);
+ std::string throw_msg = std::string("[json.exception.out_of_range.410] array index ") + too_large_index + " exceeds size_type";
+
+ CHECK_THROWS_AS(j[jp] = 1, json::out_of_range&);
+ CHECK_THROWS_WITH(j[jp] = 1, throw_msg.c_str());
+ CHECK_THROWS_AS(j_const[jp] == 1, json::out_of_range&);
+ CHECK_THROWS_WITH(j_const[jp] == 1, throw_msg.c_str());
+ }
CHECK_THROWS_AS(j.at("/one"_json_pointer) = 1, json::parse_error&);
CHECK_THROWS_WITH(j.at("/one"_json_pointer) = 1,
@@ -362,10 +379,10 @@ TEST_CASE("JSON pointers")
CHECK_THROWS_WITH(j_const.at("/one"_json_pointer) == 1,
"[json.exception.parse_error.109] parse error: array index 'one' is not a number");
- CHECK(not j.contains("/one"_json_pointer));
- CHECK(not j.contains("/one"_json_pointer));
- CHECK(not j_const.contains("/one"_json_pointer));
- CHECK(not j_const.contains("/one"_json_pointer));
+ CHECK(!j.contains("/one"_json_pointer));
+ CHECK(!j.contains("/one"_json_pointer));
+ CHECK(!j_const.contains("/one"_json_pointer));
+ CHECK(!j_const.contains("/one"_json_pointer));
CHECK_THROWS_AS(json({{"/list/0", 1}, {"/list/1", 2}, {"/list/three", 3}}).unflatten(), json::parse_error&);
CHECK_THROWS_WITH(json({{"/list/0", 1}, {"/list/1", 2}, {"/list/three", 3}}).unflatten(),
@@ -379,7 +396,7 @@ TEST_CASE("JSON pointers")
CHECK_THROWS_AS(j_const["/-"_json_pointer], json::out_of_range&);
CHECK_THROWS_WITH(j_const["/-"_json_pointer],
"[json.exception.out_of_range.402] array index '-' (3) is out of range");
- CHECK(not j_const.contains("/-"_json_pointer));
+ CHECK(!j_const.contains("/-"_json_pointer));
// error when using "-" with at
CHECK_THROWS_AS(j.at("/-"_json_pointer), json::out_of_range&);
@@ -388,7 +405,7 @@ TEST_CASE("JSON pointers")
CHECK_THROWS_AS(j_const.at("/-"_json_pointer), json::out_of_range&);
CHECK_THROWS_WITH(j_const.at("/-"_json_pointer),
"[json.exception.out_of_range.402] array index '-' (3) is out of range");
- CHECK(not j_const.contains("/-"_json_pointer));
+ CHECK(!j_const.contains("/-"_json_pointer));
}
SECTION("const access")
@@ -404,13 +421,13 @@ TEST_CASE("JSON pointers")
CHECK_THROWS_AS(j.at("/3"_json_pointer), json::out_of_range&);
CHECK_THROWS_WITH(j.at("/3"_json_pointer),
"[json.exception.out_of_range.401] array index 3 is out of range");
- CHECK(not j.contains("/3"_json_pointer));
+ CHECK(!j.contains("/3"_json_pointer));
// assign to nonexisting index (with gap)
CHECK_THROWS_AS(j.at("/5"_json_pointer), json::out_of_range&);
CHECK_THROWS_WITH(j.at("/5"_json_pointer),
"[json.exception.out_of_range.401] array index 5 is out of range");
- CHECK(not j.contains("/5"_json_pointer));
+ CHECK(!j.contains("/5"_json_pointer));
// assign to "-"
CHECK_THROWS_AS(j["/-"_json_pointer], json::out_of_range&);
@@ -419,7 +436,7 @@ TEST_CASE("JSON pointers")
CHECK_THROWS_AS(j.at("/-"_json_pointer), json::out_of_range&);
CHECK_THROWS_WITH(j.at("/-"_json_pointer),
"[json.exception.out_of_range.402] array index '-' (3) is out of range");
- CHECK(not j.contains("/-"_json_pointer));
+ CHECK(!j.contains("/-"_json_pointer));
}
}
diff --git a/test/src/unit-large_json.cpp b/test/src/unit-large_json.cpp
index 455af49f..175b0cd6 100644
--- a/test/src/unit-large_json.cpp
+++ b/test/src/unit-large_json.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-merge_patch.cpp b/test/src/unit-merge_patch.cpp
index 4bab7828..c664f8f3 100644
--- a/test/src/unit-merge_patch.cpp
+++ b/test/src/unit-merge_patch.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-meta.cpp b/test/src/unit-meta.cpp
index 243de046..48ef35c1 100644
--- a/test/src/unit-meta.cpp
+++ b/test/src/unit-meta.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -39,13 +39,13 @@ TEST_CASE("version information")
json j = json::meta();
CHECK(j["name"] == "JSON for Modern C++");
- CHECK(j["copyright"] == "(C) 2013-2017 Niels Lohmann");
+ CHECK(j["copyright"] == "(C) 2013-2020 Niels Lohmann");
CHECK(j["url"] == "https://github.com/nlohmann/json");
CHECK(j["version"] == json(
{
- {"string", "3.8.0"},
+ {"string", "3.9.0"},
{"major", 3},
- {"minor", 8},
+ {"minor", 9},
{"patch", 0}
}));
diff --git a/test/src/unit-modifiers.cpp b/test/src/unit-modifiers.cpp
index 6e7031b7..4f5b5729 100644
--- a/test/src/unit-modifiers.cpp
+++ b/test/src/unit-modifiers.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -114,7 +114,7 @@ TEST_CASE("modifiers")
json k = j;
j.clear();
- CHECK(not j.empty());
+ CHECK(!j.empty());
CHECK(j == json(json::value_t::binary));
CHECK(j == json(k.type()));
}
@@ -125,7 +125,7 @@ TEST_CASE("modifiers")
json k = j;
j.clear();
- CHECK(not j.empty());
+ CHECK(!j.empty());
CHECK(j == json(json::value_t::binary));
CHECK(j == json(k.type()));
}
@@ -878,7 +878,8 @@ TEST_CASE("modifiers")
json j("hello world");
json k(42.23);
- std::swap(j, k);
+ using std::swap;
+ swap(j, k);
CHECK(j == json(42.23));
CHECK(k == json("hello world"));
diff --git a/test/src/unit-msgpack.cpp b/test/src/unit-msgpack.cpp
index 2744a67b..42089555 100644
--- a/test/src/unit-msgpack.cpp
+++ b/test/src/unit-msgpack.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -37,6 +37,7 @@ using nlohmann::json;
#include <iomanip>
#include <set>
#include <test_data.hpp>
+#include "test_utils.hpp"
namespace
{
@@ -514,7 +515,7 @@ TEST_CASE("MessagePack")
(static_cast<uint32_t>(result[2]) << 020) +
(static_cast<uint32_t>(result[3]) << 010) +
static_cast<uint32_t>(result[4]);
- CHECK(restored == i);
+ CHECK(static_cast<std::int32_t>(restored) == i);
// roundtrip
CHECK(json::from_msgpack(result) == j);
@@ -783,6 +784,40 @@ TEST_CASE("MessagePack")
CHECK(json::from_msgpack(result) == v);
CHECK(json::from_msgpack(result, true, false) == j);
}
+
+ SECTION("1.0")
+ {
+ double v = 1.0;
+ json j = v;
+ std::vector<uint8_t> expected =
+ {
+ 0xca, 0x3f, 0x80, 0x00, 0x00
+ };
+ const auto result = json::to_msgpack(j);
+ CHECK(result == expected);
+
+ // roundtrip
+ CHECK(json::from_msgpack(result) == j);
+ CHECK(json::from_msgpack(result) == v);
+ CHECK(json::from_msgpack(result, true, false) == j);
+ }
+
+ SECTION("128.128")
+ {
+ double v = 128.1280059814453125;
+ json j = v;
+ std::vector<uint8_t> expected =
+ {
+ 0xca, 0x43, 0x00, 0x20, 0xc5
+ };
+ const auto result = json::to_msgpack(j);
+ CHECK(result == expected);
+
+ // roundtrip
+ CHECK(json::from_msgpack(result) == j);
+ CHECK(json::from_msgpack(result) == v);
+ CHECK(json::from_msgpack(result, true, false) == j);
+ }
}
}
@@ -1544,21 +1579,21 @@ TEST_CASE("MessagePack")
{
std::vector<uint8_t> v = {0x93, 0x01, 0x02, 0x03};
SaxCountdown scp(0);
- CHECK(not json::sax_parse(v, &scp, json::input_format_t::msgpack));
+ CHECK(!json::sax_parse(v, &scp, json::input_format_t::msgpack));
}
SECTION("start_object(len)")
{
std::vector<uint8_t> v = {0x81, 0xa3, 0x66, 0x6F, 0x6F, 0xc2};
SaxCountdown scp(0);
- CHECK(not json::sax_parse(v, &scp, json::input_format_t::msgpack));
+ CHECK(!json::sax_parse(v, &scp, json::input_format_t::msgpack));
}
SECTION("key()")
{
std::vector<uint8_t> v = {0x81, 0xa3, 0x66, 0x6F, 0x6F, 0xc2};
SaxCountdown scp(1);
- CHECK(not json::sax_parse(v, &scp, json::input_format_t::msgpack));
+ CHECK(!json::sax_parse(v, &scp, json::input_format_t::msgpack));
}
}
}
@@ -1575,9 +1610,7 @@ TEST_CASE("single MessagePack roundtrip")
json j1 = json::parse(f_json);
// parse MessagePack file
- std::ifstream f_msgpack(filename + ".msgpack", std::ios::binary);
- std::vector<uint8_t> packed((std::istreambuf_iterator<char>(f_msgpack)),
- std::istreambuf_iterator<char>());
+ auto packed = utils::read_binary_file(filename + ".msgpack");
json j2;
CHECK_NOTHROW(j2 = json::from_msgpack(packed));
@@ -1790,10 +1823,7 @@ TEST_CASE("MessagePack roundtrips" * doctest::skip())
json j1 = json::parse(f_json);
// parse MessagePack file
- std::ifstream f_msgpack(filename + ".msgpack", std::ios::binary);
- std::vector<uint8_t> packed(
- (std::istreambuf_iterator<char>(f_msgpack)),
- std::istreambuf_iterator<char>());
+ auto packed = utils::read_binary_file(filename + ".msgpack");
json j2;
CHECK_NOTHROW(j2 = json::from_msgpack(packed));
@@ -1823,10 +1853,7 @@ TEST_CASE("MessagePack roundtrips" * doctest::skip())
json j1 = json::parse(f_json);
// parse MessagePack file
- std::ifstream f_msgpack(filename + ".msgpack", std::ios::binary);
- std::vector<uint8_t> packed(
- (std::istreambuf_iterator<char>(f_msgpack)),
- std::istreambuf_iterator<char>());
+ auto packed = utils::read_binary_file(filename + ".msgpack");
json j2;
CHECK_NOTHROW(j2 = json::from_msgpack({packed.data(), packed.size()}));
@@ -1841,10 +1868,7 @@ TEST_CASE("MessagePack roundtrips" * doctest::skip())
json j1 = json::parse(f_json);
// parse MessagePack file
- std::ifstream f_msgpack(filename + ".msgpack", std::ios::binary);
- std::vector<uint8_t> packed(
- (std::istreambuf_iterator<char>(f_msgpack)),
- std::istreambuf_iterator<char>());
+ auto packed = utils::read_binary_file(filename + ".msgpack");
if (!exclude_packed.count(filename))
{
diff --git a/test/src/unit-noexcept.cpp b/test/src/unit-noexcept.cpp
index f3a96de4..4ed0f709 100644
--- a/test/src/unit-noexcept.cpp
+++ b/test/src/unit-noexcept.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -59,12 +59,12 @@ static_assert(noexcept(nlohmann::to_json(*j, 2.5)), "");
static_assert(noexcept(nlohmann::to_json(*j, true)), "");
static_assert(noexcept(nlohmann::to_json(*j, test{})), "");
static_assert(noexcept(nlohmann::to_json(*j, pod{})), "");
-static_assert(not noexcept(nlohmann::to_json(*j, pod_bis{})), "");
+static_assert(!noexcept(nlohmann::to_json(*j, pod_bis{})), "");
static_assert(noexcept(json(2)), "");
static_assert(noexcept(json(test{})), "");
static_assert(noexcept(json(pod{})), "");
static_assert(noexcept(j->get<pod>()), "");
-static_assert(not noexcept(j->get<pod_bis>()), "");
+static_assert(!noexcept(j->get<pod_bis>()), "");
static_assert(noexcept(json(pod{})), "");
}
diff --git a/test/src/unit-ordered_json.cpp b/test/src/unit-ordered_json.cpp
new file mode 100644
index 00000000..0c8e7154
--- /dev/null
+++ b/test/src/unit-ordered_json.cpp
@@ -0,0 +1,79 @@
+/*
+ __ _____ _____ _____
+ __| | __| | | | JSON for Modern C++ (test suite)
+| | |__ | | | | | | version 3.9.0
+|_____|_____|_____|_|___| https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "doctest_compatibility.h"
+
+#include <nlohmann/json.hpp>
+using nlohmann::json;
+using nlohmann::ordered_json;
+
+
+TEST_CASE("ordered_json")
+{
+ json j;
+ ordered_json oj;
+
+ j["element3"] = 3;
+ j["element1"] = 1;
+ j["element2"] = 2;
+
+ oj["element3"] = 3;
+ oj["element1"] = 1;
+ oj["element2"] = 2;
+
+ CHECK(j.dump() == "{\"element1\":1,\"element2\":2,\"element3\":3}");
+ CHECK(oj.dump() == "{\"element3\":3,\"element1\":1,\"element2\":2}");
+
+ CHECK(j == json(oj));
+ CHECK(ordered_json(json(oj)) == ordered_json(j));
+
+ j.erase("element1");
+ oj.erase("element1");
+
+ CHECK(j.dump() == "{\"element2\":2,\"element3\":3}");
+ CHECK(oj.dump() == "{\"element3\":3,\"element2\":2}");
+
+ // remove again and nothing changes
+ j.erase("element1");
+ oj.erase("element1");
+
+ CHECK(j.dump() == "{\"element2\":2,\"element3\":3}");
+ CHECK(oj.dump() == "{\"element3\":3,\"element2\":2}");
+
+ // There are no dup keys cause constructor calls emplace...
+ json multi {{"z", 1}, {"m", 2}, {"m", 3}, {"y", 4}, {"m", 5}};
+ CHECK(multi.size() == 3);
+ CHECK(multi.dump() == "{\"m\":2,\"y\":4,\"z\":1}");
+
+ ordered_json multi_ordered {{"z", 1}, {"m", 2}, {"m", 3}, {"y", 4}, {"m", 5}};
+ CHECK(multi_ordered.size() == 3);
+ CHECK(multi_ordered.dump() == "{\"z\":1,\"m\":2,\"y\":4}");
+ CHECK(multi_ordered.erase("m") == 1);
+ CHECK(multi_ordered.dump() == "{\"z\":1,\"y\":4}");
+}
diff --git a/test/src/unit-pointer_access.cpp b/test/src/unit-pointer_access.cpp
index 1113d202..c353c17c 100644
--- a/test/src/unit-pointer_access.cpp
+++ b/test/src/unit-pointer_access.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-readme.cpp b/test/src/unit-readme.cpp
index e6089a32..729ee954 100644
--- a/test/src/unit-readme.cpp
+++ b/test/src/unit-readme.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -174,9 +174,9 @@ TEST_CASE("README" * doctest::skip())
}
// getter/setter
- const std::string tmp = j[0];
+ const auto tmp = j[0].get<std::string>();
j[1] = 42;
- bool foo = j.at(2);
+ bool foo{j.at(2)};
CHECK(foo == true);
// other stuff
@@ -258,18 +258,18 @@ TEST_CASE("README" * doctest::skip())
// strings
std::string s1 = "Hello, world!";
json js = s1;
- std::string s2 = js;
+ auto s2 = js.get<std::string>();
// Booleans
bool b1 = true;
json jb = b1;
- bool b2 = jb;
+ bool b2{jb};
CHECK(b2 == true);
// numbers
int i = 42;
json jn = i;
- double f = jn;
+ double f{jn};
CHECK(f == 42);
// etc.
diff --git a/test/src/unit-reference_access.cpp b/test/src/unit-reference_access.cpp
index 69f65102..9cbc7aea 100644
--- a/test/src/unit-reference_access.cpp
+++ b/test/src/unit-reference_access.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-regression.cpp b/test/src/unit-regression.cpp
index e5cd0337..223466a4 100644
--- a/test/src/unit-regression.cpp
+++ b/test/src/unit-regression.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -240,12 +240,12 @@ TEST_CASE("regression tests")
{
json j1 = NAN;
CHECK(j1.is_number_float());
- json::number_float_t f1 = j1;
+ json::number_float_t f1{j1};
CHECK(std::isnan(f1));
json j2 = json::number_float_t(NAN);
CHECK(j2.is_number_float());
- json::number_float_t f2 = j2;
+ json::number_float_t f2{j2};
CHECK(std::isnan(f2));
}
@@ -253,13 +253,13 @@ TEST_CASE("regression tests")
{
json j1 = INFINITY;
CHECK(j1.is_number_float());
- json::number_float_t f1 = j1;
- CHECK(not std::isfinite(f1));
+ json::number_float_t f1{j1};
+ CHECK(!std::isfinite(f1));
json j2 = json::number_float_t(INFINITY);
CHECK(j2.is_number_float());
- json::number_float_t f2 = j2;
- CHECK(not std::isfinite(f2));
+ json::number_float_t f2{j2};
+ CHECK(!std::isfinite(f2));
}
}
@@ -332,11 +332,11 @@ TEST_CASE("regression tests")
json j;
ss >> j;
- std::string test = j["Test"];
+ auto test = j["Test"].get<std::string>();
CHECK(test == "Test1");
- int number = j["Number"];
+ int number{j["Number"]};
CHECK(number == 100);
- float foo = j["Foo"];
+ float foo{j["Foo"]};
CHECK(static_cast<double>(foo) == Approx(42.42));
}
@@ -453,6 +453,7 @@ TEST_CASE("regression tests")
CHECK(j["string"] == "\u0007\u0007");
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("issue #144 - implicit assignment to std::string fails")
{
json o = {{"name", "value"}};
@@ -470,6 +471,7 @@ TEST_CASE("regression tests")
CHECK_THROWS_AS(s2 = o["int"], json::type_error);
CHECK_THROWS_WITH(s2 = o["int"], "[json.exception.type_error.302] type must be string, but is number");
}
+#endif
SECTION("issue #146 - character following a surrogate pair is skipped")
{
@@ -689,7 +691,7 @@ TEST_CASE("regression tests")
{"object", {{"key1", 1}, {"key2", 2}}},
};
- int at_integer = j.at("/object/key2"_json_pointer);
+ int at_integer{j.at("/object/key2"_json_pointer)};
int val_integer = j.value("/object/key2"_json_pointer, 0);
CHECK(at_integer == val_integer);
@@ -1233,6 +1235,7 @@ TEST_CASE("regression tests")
CHECK(j["double_value"].is_number_float());
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("issue #464 - VS2017 implicit to std::string conversion fix")
{
json v = "test";
@@ -1240,6 +1243,7 @@ TEST_CASE("regression tests")
test = v;
CHECK(v == "test");
}
+#endif
SECTION("issue #465 - roundtrip error while parsing 1000000000000000010E5")
{
@@ -1250,6 +1254,7 @@ TEST_CASE("regression tests")
CHECK(s1 == s2);
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("issue #473 - inconsistent behavior in conversion to array type")
{
json j_array = {1, 2, 3, 4};
@@ -1298,6 +1303,7 @@ TEST_CASE("regression tests")
CHECK_THROWS_WITH(create(j_null), "[json.exception.type_error.302] type must be array, but is null");
}
}
+#endif
SECTION("issue #486 - json::value_t can't be a map's key type in VC++ 2015")
{
@@ -1350,10 +1356,10 @@ TEST_CASE("regression tests")
CHECK(j["a"] > 3);
- CHECK(not(j["a"] <= 4));
- CHECK(not(j["a"] < 4));
- CHECK(not(j["a"] >= 6));
- CHECK(not(j["a"] > 6));
+ CHECK(!(j["a"] <= 4));
+ CHECK(!(j["a"] < 4));
+ CHECK(!(j["a"] >= 6));
+ CHECK(!(j["a"] > 6));
// scalar op json
CHECK(5 == j["a"]);
@@ -1364,10 +1370,10 @@ TEST_CASE("regression tests")
CHECK(3 <= j["a"]);
CHECK(3 < j["a"]);
- CHECK(not(4 >= j["a"]));
- CHECK(not(4 > j["a"]));
- CHECK(not(6 <= j["a"]));
- CHECK(not(6 < j["a"]));
+ CHECK(!(4 >= j["a"]));
+ CHECK(!(4 > j["a"]));
+ CHECK(!(6 <= j["a"]));
+ CHECK(!(6 < j["a"]));
}
SECTION("issue #575 - heap-buffer-overflow (OSS-Fuzz 1400)")
@@ -1377,6 +1383,7 @@ TEST_CASE("regression tests")
CHECK_THROWS_AS(_ = json::parse(vec), json::parse_error&);
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("issue #600 - how does one convert a map in Json back to std::map?")
{
SECTION("example 1")
@@ -1409,6 +1416,7 @@ TEST_CASE("regression tests")
CHECK(m1 == m2);
}
}
+#endif
SECTION("issue #602 - BOM not skipped when using json:parse(iterator)")
{
@@ -1417,6 +1425,7 @@ TEST_CASE("regression tests")
CHECK_NOTHROW(_ = json::parse(i.begin(), i.end()));
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("issue #702 - conversion from valarray<double> to json fails to build")
{
SECTION("original example")
@@ -1445,6 +1454,7 @@ TEST_CASE("regression tests")
"[json.exception.type_error.302] type must be array, but is null");
}
}
+#endif
SECTION("issue #367 - Behavior of operator>> should more closely resemble that of built-in overloads.")
{
@@ -1456,9 +1466,9 @@ TEST_CASE("regression tests")
i1_2_3 >> j2;
i1_2_3 >> j3;
- std::map<std::string, std::string> m1 = j1;
- std::map<std::string, std::string> m2 = j2;
- int i3 = j3;
+ auto m1 = j1.get<std::map<std::string, std::string>>();
+ auto m2 = j2.get<std::map<std::string, std::string>>();
+ int i3{j3};
CHECK( m1 == ( std::map<std::string, std::string> {{ "first", "one" }} ));
CHECK( m2 == ( std::map<std::string, std::string> {{ "second", "two" }} ));
@@ -1506,13 +1516,14 @@ TEST_CASE("regression tests")
SECTION("issue #838 - incorrect parse error with binary data in keys")
{
- uint8_t key1[] = { 103, 92, 117, 48, 48, 48, 55, 92, 114, 215, 126, 214, 95, 92, 34, 174, 40, 71, 38, 174, 40, 71, 38, 223, 134, 247, 127 };
- std::string key1_str(key1, key1 + sizeof(key1) / sizeof(key1[0]));
+ uint8_t key1[] = { 103, 92, 117, 48, 48, 48, 55, 92, 114, 215, 126, 214, 95, 92, 34, 174, 40, 71, 38, 174, 40, 71, 38, 223, 134, 247, 127, 0 };
+ std::string key1_str(reinterpret_cast<char*>(key1));
json j = key1_str;
CHECK_THROWS_AS(j.dump(), json::type_error&);
CHECK_THROWS_WITH(j.dump(), "[json.exception.type_error.316] invalid UTF-8 byte at index 10: 0x7E");
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("issue #843 - converting to array not working")
{
json j;
@@ -1520,6 +1531,7 @@ TEST_CASE("regression tests")
j = ar;
ar = j;
}
+#endif
SECTION("issue #894 - invalid RFC6902 copy operation succeeds")
{
@@ -1608,7 +1620,7 @@ TEST_CASE("regression tests")
json::parser_callback_t cb = [](int /*depth*/, json::parse_event_t event, json & parsed)
{
// skip object elements with key "Thumbnail"
- if (event == json::parse_event_t::key and parsed == json("Thumbnail"))
+ if (event == json::parse_event_t::key && parsed == json("Thumbnail"))
{
return false;
}
@@ -1632,7 +1644,7 @@ TEST_CASE("regression tests")
SECTION("issue #977 - Assigning between different json types")
{
foo_json lj = ns::foo{3};
- ns::foo ff = lj;
+ ns::foo ff(lj);
CHECK(lj.is_object());
CHECK(lj.size() == 1);
CHECK(lj["x"] == 3);
@@ -1680,7 +1692,7 @@ TEST_CASE("regression tests")
json::parser_callback_t cb = [&](int, json::parse_event_t event, json & parsed)
{
// skip uninteresting events
- if (event == json::parse_event_t::value and !parsed.is_primitive())
+ if (event == json::parse_event_t::value && !parsed.is_primitive())
{
return false;
}
@@ -1760,7 +1772,7 @@ TEST_CASE("regression tests")
SECTION("issue #1292 - Serializing std::variant causes stack overflow")
{
static_assert(
- not std::is_constructible<json, std::variant<int, float>>::value, "");
+ !std::is_constructible<json, std::variant<int, float>>::value, "");
}
#endif
@@ -1880,7 +1892,7 @@ TEST_CASE("regression tests")
{
{
json j;
- NonDefaultFromJsonStruct x = j;
+ NonDefaultFromJsonStruct x(j);
NonDefaultFromJsonStruct y;
CHECK(x == y);
}
@@ -1945,9 +1957,28 @@ TEST_CASE("regression tests")
)
);
}
+
+ SECTION("PR #2181 - regression bug with lvalue")
+ {
+ // see https://github.com/nlohmann/json/pull/2181#issuecomment-653326060
+ json j{{"x", "test"}};
+ std::string defval = "default value";
+ auto val = j.value("x", defval);
+ auto val2 = j.value("y", defval);
+ }
+
+ SECTION("issue #2293 - eof doesnt cause parsing to stop")
+ {
+ std::vector<uint8_t> data =
+ {
+ 0x7B, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x20, 0x4F, 0x42
+ };
+ json result = json::from_cbor(data, true, false);
+ CHECK(result.is_discarded());
+ }
}
-#if not defined(JSON_NOEXCEPTION)
+#if !defined(JSON_NOEXCEPTION)
TEST_CASE("regression tests, exceptions dependent")
{
SECTION("issue #1340 - eof not set on exhausted input stream")
@@ -1965,9 +1996,14 @@ TEST_CASE("regression tests, exceptions dependent")
/////////////////////////////////////////////////////////////////////
// for #1642
/////////////////////////////////////////////////////////////////////
+
+// the code below fails with Clang on Windows, so we need to exclude it there
+#if defined(__clang__) && (defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__))
+#else
template <typename T> class array {};
template <typename T> class object {};
template <typename T> class string {};
template <typename T> class number_integer {};
template <typename T> class number_unsigned {};
template <typename T> class number_float {};
+#endif
diff --git a/test/src/unit-serialization.cpp b/test/src/unit-serialization.cpp
index e7051d88..2308dd2a 100644
--- a/test/src/unit-serialization.cpp
+++ b/test/src/unit-serialization.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-testsuites.cpp b/test/src/unit-testsuites.cpp
index 7082de3c..f5e0ec10 100644
--- a/test/src/unit-testsuites.cpp
+++ b/test/src/unit-testsuites.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1235,7 +1235,7 @@ TEST_CASE("nst's JSONTestSuite (2)")
json _;
CHECK_THROWS_AS(_ = json::parse(f), json::parse_error&);
std::ifstream f2(filename);
- CHECK(not json::accept(f2));
+ CHECK(!json::accept(f2));
}
}
@@ -1250,7 +1250,7 @@ TEST_CASE("nst's JSONTestSuite (2)")
{
CAPTURE(filename)
std::ifstream f(filename);
- CHECK(not json::accept(f));
+ CHECK(!json::accept(f));
}
}
@@ -1352,7 +1352,7 @@ TEST_CASE("nst's JSONTestSuite (2)")
json _;
CHECK_THROWS_AS(_ = json::parse(f), json::exception&); // could be parse_error or out_of_range
std::ifstream f2(filename);
- CHECK(not json::accept(f2));
+ CHECK(!json::accept(f2));
}
}
}
diff --git a/test/src/unit-to_chars.cpp b/test/src/unit-to_chars.cpp
index 8853b199..386c4cc2 100644
--- a/test/src/unit-to_chars.cpp
+++ b/test/src/unit-to_chars.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-ubjson.cpp b/test/src/unit-ubjson.cpp
index fab25d2e..3c72ddbb 100644
--- a/test/src/unit-ubjson.cpp
+++ b/test/src/unit-ubjson.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -32,9 +32,11 @@ SOFTWARE.
#include <nlohmann/json.hpp>
using nlohmann::json;
+#include <iostream>
#include <fstream>
#include <set>
#include <test_data.hpp>
+#include "test_utils.hpp"
namespace
{
@@ -767,6 +769,65 @@ TEST_CASE("UBJSON")
CHECK(json::from_ubjson(result, true, false) == j);
}
}
+
+ SECTION("high-precision number")
+ {
+ SECTION("unsigned integer number")
+ {
+ std::vector<uint8_t> vec = {'H', 'i', 0x14, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0'};
+ const auto j = json::from_ubjson(vec);
+ CHECK(j.is_number_unsigned());
+ CHECK(j.dump() == "12345678901234567890");
+ }
+
+ SECTION("signed integer number")
+ {
+ std::vector<uint8_t> vec = {'H', 'i', 0x13, '-', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8'};
+ const auto j = json::from_ubjson(vec);
+ CHECK(j.is_number_integer());
+ CHECK(j.dump() == "-123456789012345678");
+ }
+
+ SECTION("floating-point number")
+ {
+ std::vector<uint8_t> vec = {'H', 'i', 0x16, '3', '.', '1', '4', '1', '5', '9', '2', '6', '5', '3', '5', '8', '9', '7', '9', '3', '2', '3', '8', '4', '6'};
+ const auto j = json::from_ubjson(vec);
+ CHECK(j.is_number_float());
+ CHECK(j.dump() == "3.141592653589793");
+ }
+
+ SECTION("errors")
+ {
+ // error while parsing length
+ std::vector<uint8_t> vec0 = {'H', 'i'};
+ CHECK(json::from_ubjson(vec0, true, false).is_discarded());
+ // error while parsing string
+ std::vector<uint8_t> vec1 = {'H', 'i', '1'};
+ CHECK(json::from_ubjson(vec1, true, false).is_discarded());
+
+ std::vector<uint8_t> vec2 = {'H', 'i', 2, '1', 'A', '3'};
+ CHECK_THROWS_WITH_AS(json::from_ubjson(vec2), "[json.exception.parse_error.115] parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1A", json::parse_error);
+ std::vector<uint8_t> vec3 = {'H', 'i', 2, '1', '.'};
+ CHECK_THROWS_WITH_AS(json::from_ubjson(vec3), "[json.exception.parse_error.115] parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1.", json::parse_error);
+ std::vector<uint8_t> vec4 = {'H', 2, '1', '0'};
+ CHECK_THROWS_WITH_AS(json::from_ubjson(vec4), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing UBJSON size: expected length type specification (U, i, I, l, L) after '#'; last byte: 0x02", json::parse_error);
+ }
+
+ SECTION("serialization")
+ {
+ // number that does not fit int64
+ json j = 11111111111111111111ULL;
+ CHECK(j.is_number_unsigned());
+
+ // number will be serialized to high-precision number
+ const auto vec = json::to_ubjson(j);
+ std::vector<uint8_t> expected = {'H', 'i', 0x14, '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1'};
+ CHECK(vec == expected);
+
+ // roundtrip
+ CHECK(json::from_ubjson(vec) == j);
+ }
+ }
}
SECTION("string")
@@ -1539,15 +1600,6 @@ TEST_CASE("UBJSON")
}
}
- SECTION("number out of range")
- {
- // larger than max int64
- json j = 9223372036854775808llu;
- json _;
- CHECK_THROWS_AS(_ = json::to_ubjson(j), json::out_of_range&);
- CHECK_THROWS_WITH(_ = json::to_ubjson(j), "[json.exception.out_of_range.407] integer number 9223372036854775808 cannot be represented by UBJSON as it does not fit int64");
- }
-
SECTION("excessive size")
{
SECTION("array")
@@ -1586,42 +1638,42 @@ TEST_CASE("UBJSON")
{
std::vector<uint8_t> v = {'[', 'T', 'F', ']'};
SaxCountdown scp(0);
- CHECK(not json::sax_parse(v, &scp, json::input_format_t::ubjson));
+ CHECK(!json::sax_parse(v, &scp, json::input_format_t::ubjson));
}
SECTION("start_object()")
{
std::vector<uint8_t> v = {'{', 'i', 3, 'f', 'o', 'o', 'F', '}'};
SaxCountdown scp(0);
- CHECK(not json::sax_parse(v, &scp, json::input_format_t::ubjson));
+ CHECK(!json::sax_parse(v, &scp, json::input_format_t::ubjson));
}
SECTION("key() in object")
{
std::vector<uint8_t> v = {'{', 'i', 3, 'f', 'o', 'o', 'F', '}'};
SaxCountdown scp(1);
- CHECK(not json::sax_parse(v, &scp, json::input_format_t::ubjson));
+ CHECK(!json::sax_parse(v, &scp, json::input_format_t::ubjson));
}
SECTION("start_array(len)")
{
std::vector<uint8_t> v = {'[', '#', 'i', '2', 'T', 'F'};
SaxCountdown scp(0);
- CHECK(not json::sax_parse(v, &scp, json::input_format_t::ubjson));
+ CHECK(!json::sax_parse(v, &scp, json::input_format_t::ubjson));
}
SECTION("start_object(len)")
{
std::vector<uint8_t> v = {'{', '#', 'i', '1', 3, 'f', 'o', 'o', 'F'};
SaxCountdown scp(0);
- CHECK(not json::sax_parse(v, &scp, json::input_format_t::ubjson));
+ CHECK(!json::sax_parse(v, &scp, json::input_format_t::ubjson));
}
SECTION("key() in object with length")
{
std::vector<uint8_t> v = {'{', 'i', 3, 'f', 'o', 'o', 'F', '}'};
SaxCountdown scp(1);
- CHECK(not json::sax_parse(v, &scp, json::input_format_t::ubjson));
+ CHECK(!json::sax_parse(v, &scp, json::input_format_t::ubjson));
}
}
@@ -2363,13 +2415,13 @@ TEST_CASE("Universal Binary JSON Specification Examples 1")
}
}
-#if not defined(JSON_NOEXCEPTION)
+#if !defined(JSON_NOEXCEPTION)
TEST_CASE("all UBJSON first bytes")
{
// these bytes will fail immediately with exception parse_error.112
std::set<uint8_t> supported =
{
- 'T', 'F', 'Z', 'U', 'i', 'I', 'l', 'L', 'd', 'D', 'C', 'S', '[', '{', 'N'
+ 'T', 'F', 'Z', 'U', 'i', 'I', 'l', 'L', 'd', 'D', 'C', 'S', '[', '{', 'N', 'H'
};
for (auto i = 0; i < 256; ++i)
@@ -2457,11 +2509,8 @@ TEST_CASE("UBJSON roundtrips" * doctest::skip())
std::ifstream f_json(filename);
json j1 = json::parse(f_json);
- // parse MessagePack file
- std::ifstream f_ubjson(filename + ".ubjson", std::ios::binary);
- std::vector<uint8_t> packed(
- (std::istreambuf_iterator<char>(f_ubjson)),
- std::istreambuf_iterator<char>());
+ // parse UBJSON file
+ auto packed = utils::read_binary_file(filename + ".ubjson");
json j2;
CHECK_NOTHROW(j2 = json::from_ubjson(packed));
@@ -2475,7 +2524,7 @@ TEST_CASE("UBJSON roundtrips" * doctest::skip())
std::ifstream f_json(filename);
json j1 = json::parse(f_json);
- // parse MessagePack file
+ // parse UBJSON file
std::ifstream f_ubjson(filename + ".ubjson", std::ios::binary);
json j2;
CHECK_NOTHROW(j2 = json::from_ubjson(f_ubjson));
@@ -2490,11 +2539,8 @@ TEST_CASE("UBJSON roundtrips" * doctest::skip())
std::ifstream f_json(filename);
json j1 = json::parse(f_json);
- // parse MessagePack file
- std::ifstream f_ubjson(filename + ".ubjson", std::ios::binary);
- std::vector<uint8_t> packed(
- (std::istreambuf_iterator<char>(f_ubjson)),
- std::istreambuf_iterator<char>());
+ // parse UBJSON file
+ auto packed = utils::read_binary_file(filename + ".ubjson");
json j2;
CHECK_NOTHROW(j2 = json::from_ubjson({packed.data(), packed.size()}));
@@ -2508,11 +2554,8 @@ TEST_CASE("UBJSON roundtrips" * doctest::skip())
std::ifstream f_json(filename);
json j1 = json::parse(f_json);
- // parse MessagePack file
- std::ifstream f_ubjson(filename + ".ubjson", std::ios::binary);
- std::vector<uint8_t> packed(
- (std::istreambuf_iterator<char>(f_ubjson)),
- std::istreambuf_iterator<char>());
+ // parse UBJSON file
+ auto packed = utils::read_binary_file(filename + ".ubjson");
{
INFO_WITH_TEMP(filename + ": output adapters: std::vector<uint8_t>");
diff --git a/test/src/unit-udt.cpp b/test/src/unit-udt.cpp
index 3097c1c6..2374b3e3 100644
--- a/test/src/unit-udt.cpp
+++ b/test/src/unit-udt.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -312,6 +312,7 @@ TEST_CASE("basic usage" * doctest::test_suite("udt"))
CHECK(name.m_val == "new name");
}
+#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("implicit conversions")
{
const udt::contact_book parsed_book = big_json;
@@ -335,6 +336,7 @@ TEST_CASE("basic usage" * doctest::test_suite("udt"))
CHECK(book_name == udt::name{"C++"});
CHECK(book == parsed_book);
}
+#endif
}
}
@@ -551,7 +553,7 @@ struct pod_serializer
template <
typename BasicJsonType, typename U = T,
typename std::enable_if <
- not(std::is_pod<U>::value and std::is_class<U>::value), int >::type = 0 >
+ !(std::is_pod<U>::value && std::is_class<U>::value), int >::type = 0 >
static void from_json(const BasicJsonType& j, U& t)
{
using nlohmann::from_json;
@@ -559,9 +561,9 @@ struct pod_serializer
}
// special behaviour for pods
- template <typename BasicJsonType, typename U = T,
- typename std::enable_if<
- std::is_pod<U>::value and std::is_class<U>::value, int>::type = 0>
+ template < typename BasicJsonType, typename U = T,
+ typename std::enable_if <
+ std::is_pod<U>::value && std::is_class<U>::value, int >::type = 0 >
static void from_json(const BasicJsonType& j, U& t)
{
std::uint64_t value;
@@ -587,16 +589,16 @@ struct pod_serializer
template <
typename BasicJsonType, typename U = T,
typename std::enable_if <
- not(std::is_pod<U>::value and std::is_class<U>::value), int >::type = 0 >
+ !(std::is_pod<U>::value && std::is_class<U>::value), int >::type = 0 >
static void to_json(BasicJsonType& j, const T& t)
{
using nlohmann::to_json;
to_json(j, t);
}
- template <typename BasicJsonType, typename U = T,
- typename std::enable_if<
- std::is_pod<U>::value and std::is_class<U>::value, int>::type = 0>
+ template < typename BasicJsonType, typename U = T,
+ typename std::enable_if <
+ std::is_pod<U>::value && std::is_class<U>::value, int >::type = 0 >
static void to_json(BasicJsonType& j, const T& t) noexcept
{
auto bytes = static_cast< const unsigned char*>(static_cast<const void*>(&t));
@@ -805,7 +807,7 @@ struct is_constructible_patched<T, decltype(void(json(std::declval<T>())))> : st
TEST_CASE("an incomplete type does not trigger a compiler error in non-evaluated context" * doctest::test_suite("udt"))
{
- static_assert(not is_constructible_patched<json, incomplete>::value, "");
+ static_assert(!is_constructible_patched<json, incomplete>::value, "");
}
namespace
@@ -839,5 +841,5 @@ TEST_CASE("Issue #924")
TEST_CASE("Issue #1237")
{
struct non_convertible_type {};
- static_assert(not std::is_convertible<json, non_convertible_type>::value, "");
+ static_assert(!std::is_convertible<json, non_convertible_type>::value, "");
}
diff --git a/test/src/unit-udt_macro.cpp b/test/src/unit-udt_macro.cpp
new file mode 100644
index 00000000..45eeca2e
--- /dev/null
+++ b/test/src/unit-udt_macro.cpp
@@ -0,0 +1,330 @@
+/*
+ __ _____ _____ _____
+ __| | __| | | | JSON for Modern C++ (test suite)
+| | |__ | | | | | | version 3.9.0
+|_____|_____|_____|_|___| https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include <string>
+#include <vector>
+#include "doctest_compatibility.h"
+
+#include <nlohmann/json.hpp>
+using nlohmann::json;
+
+namespace persons
+{
+class person_with_private_data
+{
+ private:
+ std::string name = "";
+ int age = 0;
+ json metadata = nullptr;
+
+ public:
+ bool operator==(const person_with_private_data& rhs) const
+ {
+ return name == rhs.name && age == rhs.age && metadata == rhs.metadata;
+ }
+
+ person_with_private_data() = default;
+ person_with_private_data(std::string name_, int age_, json metadata_)
+ : name(std::move(name_))
+ , age(age_)
+ , metadata(std::move(metadata_))
+ {}
+
+ NLOHMANN_DEFINE_TYPE_INTRUSIVE(person_with_private_data, age, name, metadata)
+};
+
+class person_without_private_data_1
+{
+ public:
+ std::string name = "";
+ int age = 0;
+ json metadata = nullptr;
+
+ bool operator==(const person_without_private_data_1& rhs) const
+ {
+ return name == rhs.name && age == rhs.age && metadata == rhs.metadata;
+ }
+
+ person_without_private_data_1() = default;
+ person_without_private_data_1(std::string name_, int age_, json metadata_)
+ : name(std::move(name_))
+ , age(age_)
+ , metadata(std::move(metadata_))
+ {}
+
+ NLOHMANN_DEFINE_TYPE_INTRUSIVE(person_without_private_data_1, age, name, metadata)
+};
+
+class person_without_private_data_2
+{
+ public:
+ std::string name = "";
+ int age = 0;
+ json metadata = nullptr;
+
+ bool operator==(const person_without_private_data_2& rhs) const
+ {
+ return name == rhs.name && age == rhs.age && metadata == rhs.metadata;
+ }
+
+ person_without_private_data_2() = default;
+ person_without_private_data_2(std::string name_, int age_, json metadata_)
+ : name(std::move(name_))
+ , age(age_)
+ , metadata(std::move(metadata_))
+ {}
+};
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person_without_private_data_2, age, name, metadata)
+
+class person_with_private_alphabet
+{
+ public:
+ bool operator==(const person_with_private_alphabet& other)
+ {
+ return a == other.a &&
+ b == other.b &&
+ c == other.c &&
+ d == other.d &&
+ e == other.e &&
+ f == other.f &&
+ g == other.g &&
+ h == other.h &&
+ i == other.i &&
+ j == other.j &&
+ k == other.k &&
+ l == other.l &&
+ m == other.m &&
+ n == other.n &&
+ o == other.o &&
+ p == other.p &&
+ q == other.q &&
+ r == other.r &&
+ s == other.s &&
+ t == other.t &&
+ u == other.u &&
+ v == other.v &&
+ w == other.w &&
+ x == other.x &&
+ y == other.y &&
+ z == other.z;
+ }
+
+ private:
+ int a = 0;
+ int b = 0;
+ int c = 0;
+ int d = 0;
+ int e = 0;
+ int f = 0;
+ int g = 0;
+ int h = 0;
+ int i = 0;
+ int j = 0;
+ int k = 0;
+ int l = 0;
+ int m = 0;
+ int n = 0;
+ int o = 0;
+ int p = 0;
+ int q = 0;
+ int r = 0;
+ int s = 0;
+ int t = 0;
+ int u = 0;
+ int v = 0;
+ int w = 0;
+ int x = 0;
+ int y = 0;
+ int z = 0;
+ NLOHMANN_DEFINE_TYPE_INTRUSIVE(person_with_private_alphabet, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
+};
+
+class person_with_public_alphabet
+{
+ public:
+ bool operator==(const person_with_public_alphabet& other)
+ {
+ return a == other.a &&
+ b == other.b &&
+ c == other.c &&
+ d == other.d &&
+ e == other.e &&
+ f == other.f &&
+ g == other.g &&
+ h == other.h &&
+ i == other.i &&
+ j == other.j &&
+ k == other.k &&
+ l == other.l &&
+ m == other.m &&
+ n == other.n &&
+ o == other.o &&
+ p == other.p &&
+ q == other.q &&
+ r == other.r &&
+ s == other.s &&
+ t == other.t &&
+ u == other.u &&
+ v == other.v &&
+ w == other.w &&
+ x == other.x &&
+ y == other.y &&
+ z == other.z;
+ }
+
+ int a = 0;
+ int b = 0;
+ int c = 0;
+ int d = 0;
+ int e = 0;
+ int f = 0;
+ int g = 0;
+ int h = 0;
+ int i = 0;
+ int j = 0;
+ int k = 0;
+ int l = 0;
+ int m = 0;
+ int n = 0;
+ int o = 0;
+ int p = 0;
+ int q = 0;
+ int r = 0;
+ int s = 0;
+ int t = 0;
+ int u = 0;
+ int v = 0;
+ int w = 0;
+ int x = 0;
+ int y = 0;
+ int z = 0;
+};
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person_with_public_alphabet, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
+
+} // namespace persons
+
+TEST_CASE_TEMPLATE("Serialization/deserialization via NLOHMANN_DEFINE_TYPE_INTRUSIVE", T,
+ persons::person_with_private_data,
+ persons::person_without_private_data_1,
+ persons::person_without_private_data_2)
+{
+ SECTION("person")
+ {
+ // serialization
+ T p1("Erik", 1, {{"haircuts", 2}});
+ CHECK(json(p1).dump() == "{\"age\":1,\"metadata\":{\"haircuts\":2},\"name\":\"Erik\"}");
+
+ // deserialization
+ auto p2 = json(p1).get<T>();
+ CHECK(p2 == p1);
+
+ // roundtrip
+ CHECK(T(json(p1)) == p1);
+ CHECK(json(T(json(p1))) == json(p1));
+
+ // check exception in case of missing field
+ json j = json(p1);
+ j.erase("age");
+ CHECK_THROWS_WITH_AS(j.get<T>(), "[json.exception.out_of_range.403] key 'age' not found", json::out_of_range);
+ }
+}
+
+TEST_CASE_TEMPLATE("Serialization/deserialization of classes with 26 public/private member variables via NLOHMANN_DEFINE_TYPE_INTRUSIVE and NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE", T,
+ persons::person_with_private_alphabet,
+ persons::person_with_public_alphabet)
+{
+ SECTION("alphabet")
+ {
+ {
+ T obj1;
+ nlohmann::json j = obj1; //via json object
+ T obj2;
+ j.get_to(obj2);
+ bool ok = (obj1 == obj2);
+ CHECK(ok);
+ }
+
+ {
+ T obj1;
+ nlohmann::json j1 = obj1; //via json string
+ std::string s = j1.dump();
+ nlohmann::json j2 = nlohmann::json::parse(s);
+ T obj2;
+ j2.get_to(obj2);
+ bool ok = (obj1 == obj2);
+ CHECK(ok);
+ }
+
+ {
+ T obj1;
+ nlohmann::json j1 = obj1; //via msgpack
+ std::vector<uint8_t> buf = nlohmann::json::to_msgpack(j1);
+ nlohmann::json j2 = nlohmann::json::from_msgpack(buf);
+ T obj2;
+ j2.get_to(obj2);
+ bool ok = (obj1 == obj2);
+ CHECK(ok);
+ }
+
+ {
+ T obj1;
+ nlohmann::json j1 = obj1; //via bson
+ std::vector<uint8_t> buf = nlohmann::json::to_bson(j1);
+ nlohmann::json j2 = nlohmann::json::from_bson(buf);
+ T obj2;
+ j2.get_to(obj2);
+ bool ok = (obj1 == obj2);
+ CHECK(ok);
+ }
+
+ {
+ T obj1;
+ nlohmann::json j1 = obj1; //via cbor
+ std::vector<uint8_t> buf = nlohmann::json::to_cbor(j1);
+ nlohmann::json j2 = nlohmann::json::from_cbor(buf);
+ T obj2;
+ j2.get_to(obj2);
+ bool ok = (obj1 == obj2);
+ CHECK(ok);
+ }
+
+ {
+ T obj1;
+ nlohmann::json j1 = obj1; //via ubjson
+ std::vector<uint8_t> buf = nlohmann::json::to_ubjson(j1);
+ nlohmann::json j2 = nlohmann::json::from_ubjson(buf);
+ T obj2;
+ j2.get_to(obj2);
+ bool ok = (obj1 == obj2);
+ CHECK(ok);
+ }
+ }
+}
diff --git a/test/src/unit-unicode.cpp b/test/src/unit-unicode.cpp
index 54f91535..0b60b359 100644
--- a/test/src/unit-unicode.cpp
+++ b/test/src/unit-unicode.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -217,7 +217,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte1 = 0x00; byte1 <= 0x7F; ++byte1)
{
// unescaped control characters are parse errors in JSON
- if (0x00 <= byte1 and byte1 <= 0x1F)
+ if (0x00 <= byte1 && byte1 <= 0x1F)
{
check_utf8string(false, byte1);
continue;
@@ -274,7 +274,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{
// skip correct second byte
- if (0x80 <= byte2 and byte2 <= 0xBF)
+ if (0x80 <= byte2 && byte2 <= 0xBF)
{
continue;
}
@@ -331,7 +331,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{
// skip correct second byte
- if (0xA0 <= byte2 and byte2 <= 0xBF)
+ if (0xA0 <= byte2 && byte2 <= 0xBF)
{
continue;
}
@@ -354,7 +354,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{
// skip correct third byte
- if (0x80 <= byte3 and byte3 <= 0xBF)
+ if (0x80 <= byte3 && byte3 <= 0xBF)
{
continue;
}
@@ -412,7 +412,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{
// skip correct second byte
- if (0x80 <= byte2 and byte2 <= 0xBF)
+ if (0x80 <= byte2 && byte2 <= 0xBF)
{
continue;
}
@@ -435,7 +435,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{
// skip correct third byte
- if (0x80 <= byte3 and byte3 <= 0xBF)
+ if (0x80 <= byte3 && byte3 <= 0xBF)
{
continue;
}
@@ -493,7 +493,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{
// skip correct second byte
- if (0x80 <= byte2 and byte2 <= 0x9F)
+ if (0x80 <= byte2 && byte2 <= 0x9F)
{
continue;
}
@@ -516,7 +516,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{
// skip correct third byte
- if (0x80 <= byte3 and byte3 <= 0xBF)
+ if (0x80 <= byte3 && byte3 <= 0xBF)
{
continue;
}
@@ -574,7 +574,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{
// skip correct second byte
- if (0x80 <= byte2 and byte2 <= 0xBF)
+ if (0x80 <= byte2 && byte2 <= 0xBF)
{
continue;
}
@@ -597,7 +597,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{
// skip correct third byte
- if (0x80 <= byte3 and byte3 <= 0xBF)
+ if (0x80 <= byte3 && byte3 <= 0xBF)
{
continue;
}
@@ -673,7 +673,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{
// skip correct second byte
- if (0x90 <= byte2 and byte2 <= 0xBF)
+ if (0x90 <= byte2 && byte2 <= 0xBF)
{
continue;
}
@@ -699,7 +699,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{
// skip correct third byte
- if (0x80 <= byte3 and byte3 <= 0xBF)
+ if (0x80 <= byte3 && byte3 <= 0xBF)
{
continue;
}
@@ -725,7 +725,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
{
// skip fourth second byte
- if (0x80 <= byte3 and byte3 <= 0xBF)
+ if (0x80 <= byte3 && byte3 <= 0xBF)
{
continue;
}
@@ -802,7 +802,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{
// skip correct second byte
- if (0x80 <= byte2 and byte2 <= 0xBF)
+ if (0x80 <= byte2 && byte2 <= 0xBF)
{
continue;
}
@@ -828,7 +828,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{
// skip correct third byte
- if (0x80 <= byte3 and byte3 <= 0xBF)
+ if (0x80 <= byte3 && byte3 <= 0xBF)
{
continue;
}
@@ -854,7 +854,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
{
// skip correct fourth byte
- if (0x80 <= byte3 and byte3 <= 0xBF)
+ if (0x80 <= byte3 && byte3 <= 0xBF)
{
continue;
}
@@ -931,7 +931,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{
// skip correct second byte
- if (0x80 <= byte2 and byte2 <= 0x8F)
+ if (0x80 <= byte2 && byte2 <= 0x8F)
{
continue;
}
@@ -957,7 +957,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{
// skip correct third byte
- if (0x80 <= byte3 and byte3 <= 0xBF)
+ if (0x80 <= byte3 && byte3 <= 0xBF)
{
continue;
}
@@ -983,7 +983,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
{
// skip correct fourth byte
- if (0x80 <= byte3 and byte3 <= 0xBF)
+ if (0x80 <= byte3 && byte3 <= 0xBF)
{
continue;
}
@@ -1030,7 +1030,7 @@ TEST_CASE("Unicode" * doctest::skip())
// they will never be assigned a character, so there should be no
// reason to encode them. The official Unicode standard says that
// no UTF forms, including UTF-16, can encode these code points.
- if (cp >= 0xD800u and cp <= 0xDFFFu)
+ if (cp >= 0xD800u && cp <= 0xDFFFu)
{
// if we would not skip these code points, we would get a
// "missing low surrogate" exception
@@ -1117,7 +1117,7 @@ TEST_CASE("Unicode" * doctest::skip())
{
for (std::size_t cp2 = 0x0000u; cp2 <= 0xFFFFu; ++cp2)
{
- if (0xDC00u <= cp2 and cp2 <= 0xDFFFu)
+ if (0xDC00u <= cp2 && cp2 <= 0xDFFFu)
{
continue;
}
@@ -1163,12 +1163,12 @@ TEST_CASE("Unicode" * doctest::skip())
for (auto s : j)
{
// skip non-string JSON values
- if (not s.is_string())
+ if (!s.is_string())
{
continue;
}
- std::string ptr = s;
+ auto ptr = s.get<std::string>();
// tilde must be followed by 0 or 1
if (ptr == "~")
diff --git a/test/src/unit-user_defined_input.cpp b/test/src/unit-user_defined_input.cpp
index 45c3d055..967f9c06 100644
--- a/test/src/unit-user_defined_input.cpp
+++ b/test/src/unit-user_defined_input.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit-wstring.cpp b/test/src/unit-wstring.cpp
index 884a3209..2ebe99fb 100644
--- a/test/src/unit-wstring.cpp
+++ b/test/src/unit-wstring.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/test/src/unit.cpp b/test/src/unit.cpp
index 6cd45a5f..b0b20d79 100644
--- a/test/src/unit.cpp
+++ b/test/src/unit.cpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
-| | |__ | | | | | | version 3.8.0
+| | |__ | | | | | | version 3.9.0
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
diff --git a/third_party/macro_builder/main.cpp b/third_party/macro_builder/main.cpp
new file mode 100644
index 00000000..e676daac
--- /dev/null
+++ b/third_party/macro_builder/main.cpp
@@ -0,0 +1,43 @@
+#include <cstdlib>
+#include <iostream>
+#include <sstream>
+
+using namespace std;
+
+void build_code(int max_args)
+{
+ stringstream ss;
+ ss << "#define NLOHMANN_JSON_EXPAND( x ) x" << endl;
+ ss << "#define NLOHMANN_JSON_GET_MACRO(";
+ for (int i = 0 ; i < max_args ; i++)
+ ss << "_" << i + 1 << ", ";
+ ss << "NAME,...) NAME" << endl;
+
+ ss << "#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \\" << endl;
+ for (int i = max_args ; i > 1 ; i--)
+ ss << "NLOHMANN_JSON_PASTE" << i << ", \\" << endl;
+ ss << "NLOHMANN_JSON_PASTE1)(__VA_ARGS__))" << endl;
+
+ ss << "#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)" << endl;
+ for (int i = 3 ; i <= max_args ; i++)
+ {
+ ss << "#define NLOHMANN_JSON_PASTE" << i << "(func, ";
+ for (int j = 1 ; j < i -1 ; j++)
+ ss << "v" << j << ", ";
+ ss << "v" << i-1 << ") NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE" << i-1 << "(func, ";
+ for (int j = 2 ; j < i-1 ; j++)
+ ss << "v" << j << ", ";
+ ss << "v" << i-1 << ")" << endl;
+ }
+
+ cout << ss.str() << endl;
+}
+
+int main(int argc, char** argv)
+{
+ int max_args = 64;
+ build_code(max_args);
+
+ return 0;
+}
+
diff --git a/wsjcpp.yml b/wsjcpp.yml
index 32027a43..629ae388 100644
--- a/wsjcpp.yml
+++ b/wsjcpp.yml
@@ -2,7 +2,7 @@ wsjcpp_version: "v0.1.1"
cmake_minimum_required: "3.0"
cmake_cxx_standard: "11"
name: "nlohmann/json"
-version: "v3.7.3"
+version: "v3.9.0"
description: "JSON for Modern C++"
issues: "https://github.com/nlohmann/json/issues"
keywords: