luo980/json
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'develop' of https://github.com/nlohmann/json into issue2228

Browse Source
This commit is contained in:
Niels Lohmann 2020-07-12 17:39:13 +02:00
commit aba37d001e
No known key found for this signature in database
GPG Key ID: 7F3CEA63AE251B69
56 changed files with 1912 additions and 1664 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
.github/workflows/windows_clang.yml vendored Normal file
View File

@ -0,0 +1,32 @@
name: Windows
on: [push, pull_request]
jobs:
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

2
CMakeLists.txt
View File

@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 3.1)
## PROJECT ## PROJECT
## name and version ## name and version
## ##
project(nlohmann_json VERSION 3.8.0 DESCRIPTION "JSON for Modern C++" LANGUAGES CXX) project(nlohmann_json VERSION 3.8.0 LANGUAGES CXX)
## ##
## INCLUDE ## INCLUDE

7
README.md
View File

@ -1190,6 +1190,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) - GCC 4.8 - 10.1 (and possibly later)
- Clang 3.4 - 10.0 (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) - 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++ 2015 / Build Tools 14.0.25123.0 (and possibly later)
- Microsoft Visual C++ 2017 / Build Tools 15.5.180.51428 (and possibly later) - Microsoft Visual C++ 2017 / Build Tools 15.5.180.51428 (and possibly later)
@ -1235,6 +1236,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 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.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 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.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 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 | | GCC 5.5.0 (Ubuntu 5.5.0-12ubuntu1~14.04) | Ubuntu 14.04.5 LTS | Travis |
@ -1574,7 +1577,9 @@ However, you can pass set parameter `ignore_comments` to true in the `parse` fun
### Order of object keys ### 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 ### Memory Release

2
cmake/pkg-config.pc.in
View File

@ -1,4 +1,4 @@
Name: ${PROJECT_NAME} Name: ${PROJECT_NAME}
Description: ${PROJECT_DESCRIPTION} Description: JSON for Modern C++
Version: ${PROJECT_VERSION} Version: ${PROJECT_VERSION}
Cflags: -I${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR} Cflags: -I${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}

2
include/nlohmann/adl_serializer.hpp
View File

@ -37,7 +37,7 @@ struct adl_serializer
@param[in,out] j JSON value to write to @param[in,out] j JSON value to write to
@param[in] val value to read from @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( static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(
noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val)))) noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
-> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)), void()) -> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)), void())

8
include/nlohmann/detail/boolean_operators.hpp
View File

@ -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

85
include/nlohmann/detail/conversions/from_json.hpp
View File

@ -12,7 +12,6 @@
#include <utility> // pair, declval #include <utility> // pair, declval
#include <valarray> // valarray #include <valarray> // valarray
#include <nlohmann/detail/boolean_operators.hpp>
#include <nlohmann/detail/exceptions.hpp> #include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/macro_scope.hpp> #include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/meta/cpp_future.hpp> #include <nlohmann/detail/meta/cpp_future.hpp>
@ -26,7 +25,7 @@ namespace detail
template<typename BasicJsonType> template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename std::nullptr_t& n) 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()))); 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 // overloads for basic_json template parameters
template<typename BasicJsonType, typename ArithmeticType, template < typename BasicJsonType, typename ArithmeticType,
enable_if_t<std::is_arithmetic<ArithmeticType>::value and enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value, !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
int> = 0> int > = 0 >
void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val) void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
{ {
switch (static_cast<value_t>(j)) switch (static_cast<value_t>(j))
@ -66,7 +65,7 @@ void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
template<typename BasicJsonType> template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b) 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()))); 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> template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s) 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()))); 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 < template <
typename BasicJsonType, typename ConstructibleStringType, typename BasicJsonType, typename ConstructibleStringType,
enable_if_t < enable_if_t <
is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value and is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
not std::is_same<typename BasicJsonType::string_t, !std::is_same<typename BasicJsonType::string_t,
ConstructibleStringType>::value, ConstructibleStringType>::value,
int > = 0 > int > = 0 >
void from_json(const BasicJsonType& j, ConstructibleStringType& s) 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()))); JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
} }
@ -132,7 +131,7 @@ template<typename BasicJsonType, typename T, typename Allocator,
enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0> enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l) 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()))); JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
} }
@ -149,7 +148,7 @@ template<typename BasicJsonType, typename T,
enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0> enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
void from_json(const BasicJsonType& j, std::valarray<T>& l) 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()))); JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
} }
@ -157,7 +156,7 @@ void from_json(const BasicJsonType& j, std::valarray<T>& l)
std::copy(j.begin(), j.end(), std::begin(l)); std::copy(j.begin(), j.end(), std::begin(l));
} }
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]) auto from_json(const BasicJsonType& j, T (&arr)[N])
-> decltype(j.template get<T>(), void()) -> decltype(j.template get<T>(), void())
{ {
@ -173,7 +172,7 @@ void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_
arr = *j.template get_ptr<const typename BasicJsonType::array_t*>(); 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, auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
priority_tag<2> /*unused*/) priority_tag<2> /*unused*/)
-> decltype(j.template get<T>(), void()) -> decltype(j.template get<T>(), void())
@ -205,7 +204,7 @@ auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, p
arr = std::move(ret); arr = std::move(ret);
} }
template <typename BasicJsonType, typename ConstructibleArrayType> template<typename BasicJsonType, typename ConstructibleArrayType>
void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
priority_tag<0> /*unused*/) priority_tag<0> /*unused*/)
{ {
@ -223,20 +222,20 @@ void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
arr = std::move(ret); arr = std::move(ret);
} }
template <typename BasicJsonType, typename ConstructibleArrayType, template < typename BasicJsonType, typename ConstructibleArrayType,
enable_if_t < enable_if_t <
is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value and is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
not is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value and !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
not is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value and !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
not std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value and !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
not is_basic_json<ConstructibleArrayType>::value, !is_basic_json<ConstructibleArrayType>::value,
int > = 0 > int > = 0 >
auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr) auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}), -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
j.template get<typename ConstructibleArrayType::value_type>(), j.template get<typename ConstructibleArrayType::value_type>(),
void()) 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 " + JSON_THROW(type_error::create(302, "type must be array, but is " +
std::string(j.type_name()))); std::string(j.type_name())));
@ -245,10 +244,10 @@ void())
from_json_array_impl(j, arr, priority_tag<3> {}); 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) 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()))); JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name())));
} }
@ -260,7 +259,7 @@ template<typename BasicJsonType, typename ConstructibleObjectType,
enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0> enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
void from_json(const BasicJsonType& j, ConstructibleObjectType& obj) 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()))); JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
} }
@ -282,14 +281,14 @@ void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
// (BooleanType, etc..); note: Is it really necessary to provide explicit // (BooleanType, etc..); note: Is it really necessary to provide explicit
// overloads for boolean_t etc. in case of a custom BooleanType which is not // overloads for boolean_t etc. in case of a custom BooleanType which is not
// an arithmetic type? // an arithmetic type?
template<typename BasicJsonType, typename ArithmeticType, template < typename BasicJsonType, typename ArithmeticType,
enable_if_t < enable_if_t <
std::is_arithmetic<ArithmeticType>::value and std::is_arithmetic<ArithmeticType>::value&&
not std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value and !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
not std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value and !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
not std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value and !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value, !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
int> = 0> int > = 0 >
void from_json(const BasicJsonType& j, ArithmeticType& val) void from_json(const BasicJsonType& j, ArithmeticType& val)
{ {
switch (static_cast<value_t>(j)) switch (static_cast<value_t>(j))
@ -338,19 +337,19 @@ void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
from_json_tuple_impl(j, t, index_sequence_for<Args...> {}); from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
} }
template <typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator, template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
typename = enable_if_t<not std::is_constructible< typename = enable_if_t < !std::is_constructible <
typename BasicJsonType::string_t, Key>::value>> typename BasicJsonType::string_t, Key >::value >>
void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m) 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()))); JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
} }
m.clear(); m.clear();
for (const auto& p : j) 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()))); JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
} }
@ -358,19 +357,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, template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
typename = enable_if_t<not std::is_constructible< typename = enable_if_t < !std::is_constructible <
typename BasicJsonType::string_t, Key>::value>> typename BasicJsonType::string_t, Key >::value >>
void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m) 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()))); JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
} }
m.clear(); m.clear();
for (const auto& p : j) 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()))); JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
} }

21
include/nlohmann/detail/conversions/to_chars.hpp
View File

@ -7,7 +7,6 @@
#include <limits> // numeric_limits #include <limits> // numeric_limits
#include <type_traits> // conditional #include <type_traits> // conditional
#include <nlohmann/detail/boolean_operators.hpp>
#include <nlohmann/detail/macro_scope.hpp> #include <nlohmann/detail/macro_scope.hpp>
namespace nlohmann namespace nlohmann
@ -37,7 +36,7 @@ For a detailed description of the algorithm see:
namespace dtoa_impl namespace dtoa_impl
{ {
template <typename Target, typename Source> template<typename Target, typename Source>
Target reinterpret_bits(const Source source) Target reinterpret_bits(const Source source)
{ {
static_assert(sizeof(Target) == sizeof(Source), "size mismatch"); static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
@ -178,7 +177,7 @@ boundaries.
@pre value must be finite and positive @pre value must be finite and positive
*/ */
template <typename FloatType> template<typename FloatType>
boundaries compute_boundaries(FloatType value) boundaries compute_boundaries(FloatType value)
{ {
JSON_ASSERT(std::isfinite(value)); JSON_ASSERT(std::isfinite(value));
@ -231,7 +230,7 @@ boundaries compute_boundaries(FloatType value)
// -----------------+------+------+-------------+-------------+--- (B) // -----------------+------+------+-------------+-------------+--- (B)
// v- m- v m+ v+ // 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_plus = diyfp(2 * v.f + 1, v.e - 1);
const diyfp m_minus = lower_boundary_is_closer const diyfp m_minus = lower_boundary_is_closer
? diyfp(4 * v.f - 1, v.e - 2) // (B) ? diyfp(4 * v.f - 1, v.e - 2) // (B)
@ -566,8 +565,8 @@ inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t d
// integer arithmetic. // integer arithmetic.
while (rest < dist while (rest < dist
and delta - rest >= ten_k && delta - rest >= ten_k
and (rest + ten_k < dist or dist - rest > rest + ten_k - dist)) && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
{ {
JSON_ASSERT(buf[len - 1] != '0'); JSON_ASSERT(buf[len - 1] != '0');
buf[len - 1]--; buf[len - 1]--;
@ -878,7 +877,7 @@ v = buf * 10^decimal_exponent
len is the length of the buffer (number of decimal digits) len is the length of the buffer (number of decimal digits)
The buffer must be large enough, i.e. >= max_digits10. The buffer must be large enough, i.e. >= max_digits10.
*/ */
template <typename FloatType> template<typename FloatType>
JSON_HEDLEY_NON_NULL(1) JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value) void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{ {
@ -985,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) // 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. // 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] // digits[000]
// len <= max_exp + 2 // len <= max_exp + 2
@ -997,7 +996,7 @@ inline char* format_buffer(char* buf, int len, int decimal_exponent,
return buf + (static_cast<size_t>(n) + 2); return buf + (static_cast<size_t>(n) + 2);
} }
if (0 < n and n <= max_exp) if (0 < n && n <= max_exp)
{ {
// dig.its // dig.its
// len <= max_digits10 + 1 // len <= max_digits10 + 1
@ -1009,7 +1008,7 @@ inline char* format_buffer(char* buf, int len, int decimal_exponent,
return buf + (static_cast<size_t>(k) + 1U); return buf + (static_cast<size_t>(k) + 1U);
} }
if (min_exp < n and n <= 0) if (min_exp < n && n <= 0)
{ {
// 0.[000]digits // 0.[000]digits
// len <= 2 + (-min_exp - 1) + max_digits10 // len <= 2 + (-min_exp - 1) + max_digits10
@ -1054,7 +1053,7 @@ format. Returns an iterator pointing past-the-end of the decimal representation.
@note The buffer must be large enough. @note The buffer must be large enough.
@note The result is NOT null-terminated. @note The result is NOT null-terminated.
*/ */
template <typename FloatType> template<typename FloatType>
JSON_HEDLEY_NON_NULL(1, 2) JSON_HEDLEY_NON_NULL(1, 2)
JSON_HEDLEY_RETURNS_NON_NULL JSON_HEDLEY_RETURNS_NON_NULL
char* to_chars(char* first, const char* last, FloatType value) char* to_chars(char* first, const char* last, FloatType value)

45
include/nlohmann/detail/conversions/to_json.hpp
View File

@ -9,7 +9,6 @@
#include <valarray> // valarray #include <valarray> // valarray
#include <vector> // vector #include <vector> // vector
#include <nlohmann/detail/boolean_operators.hpp>
#include <nlohmann/detail/iterators/iteration_proxy.hpp> #include <nlohmann/detail/iterators/iteration_proxy.hpp>
#include <nlohmann/detail/meta/cpp_future.hpp> #include <nlohmann/detail/meta/cpp_future.hpp>
#include <nlohmann/detail/meta/type_traits.hpp> #include <nlohmann/detail/meta/type_traits.hpp>
@ -56,9 +55,9 @@ struct external_constructor<value_t::string>
j.assert_invariant(); j.assert_invariant();
} }
template<typename BasicJsonType, typename CompatibleStringType, template < typename BasicJsonType, typename CompatibleStringType,
enable_if_t<not std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value, enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
int> = 0> int > = 0 >
static void construct(BasicJsonType& j, const CompatibleStringType& str) static void construct(BasicJsonType& j, const CompatibleStringType& str)
{ {
j.m_type = value_t::string; j.m_type = value_t::string;
@ -144,9 +143,9 @@ struct external_constructor<value_t::array>
j.assert_invariant(); j.assert_invariant();
} }
template<typename BasicJsonType, typename CompatibleArrayType, template < typename BasicJsonType, typename CompatibleArrayType,
enable_if_t<not std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value, enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
int> = 0> int > = 0 >
static void construct(BasicJsonType& j, const CompatibleArrayType& arr) static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
{ {
using std::begin; using std::begin;
@ -203,8 +202,8 @@ struct external_constructor<value_t::object>
j.assert_invariant(); j.assert_invariant();
} }
template<typename BasicJsonType, typename CompatibleObjectType, template < typename BasicJsonType, typename CompatibleObjectType,
enable_if_t<not std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int> = 0> enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
static void construct(BasicJsonType& j, const CompatibleObjectType& obj) static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
{ {
using std::begin; 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); external_constructor<value_t::array>::construct(j, e);
} }
template <typename BasicJsonType, typename CompatibleArrayType, template < typename BasicJsonType, typename CompatibleArrayType,
enable_if_t<is_compatible_array_type<BasicJsonType, enable_if_t < is_compatible_array_type<BasicJsonType,
CompatibleArrayType>::value and CompatibleArrayType>::value&&
not is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value and !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
not is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value and !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
not std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value and !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
not is_basic_json<CompatibleArrayType>::value, !is_basic_json<CompatibleArrayType>::value,
int> = 0> int > = 0 >
void to_json(BasicJsonType& j, const CompatibleArrayType& arr) void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
{ {
external_constructor<value_t::array>::construct(j, 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) void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
{ {
external_constructor<value_t::binary>::construct(j, 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)); external_constructor<value_t::array>::construct(j, std::move(arr));
} }
template<typename BasicJsonType, typename CompatibleObjectType, template < typename BasicJsonType, typename CompatibleObjectType,
enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value and not is_basic_json<CompatibleObjectType>::value, int> = 0> 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) void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
{ {
external_constructor<value_t::object>::construct(j, obj); external_constructor<value_t::object>::construct(j, obj);
@ -322,9 +321,9 @@ void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
template < template <
typename BasicJsonType, typename T, std::size_t N, typename BasicJsonType, typename T, std::size_t N,
enable_if_t<not std::is_constructible<typename BasicJsonType::string_t, enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
const T(&)[N]>::value, const T(&)[N]>::value,
int> = 0 > int > = 0 >
void to_json(BasicJsonType& j, const T(&arr)[N]) void to_json(BasicJsonType& j, const T(&arr)[N])
{ {
external_constructor<value_t::array>::construct(j, arr); external_constructor<value_t::array>::construct(j, arr);
@ -337,7 +336,7 @@ void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
} }
// for https://github.com/nlohmann/json/pull/1134 // for https://github.com/nlohmann/json/pull/1134
template < typename BasicJsonType, typename T, template<typename BasicJsonType, typename T,
enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0> enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
void to_json(BasicJsonType& j, const T& b) void to_json(BasicJsonType& j, const T& b)
{ {

292
include/nlohmann/detail/input/binary_reader.hpp
View File

File diff suppressed because it is too large Load Diff

20
include/nlohmann/detail/input/input_adapters.hpp
View File

@ -250,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[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
utf8_bytes_filled = 2; 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[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)); utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
@ -259,7 +259,7 @@ struct wide_string_input_helper<BaseInputAdapter, 2>
} }
else 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 wc2 = static_cast<unsigned int>(input.get_character());
const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu)); const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
@ -402,9 +402,9 @@ using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const
// Null-delimited strings, and the like. // Null-delimited strings, and the like.
template < typename CharT, template < typename CharT,
typename std::enable_if < typename std::enable_if <
std::is_pointer<CharT>::value and std::is_pointer<CharT>::value&&
not std::is_array<CharT>::value and !std::is_array<CharT>::value&&
std::is_integral<typename std::remove_pointer<CharT>::type>::value and std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
sizeof(typename std::remove_pointer<CharT>::type) == 1, sizeof(typename std::remove_pointer<CharT>::type) == 1,
int >::type = 0 > int >::type = 0 >
contiguous_bytes_input_adapter input_adapter(CharT b) contiguous_bytes_input_adapter input_adapter(CharT b)
@ -426,12 +426,12 @@ auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N))
class span_input_adapter class span_input_adapter
{ {
public: public:
template<typename CharT, template < typename CharT,
typename std::enable_if< typename std::enable_if <
std::is_pointer<CharT>::value and std::is_pointer<CharT>::value&&
std::is_integral<typename std::remove_pointer<CharT>::type>::value and std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
sizeof(typename std::remove_pointer<CharT>::type) == 1, sizeof(typename std::remove_pointer<CharT>::type) == 1,
int>::type = 0> int >::type = 0 >
span_input_adapter(CharT b, std::size_t l) span_input_adapter(CharT b, std::size_t l)
: ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {} : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}

44
include/nlohmann/detail/input/json_sax.hpp
View File

@ -217,7 +217,7 @@ class json_sax_dom_parser
{ {
ref_stack.push_back(handle_value(BasicJsonType::value_t::object)); 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, JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len))); "excessive object size: " + std::to_string(len)));
@ -243,7 +243,7 @@ class json_sax_dom_parser
{ {
ref_stack.push_back(handle_value(BasicJsonType::value_t::array)); 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, JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len))); "excessive array size: " + std::to_string(len)));
@ -308,7 +308,7 @@ class json_sax_dom_parser
return &root; return &root;
} }
JSON_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()) if (ref_stack.back()->is_array())
{ {
@ -413,7 +413,7 @@ class json_sax_dom_callback_parser
ref_stack.push_back(val.second); ref_stack.push_back(val.second);
// check object limit // 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))); JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len)));
} }
@ -430,7 +430,7 @@ class json_sax_dom_callback_parser
key_keep_stack.push_back(keep); key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later // 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); object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
} }
@ -440,18 +440,18 @@ class json_sax_dom_callback_parser
bool end_object() 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 // discard object
*ref_stack.back() = discarded; *ref_stack.back() = discarded;
} }
JSON_ASSERT(not ref_stack.empty()); JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(not keep_stack.empty()); JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back(); ref_stack.pop_back();
keep_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 // remove discarded value
for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it) for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
@ -476,7 +476,7 @@ class json_sax_dom_callback_parser
ref_stack.push_back(val.second); ref_stack.push_back(val.second);
// check array limit // 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))); JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len)));
} }
@ -491,20 +491,20 @@ class json_sax_dom_callback_parser
if (ref_stack.back()) if (ref_stack.back())
{ {
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *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 // discard array
*ref_stack.back() = discarded; *ref_stack.back() = discarded;
} }
} }
JSON_ASSERT(not ref_stack.empty()); JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(not keep_stack.empty()); JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back(); ref_stack.pop_back();
keep_stack.pop_back(); keep_stack.pop_back();
// remove discarded value // 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(); ref_stack.back()->m_value.array->pop_back();
} }
@ -564,11 +564,11 @@ class json_sax_dom_callback_parser
template<typename Value> template<typename Value>
std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false) std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{ {
JSON_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 // do not handle this value if we know it would be added to a discarded
// container // container
if (not keep_stack.back()) if (!keep_stack.back())
{ {
return {false, nullptr}; return {false, nullptr};
} }
@ -577,10 +577,10 @@ class json_sax_dom_callback_parser
auto value = BasicJsonType(std::forward<Value>(v)); auto value = BasicJsonType(std::forward<Value>(v));
// check callback // 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 // do not handle this value if we just learnt it shall be discarded
if (not keep) if (!keep)
{ {
return {false, nullptr}; return {false, nullptr};
} }
@ -593,13 +593,13 @@ class json_sax_dom_callback_parser
// skip this value if we already decided to skip the parent // skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360) // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (not ref_stack.back()) if (!ref_stack.back())
{ {
return {false, nullptr}; return {false, nullptr};
} }
// we now only expect arrays and objects // we now only expect arrays and objects
JSON_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 // array
if (ref_stack.back()->is_array()) if (ref_stack.back()->is_array())
@ -611,11 +611,11 @@ class json_sax_dom_callback_parser
// object // object
JSON_ASSERT(ref_stack.back()->is_object()); JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key // check if we should store an element for the current key
JSON_ASSERT(not key_keep_stack.empty()); JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back(); const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back(); key_keep_stack.pop_back();
if (not store_element) if (!store_element)
{ {
return {false, nullptr}; return {false, nullptr};
} }

49
include/nlohmann/detail/input/lexer.hpp
View File

@ -169,15 +169,15 @@ class lexer : public lexer_base<BasicJsonType>
{ {
get(); get();
if (current >= '0' and current <= '9') if (current >= '0' && current <= '9')
{ {
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor); 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); 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); codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
} }
@ -187,7 +187,7 @@ class lexer : public lexer_base<BasicJsonType>
} }
} }
JSON_ASSERT(0x0000 <= codepoint and codepoint <= 0xFFFF); JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
return codepoint; return codepoint;
} }
@ -208,13 +208,13 @@ class lexer : public lexer_base<BasicJsonType>
*/ */
bool next_byte_in_range(std::initializer_list<char_int_type> ranges) bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{ {
JSON_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); add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range) for (auto range = ranges.begin(); range != ranges.end(); ++range)
{ {
get(); get();
if (JSON_HEDLEY_LIKELY(*range <= current and current <= *(++range))) if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
{ {
add(current); add(current);
} }
@ -320,10 +320,10 @@ class lexer : public lexer_base<BasicJsonType>
} }
// check if code point is a high surrogate // check if code point is a high surrogate
if (0xD800 <= codepoint1 and codepoint1 <= 0xDBFF) if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
{ {
// expect next \uxxxx entry // expect next \uxxxx entry
if (JSON_HEDLEY_LIKELY(get() == '\\' and get() == 'u')) if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
{ {
const int codepoint2 = get_codepoint(); const int codepoint2 = get_codepoint();
@ -334,7 +334,7 @@ class lexer : public lexer_base<BasicJsonType>
} }
// check if codepoint2 is a low surrogate // 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 // overwrite codepoint
codepoint = static_cast<int>( codepoint = static_cast<int>(
@ -361,7 +361,7 @@ class lexer : public lexer_base<BasicJsonType>
} }
else 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"; error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
return token_type::parse_error; return token_type::parse_error;
@ -369,7 +369,7 @@ class lexer : public lexer_base<BasicJsonType>
} }
// result of the above calculation yields a proper codepoint // result of the above calculation yields a proper codepoint
JSON_ASSERT(0x00 <= codepoint and codepoint <= 0x10FFFF); JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
// translate codepoint into bytes // translate codepoint into bytes
if (codepoint < 0x80) if (codepoint < 0x80)
@ -736,7 +736,7 @@ class lexer : public lexer_base<BasicJsonType>
case 0xDE: case 0xDE:
case 0xDF: 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; return token_type::parse_error;
} }
@ -746,7 +746,7 @@ class lexer : public lexer_base<BasicJsonType>
// U+0800..U+0FFF: bytes E0 A0..BF 80..BF // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
case 0xE0: 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; return token_type::parse_error;
} }
@ -770,7 +770,7 @@ class lexer : public lexer_base<BasicJsonType>
case 0xEE: case 0xEE:
case 0xEF: 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; return token_type::parse_error;
} }
@ -780,7 +780,7 @@ class lexer : public lexer_base<BasicJsonType>
// U+D000..U+D7FF: bytes ED 80..9F 80..BF // U+D000..U+D7FF: bytes ED 80..9F 80..BF
case 0xED: 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; return token_type::parse_error;
} }
@ -790,7 +790,7 @@ class lexer : public lexer_base<BasicJsonType>
// U+10000..U+3FFFF F0 90..BF 80..BF 80..BF // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
case 0xF0: 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; return token_type::parse_error;
} }
@ -802,7 +802,7 @@ class lexer : public lexer_base<BasicJsonType>
case 0xF2: case 0xF2:
case 0xF3: 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; return token_type::parse_error;
} }
@ -812,7 +812,7 @@ class lexer : public lexer_base<BasicJsonType>
// U+100000..U+10FFFF F4 80..8F 80..BF 80..BF // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
case 0xF4: 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; return token_type::parse_error;
} }
@ -1450,7 +1450,7 @@ scan_number_done:
if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof())) if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
{ {
JSON_ASSERT(not token_string.empty()); JSON_ASSERT(!token_string.empty());
token_string.pop_back(); token_string.pop_back();
} }
} }
@ -1546,7 +1546,7 @@ scan_number_done:
if (get() == 0xEF) if (get() == 0xEF)
{ {
// check if we completely parse the BOM // 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 // the first character is not the beginning of the BOM; unget it to
@ -1561,13 +1561,13 @@ scan_number_done:
{ {
get(); get();
} }
while (current == ' ' or current == '\t' or current == '\n' or current == '\r'); while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
} }
token_type scan() token_type scan()
{ {
// initially, skip the BOM // 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"; error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
return token_type::parse_error; return token_type::parse_error;
@ -1577,9 +1577,9 @@ scan_number_done:
skip_whitespace(); skip_whitespace();
// ignore comments // ignore comments
if (ignore_comments and current == '/') if (ignore_comments && current == '/')
{ {
if (not scan_comment()) if (!scan_comment())
{ {
return token_type::parse_error; return token_type::parse_error;
} }
@ -1587,6 +1587,7 @@ scan_number_done:
// skip following whitespace // skip following whitespace
skip_whitespace(); skip_whitespace();
} }
while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
switch (current) switch (current)
{ {

50
include/nlohmann/detail/input/parser.hpp
View File

@ -91,7 +91,7 @@ class parser
result.assert_invariant(); result.assert_invariant();
// in strict mode, input must be completely read // 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(), sdp.parse_error(m_lexer.get_position(),
m_lexer.get_token_string(), m_lexer.get_token_string(),
@ -120,7 +120,7 @@ class parser
result.assert_invariant(); result.assert_invariant();
// in strict mode, input must be completely read // 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(), sdp.parse_error(m_lexer.get_position(),
m_lexer.get_token_string(), m_lexer.get_token_string(),
@ -149,7 +149,7 @@ class parser
return sax_parse(&sax_acceptor, strict); return sax_parse(&sax_acceptor, strict);
} }
template <typename SAX> template<typename SAX>
JSON_HEDLEY_NON_NULL(2) JSON_HEDLEY_NON_NULL(2)
bool sax_parse(SAX* sax, const bool strict = true) bool sax_parse(SAX* sax, const bool strict = true)
{ {
@ -157,7 +157,7 @@ class parser
const bool result = sax_parse_internal(sax); const bool result = sax_parse_internal(sax);
// strict mode: next byte must be EOF // 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(), return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(), m_lexer.get_token_string(),
@ -169,7 +169,7 @@ class parser
} }
private: private:
template <typename SAX> template<typename SAX>
JSON_HEDLEY_NON_NULL(2) JSON_HEDLEY_NON_NULL(2)
bool sax_parse_internal(SAX* sax) bool sax_parse_internal(SAX* sax)
{ {
@ -181,14 +181,14 @@ class parser
while (true) while (true)
{ {
if (not skip_to_state_evaluation) if (!skip_to_state_evaluation)
{ {
// invariant: get_token() was called before each iteration // invariant: get_token() was called before each iteration
switch (last_token) switch (last_token)
{ {
case token_type::begin_object: 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; return false;
} }
@ -196,7 +196,7 @@ class parser
// closing } -> we are done // closing } -> we are done
if (get_token() == token_type::end_object) if (get_token() == token_type::end_object)
{ {
if (JSON_HEDLEY_UNLIKELY(not sax->end_object())) if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
{ {
return false; return false;
} }
@ -211,7 +211,7 @@ class parser
parse_error::create(101, m_lexer.get_position(), parse_error::create(101, m_lexer.get_position(),
exception_message(token_type::value_string, "object key"))); 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; return false;
} }
@ -235,7 +235,7 @@ class parser
case token_type::begin_array: 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; return false;
} }
@ -243,7 +243,7 @@ class parser
// closing ] -> we are done // closing ] -> we are done
if (get_token() == token_type::end_array) if (get_token() == token_type::end_array)
{ {
if (JSON_HEDLEY_UNLIKELY(not sax->end_array())) if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
{ {
return false; return false;
} }
@ -261,14 +261,14 @@ class parser
{ {
const auto res = m_lexer.get_number_float(); 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(), return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(), m_lexer.get_token_string(),
out_of_range::create(406, "number overflow parsing '" + 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; return false;
} }
@ -278,7 +278,7 @@ class parser
case token_type::literal_false: case token_type::literal_false:
{ {
if (JSON_HEDLEY_UNLIKELY(not sax->boolean(false))) if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
{ {
return false; return false;
} }
@ -287,7 +287,7 @@ class parser
case token_type::literal_null: case token_type::literal_null:
{ {
if (JSON_HEDLEY_UNLIKELY(not sax->null())) if (JSON_HEDLEY_UNLIKELY(!sax->null()))
{ {
return false; return false;
} }
@ -296,7 +296,7 @@ class parser
case token_type::literal_true: case token_type::literal_true:
{ {
if (JSON_HEDLEY_UNLIKELY(not sax->boolean(true))) if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
{ {
return false; return false;
} }
@ -305,7 +305,7 @@ class parser
case token_type::value_integer: 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; return false;
} }
@ -314,7 +314,7 @@ class parser
case token_type::value_string: 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; return false;
} }
@ -323,7 +323,7 @@ class parser
case token_type::value_unsigned: 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; return false;
} }
@ -373,7 +373,7 @@ class parser
// closing ] // closing ]
if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array)) 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; return false;
} }
@ -382,7 +382,7 @@ class parser
// new value, we need to evaluate the new state first. // new value, we need to evaluate the new state first.
// By setting skip_to_state_evaluation to false, we // By setting skip_to_state_evaluation to false, we
// are effectively jumping to the beginning of this if. // are effectively jumping to the beginning of this if.
JSON_ASSERT(not states.empty()); JSON_ASSERT(!states.empty());
states.pop_back(); states.pop_back();
skip_to_state_evaluation = true; skip_to_state_evaluation = true;
continue; continue;
@ -407,7 +407,7 @@ class parser
exception_message(token_type::value_string, "object key"))); 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; return false;
} }
@ -429,7 +429,7 @@ class parser
// closing } // closing }
if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object)) 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; return false;
} }
@ -438,7 +438,7 @@ class parser
// new value, we need to evaluate the new state first. // new value, we need to evaluate the new state first.
// By setting skip_to_state_evaluation to false, we // By setting skip_to_state_evaluation to false, we
// are effectively jumping to the beginning of this if. // are effectively jumping to the beginning of this if.
JSON_ASSERT(not states.empty()); JSON_ASSERT(!states.empty());
states.pop_back(); states.pop_back();
skip_to_state_evaluation = true; skip_to_state_evaluation = true;
continue; continue;
@ -462,7 +462,7 @@ class parser
{ {
std::string error_msg = "syntax error "; std::string error_msg = "syntax error ";
if (not context.empty()) if (!context.empty())
{ {
error_msg += "while parsing " + context + " "; error_msg += "while parsing " + context + " ";
} }

9
include/nlohmann/detail/iterators/iter_impl.hpp
View File

@ -3,7 +3,6 @@
#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next #include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
#include <type_traits> // conditional, is_const, remove_const #include <type_traits> // conditional, is_const, remove_const
#include <nlohmann/detail/boolean_operators.hpp>
#include <nlohmann/detail/exceptions.hpp> #include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/iterators/internal_iterator.hpp> #include <nlohmann/detail/iterators/internal_iterator.hpp>
#include <nlohmann/detail/iterators/primitive_iterator.hpp> #include <nlohmann/detail/iterators/primitive_iterator.hpp>
@ -423,7 +422,7 @@ class iter_impl
*/ */
bool operator!=(const iter_impl& other) const bool operator!=(const iter_impl& other) const
{ {
return not operator==(other); return !operator==(other);
} }
/*! /*!
@ -459,7 +458,7 @@ class iter_impl
*/ */
bool operator<=(const iter_impl& other) const 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 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 bool operator>=(const iter_impl& other) const
{ {
return not operator<(other); return !operator<(other);
} }
/*! /*!

10
include/nlohmann/detail/iterators/iteration_proxy.hpp
View File

@ -19,7 +19,7 @@ void int_to_string( string_type& target, std::size_t value )
using std::to_string; using std::to_string;
target = to_string(value); target = to_string(value);
} }
template <typename IteratorType> class iteration_proxy_value template<typename IteratorType> class iteration_proxy_value
{ {
public: public:
using difference_type = std::ptrdiff_t; using difference_type = std::ptrdiff_t;
@ -133,7 +133,7 @@ template<typename IteratorType> class iteration_proxy
// Structured Bindings Support // Structured Bindings Support
// For further reference see https://blog.tartanllama.xyz/structured-bindings/ // For further reference see https://blog.tartanllama.xyz/structured-bindings/
// And see https://github.com/nlohmann/json/pull/1391 // 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()) auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
{ {
return i.key(); return i.key();
@ -141,7 +141,7 @@ auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decl
// Structured Bindings Support // Structured Bindings Support
// For further reference see https://blog.tartanllama.xyz/structured-bindings/ // For further reference see https://blog.tartanllama.xyz/structured-bindings/
// And see https://github.com/nlohmann/json/pull/1391 // 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()) auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
{ {
return i.value(); return i.value();
@ -160,11 +160,11 @@ namespace std
#pragma clang diagnostic push #pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmismatched-tags" #pragma clang diagnostic ignored "-Wmismatched-tags"
#endif #endif
template <typename IteratorType> template<typename IteratorType>
class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
: public std::integral_constant<std::size_t, 2> {}; : 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 >> class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
{ {
public: public:

10
include/nlohmann/detail/iterators/iterator_traits.hpp
View File

@ -9,10 +9,10 @@ namespace nlohmann
{ {
namespace detail namespace detail
{ {
template <typename It, typename = void> template<typename It, typename = void>
struct iterator_types {}; struct iterator_types {};
template <typename It> template<typename It>
struct iterator_types < struct iterator_types <
It, It,
void_t<typename It::difference_type, typename It::value_type, typename It::pointer, 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 // 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. // 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 struct iterator_traits
{ {
}; };
template <typename T> template<typename T>
struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >> struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
: iterator_types<T> : iterator_types<T>
{ {
}; };
template <typename T> template<typename T>
struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>> struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
{ {
using iterator_category = std::random_access_iterator_tag; using iterator_category = std::random_access_iterator_tag;

26
include/nlohmann/detail/json_pointer.hpp
View File

@ -335,7 +335,7 @@ class json_pointer
using size_type = typename BasicJsonType::size_type; using size_type = typename BasicJsonType::size_type;
// error condition (cf. RFC 6901, Sect. 4) // 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, JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + s + "array index '" + s +
@ -343,7 +343,7 @@ class json_pointer
} }
// error condition (cf. RFC 6901, Sect. 4) // 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")); JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number"));
} }
@ -483,7 +483,7 @@ class json_pointer
}); });
// change value to array for numbers or "-" or to object otherwise // 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::array
: detail::value_t::object; : detail::value_t::object;
} }
@ -665,7 +665,7 @@ class json_pointer
{ {
case detail::value_t::object: 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 // we did not find the key in the object
return false; return false;
@ -682,21 +682,21 @@ class json_pointer
// "-" always fails the range check // "-" always fails the range check
return false; 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 // invalid char
return false; return false;
} }
if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1)) 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' // first char should be between '1' and '9'
return false; return false;
} }
for (std::size_t i = 1; i < reference_token.size(); i++) 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' // other char should be between '0' and '9'
return false; return false;
@ -783,8 +783,8 @@ class json_pointer
JSON_ASSERT(reference_token[pos] == '~'); JSON_ASSERT(reference_token[pos] == '~');
// ~ must be followed by 0 or 1 // ~ must be followed by 0 or 1
if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 or if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
(reference_token[pos + 1] != '0' and (reference_token[pos + 1] != '0' &&
reference_token[pos + 1] != '1'))) reference_token[pos + 1] != '1')))
{ {
JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'")); JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
@ -815,7 +815,7 @@ class json_pointer
static void replace_substring(std::string& s, const std::string& f, static void replace_substring(std::string& s, const std::string& f,
const std::string& t) const std::string& t)
{ {
JSON_ASSERT(not f.empty()); JSON_ASSERT(!f.empty());
for (auto pos = s.find(f); // find first occurrence of f for (auto pos = s.find(f); // find first occurrence of f
pos != std::string::npos; // make sure f was found pos != std::string::npos; // make sure f was found
s.replace(pos, f.size(), t), // replace with t, and s.replace(pos, f.size(), t), // replace with t, and
@ -910,7 +910,7 @@ class json_pointer
static BasicJsonType static BasicJsonType
unflatten(const BasicJsonType& value) 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")); JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
} }
@ -920,7 +920,7 @@ class json_pointer
// iterate the JSON object values // iterate the JSON object values
for (const auto& element : *value.m_value.object) 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")); JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
} }
@ -966,7 +966,7 @@ class json_pointer
friend bool operator!=(json_pointer const& lhs, friend bool operator!=(json_pointer const& lhs,
json_pointer const& rhs) noexcept json_pointer const& rhs) noexcept
{ {
return not (lhs == rhs); return !(lhs == rhs);
} }
/// the reference tokens /// the reference tokens

2
include/nlohmann/detail/meta/cpp_future.hpp
View File

@ -3,8 +3,6 @@
#include <cstddef> // size_t #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 <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 nlohmann
{ {
namespace detail namespace detail

18
include/nlohmann/detail/meta/detected.hpp
View File

@ -19,9 +19,9 @@ struct nonesuch
void operator=(nonesuch&&) = delete; void operator=(nonesuch&&) = delete;
}; };
template <class Default, template<class Default,
class AlwaysVoid, class AlwaysVoid,
template <class...> class Op, template<class...> class Op,
class... Args> class... Args>
struct detector struct detector
{ {
@ -29,29 +29,29 @@ struct detector
using type = Default; 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...> struct detector<Default, void_t<Op<Args...>>, Op, Args...>
{ {
using value_t = std::true_type; using value_t = std::true_type;
using type = Op<Args...>; 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; 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; 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...>; 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; 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...>>; 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 = using is_detected_convertible =
std::is_convertible<detected_t<Op, Args...>, To>; std::is_convertible<detected_t<Op, Args...>, To>;
} // namespace detail } // namespace detail

28
include/nlohmann/detail/meta/is_sax.hpp
View File

@ -11,53 +11,53 @@ namespace nlohmann
{ {
namespace detail namespace detail
{ {
template <typename T> template<typename T>
using null_function_t = decltype(std::declval<T&>().null()); using null_function_t = decltype(std::declval<T&>().null());
template <typename T> template<typename T>
using boolean_function_t = using boolean_function_t =
decltype(std::declval<T&>().boolean(std::declval<bool>())); decltype(std::declval<T&>().boolean(std::declval<bool>()));
template <typename T, typename Integer> template<typename T, typename Integer>
using number_integer_function_t = using number_integer_function_t =
decltype(std::declval<T&>().number_integer(std::declval<Integer>())); decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
template <typename T, typename Unsigned> template<typename T, typename Unsigned>
using number_unsigned_function_t = using number_unsigned_function_t =
decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>())); 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( using number_float_function_t = decltype(std::declval<T&>().number_float(
std::declval<Float>(), std::declval<const String&>())); std::declval<Float>(), std::declval<const String&>()));
template <typename T, typename String> template<typename T, typename String>
using string_function_t = using string_function_t =
decltype(std::declval<T&>().string(std::declval<String&>())); decltype(std::declval<T&>().string(std::declval<String&>()));
template <typename T> template<typename T>
using start_object_function_t = using start_object_function_t =
decltype(std::declval<T&>().start_object(std::declval<std::size_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 = using key_function_t =
decltype(std::declval<T&>().key(std::declval<String&>())); 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()); using end_object_function_t = decltype(std::declval<T&>().end_object());
template <typename T> template<typename T>
using start_array_function_t = using start_array_function_t =
decltype(std::declval<T&>().start_array(std::declval<std::size_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()); 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( using parse_error_function_t = decltype(std::declval<T&>().parse_error(
std::declval<std::size_t>(), std::declval<const std::string&>(), std::declval<std::size_t>(), std::declval<const std::string&>(),
std::declval<const Exception&>())); std::declval<const Exception&>()));
template <typename SAX, typename BasicJsonType> template<typename SAX, typename BasicJsonType>
struct is_sax struct is_sax
{ {
private: private:
@ -89,7 +89,7 @@ struct is_sax
is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value; 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 struct is_sax_static_asserts
{ {
private: private:

167
include/nlohmann/detail/meta/type_traits.hpp
View File

@ -4,7 +4,6 @@
#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type #include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
#include <utility> // declval #include <utility> // declval
#include <nlohmann/detail/boolean_operators.hpp>
#include <nlohmann/detail/iterators/iterator_traits.hpp> #include <nlohmann/detail/iterators/iterator_traits.hpp>
#include <nlohmann/detail/macro_scope.hpp> #include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/meta/cpp_future.hpp> #include <nlohmann/detail/meta/cpp_future.hpp>
@ -45,59 +44,59 @@ struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
// json_ref helpers // // json_ref helpers //
////////////////////// //////////////////////
template <typename> template<typename>
class json_ref; class json_ref;
template<typename> template<typename>
struct is_json_ref : std::false_type {}; struct is_json_ref : std::false_type {};
template <typename T> template<typename T>
struct is_json_ref<json_ref<T>> : std::true_type {}; struct is_json_ref<json_ref<T>> : std::true_type {};
////////////////////////// //////////////////////////
// aliases for detected // // aliases for detected //
////////////////////////// //////////////////////////
template <typename T> template<typename T>
using mapped_type_t = typename T::mapped_type; using mapped_type_t = typename T::mapped_type;
template <typename T> template<typename T>
using key_type_t = typename T::key_type; using key_type_t = typename T::key_type;
template <typename T> template<typename T>
using value_type_t = typename T::value_type; using value_type_t = typename T::value_type;
template <typename T> template<typename T>
using difference_type_t = typename T::difference_type; using difference_type_t = typename T::difference_type;
template <typename T> template<typename T>
using pointer_t = typename T::pointer; using pointer_t = typename T::pointer;
template <typename T> template<typename T>
using reference_t = typename T::reference; using reference_t = typename T::reference;
template <typename T> template<typename T>
using iterator_category_t = typename T::iterator_category; using iterator_category_t = typename T::iterator_category;
template <typename T> template<typename T>
using iterator_t = typename T::iterator; 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>()...)); 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>()...)); 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>()); using get_template_function = decltype(std::declval<T>().template get<U>());
// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists // 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 {}; struct has_from_json : std::false_type {};
template <typename BasicJsonType, typename T> template<typename BasicJsonType, typename T>
struct has_from_json<BasicJsonType, T, struct has_from_json < BasicJsonType, T,
enable_if_t<not is_basic_json<T>::value>> enable_if_t < !is_basic_json<T>::value >>
{ {
using serializer = typename BasicJsonType::template json_serializer<T, void>; using serializer = typename BasicJsonType::template json_serializer<T, void>;
@ -108,11 +107,11 @@ struct has_from_json<BasicJsonType, T,
// This trait checks if JSONSerializer<T>::from_json(json const&) exists // This trait checks if JSONSerializer<T>::from_json(json const&) exists
// this overload is used for non-default-constructible user-defined-types // 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 {}; struct has_non_default_from_json : std::false_type {};
template<typename BasicJsonType, typename T> 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>; using serializer = typename BasicJsonType::template json_serializer<T, void>;
@ -123,11 +122,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 // 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. // 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 {}; struct has_to_json : std::false_type {};
template <typename BasicJsonType, typename T> template<typename BasicJsonType, typename T>
struct has_to_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>> struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
{ {
using serializer = typename BasicJsonType::template json_serializer<T, void>; using serializer = typename BasicJsonType::template json_serializer<T, void>;
@ -141,10 +140,10 @@ struct has_to_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>>
// is_ functions // // is_ functions //
/////////////////// ///////////////////
template <typename T, typename = void> template<typename T, typename = void>
struct is_iterator_traits : std::false_type {}; struct is_iterator_traits : std::false_type {};
template <typename T> template<typename T>
struct is_iterator_traits<iterator_traits<T>> struct is_iterator_traits<iterator_traits<T>>
{ {
private: private:
@ -161,20 +160,20 @@ struct is_iterator_traits<iterator_traits<T>>
// source: https://stackoverflow.com/a/37193089/4116453 // source: https://stackoverflow.com/a/37193089/4116453
template <typename T, typename = void> template<typename T, typename = void>
struct is_complete_type : std::false_type {}; 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 {}; struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
template <typename BasicJsonType, typename CompatibleObjectType, template<typename BasicJsonType, typename CompatibleObjectType,
typename = void> typename = void>
struct is_compatible_object_type_impl : std::false_type {}; 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 < struct is_compatible_object_type_impl <
BasicJsonType, CompatibleObjectType, 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 >> is_detected<key_type_t, CompatibleObjectType>::value >>
{ {
@ -183,53 +182,53 @@ struct is_compatible_object_type_impl <
// macOS's is_constructible does not play well with nonesuch... // macOS's is_constructible does not play well with nonesuch...
static constexpr bool value = static constexpr bool value =
std::is_constructible<typename object_t::key_type, 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, std::is_constructible<typename object_t::mapped_type,
typename CompatibleObjectType::mapped_type>::value; typename CompatibleObjectType::mapped_type>::value;
}; };
template <typename BasicJsonType, typename CompatibleObjectType> template<typename BasicJsonType, typename CompatibleObjectType>
struct is_compatible_object_type struct is_compatible_object_type
: is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {}; : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
template <typename BasicJsonType, typename ConstructibleObjectType, template<typename BasicJsonType, typename ConstructibleObjectType,
typename = void> typename = void>
struct is_constructible_object_type_impl : std::false_type {}; 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 < struct is_constructible_object_type_impl <
BasicJsonType, ConstructibleObjectType, 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 >> is_detected<key_type_t, ConstructibleObjectType>::value >>
{ {
using object_t = typename BasicJsonType::object_t; using object_t = typename BasicJsonType::object_t;
static constexpr bool value = static constexpr bool value =
(std::is_default_constructible<ConstructibleObjectType>::value and (std::is_default_constructible<ConstructibleObjectType>::value &&
(std::is_move_assignable<ConstructibleObjectType>::value or (std::is_move_assignable<ConstructibleObjectType>::value ||
std::is_copy_assignable<ConstructibleObjectType>::value) and std::is_copy_assignable<ConstructibleObjectType>::value) &&
(std::is_constructible<typename ConstructibleObjectType::key_type, (std::is_constructible<typename ConstructibleObjectType::key_type,
typename object_t::key_type>::value and typename object_t::key_type>::value &&
std::is_same < std::is_same <
typename object_t::mapped_type, typename object_t::mapped_type,
typename ConstructibleObjectType::mapped_type >::value)) or typename ConstructibleObjectType::mapped_type >::value)) ||
(has_from_json<BasicJsonType, (has_from_json<BasicJsonType,
typename ConstructibleObjectType::mapped_type>::value or typename ConstructibleObjectType::mapped_type>::value ||
has_non_default_from_json < has_non_default_from_json <
BasicJsonType, BasicJsonType,
typename ConstructibleObjectType::mapped_type >::value); typename ConstructibleObjectType::mapped_type >::value);
}; };
template <typename BasicJsonType, typename ConstructibleObjectType> template<typename BasicJsonType, typename ConstructibleObjectType>
struct is_constructible_object_type struct is_constructible_object_type
: is_constructible_object_type_impl<BasicJsonType, : is_constructible_object_type_impl<BasicJsonType,
ConstructibleObjectType> {}; ConstructibleObjectType> {};
template <typename BasicJsonType, typename CompatibleStringType, template<typename BasicJsonType, typename CompatibleStringType,
typename = void> typename = void>
struct is_compatible_string_type_impl : std::false_type {}; 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 < struct is_compatible_string_type_impl <
BasicJsonType, CompatibleStringType, BasicJsonType, CompatibleStringType,
enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type, enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
@ -239,15 +238,15 @@ struct is_compatible_string_type_impl <
std::is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value; std::is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
}; };
template <typename BasicJsonType, typename ConstructibleStringType> template<typename BasicJsonType, typename ConstructibleStringType>
struct is_compatible_string_type struct is_compatible_string_type
: is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {}; : is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
template <typename BasicJsonType, typename ConstructibleStringType, template<typename BasicJsonType, typename ConstructibleStringType,
typename = void> typename = void>
struct is_constructible_string_type_impl : std::false_type {}; 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 < struct is_constructible_string_type_impl <
BasicJsonType, ConstructibleStringType, BasicJsonType, ConstructibleStringType,
enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type, enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
@ -258,55 +257,55 @@ struct is_constructible_string_type_impl <
typename BasicJsonType::string_t>::value; typename BasicJsonType::string_t>::value;
}; };
template <typename BasicJsonType, typename ConstructibleStringType> template<typename BasicJsonType, typename ConstructibleStringType>
struct is_constructible_string_type struct is_constructible_string_type
: is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {}; : 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 {}; 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 < struct is_compatible_array_type_impl <
BasicJsonType, CompatibleArrayType, BasicJsonType, CompatibleArrayType,
enable_if_t<is_detected<value_type_t, CompatibleArrayType>::value and enable_if_t < is_detected<value_type_t, CompatibleArrayType>::value&&
is_detected<iterator_t, CompatibleArrayType>::value and is_detected<iterator_t, CompatibleArrayType>::value&&
// This is needed because json_reverse_iterator has a ::iterator type... // This is needed because json_reverse_iterator has a ::iterator type...
// Therefore it is detected as a CompatibleArrayType. // Therefore it is detected as a CompatibleArrayType.
// The real fix would be to have an Iterable concept. // The real fix would be to have an Iterable concept.
not is_iterator_traits< !is_iterator_traits <
iterator_traits<CompatibleArrayType>>::value >> iterator_traits<CompatibleArrayType >>::value >>
{ {
static constexpr bool value = static constexpr bool value =
std::is_constructible<BasicJsonType, std::is_constructible<BasicJsonType,
typename CompatibleArrayType::value_type>::value; typename CompatibleArrayType::value_type>::value;
}; };
template <typename BasicJsonType, typename CompatibleArrayType> template<typename BasicJsonType, typename CompatibleArrayType>
struct is_compatible_array_type struct is_compatible_array_type
: is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {}; : 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 {}; 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 < struct is_constructible_array_type_impl <
BasicJsonType, ConstructibleArrayType, BasicJsonType, ConstructibleArrayType,
enable_if_t<std::is_same<ConstructibleArrayType, enable_if_t<std::is_same<ConstructibleArrayType,
typename BasicJsonType::value_type>::value >> typename BasicJsonType::value_type>::value >>
: std::true_type {}; : std::true_type {};
template <typename BasicJsonType, typename ConstructibleArrayType> template<typename BasicJsonType, typename ConstructibleArrayType>
struct is_constructible_array_type_impl < struct is_constructible_array_type_impl <
BasicJsonType, ConstructibleArrayType, BasicJsonType, ConstructibleArrayType,
enable_if_t<not std::is_same<ConstructibleArrayType, enable_if_t < !std::is_same<ConstructibleArrayType,
typename BasicJsonType::value_type>::value and typename BasicJsonType::value_type>::value&&
std::is_default_constructible<ConstructibleArrayType>::value and std::is_default_constructible<ConstructibleArrayType>::value&&
(std::is_move_assignable<ConstructibleArrayType>::value or (std::is_move_assignable<ConstructibleArrayType>::value ||
std::is_copy_assignable<ConstructibleArrayType>::value) and std::is_copy_assignable<ConstructibleArrayType>::value)&&
is_detected<value_type_t, ConstructibleArrayType>::value and is_detected<value_type_t, ConstructibleArrayType>::value&&
is_detected<iterator_t, ConstructibleArrayType>::value and is_detected<iterator_t, ConstructibleArrayType>::value&&
is_complete_type< is_complete_type <
detected_t<value_type_t, ConstructibleArrayType>>::value >> detected_t<value_type_t, ConstructibleArrayType >>::value >>
{ {
static constexpr bool value = static constexpr bool value =
// This is needed because json_reverse_iterator has a ::iterator type, // This is needed because json_reverse_iterator has a ::iterator type,
@ -314,30 +313,30 @@ detected_t<value_type_t, ConstructibleArrayType>>::value >>
// base class `iterator`... Therefore it is detected as a // base class `iterator`... Therefore it is detected as a
// ConstructibleArrayType. The real fix would be to have an Iterable // ConstructibleArrayType. The real fix would be to have an Iterable
// concept. // concept.
not is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value and !is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value &&
(std::is_same<typename ConstructibleArrayType::value_type, (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, has_from_json<BasicJsonType,
typename ConstructibleArrayType::value_type>::value or typename ConstructibleArrayType::value_type>::value ||
has_non_default_from_json < has_non_default_from_json <
BasicJsonType, typename ConstructibleArrayType::value_type >::value); BasicJsonType, typename ConstructibleArrayType::value_type >::value);
}; };
template <typename BasicJsonType, typename ConstructibleArrayType> template<typename BasicJsonType, typename ConstructibleArrayType>
struct is_constructible_array_type struct is_constructible_array_type
: is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {}; : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
template <typename RealIntegerType, typename CompatibleNumberIntegerType, template<typename RealIntegerType, typename CompatibleNumberIntegerType,
typename = void> typename = void>
struct is_compatible_integer_type_impl : std::false_type {}; 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 < struct is_compatible_integer_type_impl <
RealIntegerType, CompatibleNumberIntegerType, RealIntegerType, CompatibleNumberIntegerType,
enable_if_t<std::is_integral<RealIntegerType>::value and enable_if_t < std::is_integral<RealIntegerType>::value&&
std::is_integral<CompatibleNumberIntegerType>::value and std::is_integral<CompatibleNumberIntegerType>::value&&
not std::is_same<bool, CompatibleNumberIntegerType>::value >> !std::is_same<bool, CompatibleNumberIntegerType>::value >>
{ {
// is there an assert somewhere on overflows? // is there an assert somewhere on overflows?
using RealLimits = std::numeric_limits<RealIntegerType>; using RealLimits = std::numeric_limits<RealIntegerType>;
@ -345,20 +344,20 @@ struct is_compatible_integer_type_impl <
static constexpr auto value = static constexpr auto value =
std::is_constructible<RealIntegerType, std::is_constructible<RealIntegerType,
CompatibleNumberIntegerType>::value and CompatibleNumberIntegerType>::value &&
CompatibleLimits::is_integer and CompatibleLimits::is_integer &&
RealLimits::is_signed == CompatibleLimits::is_signed; RealLimits::is_signed == CompatibleLimits::is_signed;
}; };
template <typename RealIntegerType, typename CompatibleNumberIntegerType> template<typename RealIntegerType, typename CompatibleNumberIntegerType>
struct is_compatible_integer_type struct is_compatible_integer_type
: is_compatible_integer_type_impl<RealIntegerType, : is_compatible_integer_type_impl<RealIntegerType,
CompatibleNumberIntegerType> {}; CompatibleNumberIntegerType> {};
template <typename BasicJsonType, typename CompatibleType, typename = void> template<typename BasicJsonType, typename CompatibleType, typename = void>
struct is_compatible_type_impl: std::false_type {}; struct is_compatible_type_impl: std::false_type {};
template <typename BasicJsonType, typename CompatibleType> template<typename BasicJsonType, typename CompatibleType>
struct is_compatible_type_impl < struct is_compatible_type_impl <
BasicJsonType, CompatibleType, BasicJsonType, CompatibleType,
enable_if_t<is_complete_type<CompatibleType>::value >> enable_if_t<is_complete_type<CompatibleType>::value >>
@ -367,7 +366,7 @@ struct is_compatible_type_impl <
has_to_json<BasicJsonType, CompatibleType>::value; has_to_json<BasicJsonType, CompatibleType>::value;
}; };
template <typename BasicJsonType, typename CompatibleType> template<typename BasicJsonType, typename CompatibleType>
struct is_compatible_type struct is_compatible_type
: is_compatible_type_impl<BasicJsonType, CompatibleType> {}; : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
@ -378,10 +377,10 @@ template<class B1, class... Bn>
struct conjunction<B1, Bn...> struct conjunction<B1, Bn...>
: std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {}; : 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 {}; 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>...> {}; struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<std::is_constructible<T1, Args>...> {};
} // namespace detail } // namespace detail
} // namespace nlohmann } // namespace nlohmann

4
include/nlohmann/detail/meta/void_t.hpp
View File

@ -4,10 +4,10 @@ namespace nlohmann
{ {
namespace detail namespace detail
{ {
template <typename ...Ts> struct make_void template<typename ...Ts> struct make_void
{ {
using type = 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 detail
} // namespace nlohmann } // namespace nlohmann

62
include/nlohmann/detail/output/binary_writer.hpp
View File

@ -426,28 +426,28 @@ class binary_writer
// negative fixnum // negative fixnum
write_number(static_cast<std::int8_t>(j.m_value.number_integer)); 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)()) j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
{ {
// int 8 // int 8
oa->write_character(to_char_type(0xD0)); oa->write_character(to_char_type(0xD0));
write_number(static_cast<std::int8_t>(j.m_value.number_integer)); 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)()) j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
{ {
// int 16 // int 16
oa->write_character(to_char_type(0xD1)); oa->write_character(to_char_type(0xD1));
write_number(static_cast<std::int16_t>(j.m_value.number_integer)); 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)()) j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
{ {
// int 32 // int 32
oa->write_character(to_char_type(0xD2)); oa->write_character(to_char_type(0xD2));
write_number(static_cast<std::int32_t>(j.m_value.number_integer)); 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)()) j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
{ {
// int 64 // int 64
@ -608,7 +608,7 @@ class binary_writer
} }
oa->write_character(to_char_type(output_type)); oa->write_character(to_char_type(output_type));
if (not fixed) if (!fixed)
{ {
write_number(static_cast<std::uint8_t>(N)); write_number(static_cast<std::uint8_t>(N));
} }
@ -752,7 +752,7 @@ class binary_writer
} }
bool prefix_required = true; bool prefix_required = true;
if (use_type and not j.m_value.array->empty()) if (use_type && !j.m_value.array->empty())
{ {
JSON_ASSERT(use_count); JSON_ASSERT(use_count);
const CharType first_prefix = ubjson_prefix(j.front()); const CharType first_prefix = ubjson_prefix(j.front());
@ -781,7 +781,7 @@ class binary_writer
write_ubjson(el, use_count, use_type, prefix_required); write_ubjson(el, use_count, use_type, prefix_required);
} }
if (not use_count) if (!use_count)
{ {
oa->write_character(to_char_type(']')); oa->write_character(to_char_type(']'));
} }
@ -796,7 +796,7 @@ class binary_writer
oa->write_character(to_char_type('[')); oa->write_character(to_char_type('['));
} }
if (use_type and not j.m_value.binary->empty()) if (use_type && !j.m_value.binary->empty())
{ {
JSON_ASSERT(use_count); JSON_ASSERT(use_count);
oa->write_character(to_char_type('$')); oa->write_character(to_char_type('$'));
@ -824,7 +824,7 @@ class binary_writer
} }
} }
if (not use_count) if (!use_count)
{ {
oa->write_character(to_char_type(']')); oa->write_character(to_char_type(']'));
} }
@ -840,7 +840,7 @@ class binary_writer
} }
bool prefix_required = true; bool prefix_required = true;
if (use_type and not j.m_value.object->empty()) if (use_type && !j.m_value.object->empty())
{ {
JSON_ASSERT(use_count); JSON_ASSERT(use_count);
const CharType first_prefix = ubjson_prefix(j.front()); const CharType first_prefix = ubjson_prefix(j.front());
@ -873,7 +873,7 @@ class binary_writer
write_ubjson(el.second, use_count, use_type, prefix_required); write_ubjson(el.second, use_count, use_type, prefix_required);
} }
if (not use_count) if (!use_count)
{ {
oa->write_character(to_char_type('}')); oa->write_character(to_char_type('}'));
} }
@ -974,7 +974,7 @@ class binary_writer
*/ */
static std::size_t calc_bson_integer_size(const std::int64_t value) 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::int32_t)
: sizeof(std::int64_t); : sizeof(std::int64_t);
} }
@ -985,7 +985,7 @@ class binary_writer
void write_bson_integer(const string_t& name, void write_bson_integer(const string_t& name,
const std::int64_t value) 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_bson_entry_header(name, 0x10); // int32
write_number<std::int32_t, true>(static_cast<std::int32_t>(value)); write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
@ -1318,13 +1318,13 @@ class binary_writer
} }
// UBJSON: write number (signed integer) // UBJSON: write number (signed integer)
template<typename NumberType, typename std::enable_if< template < typename NumberType, typename std::enable_if <
std::is_signed<NumberType>::value and std::is_signed<NumberType>::value&&
not std::is_floating_point<NumberType>::value, int>::type = 0> !std::is_floating_point<NumberType>::value, int >::type = 0 >
void write_number_with_ubjson_prefix(const NumberType n, void write_number_with_ubjson_prefix(const NumberType n,
const bool add_prefix) 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) if (add_prefix)
{ {
@ -1332,7 +1332,7 @@ class binary_writer
} }
write_number(static_cast<std::int8_t>(n)); 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) if (add_prefix)
{ {
@ -1340,7 +1340,7 @@ class binary_writer
} }
write_number(static_cast<std::uint8_t>(n)); 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) if (add_prefix)
{ {
@ -1348,7 +1348,7 @@ class binary_writer
} }
write_number(static_cast<std::int16_t>(n)); 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) if (add_prefix)
{ {
@ -1356,7 +1356,7 @@ class binary_writer
} }
write_number(static_cast<std::int32_t>(n)); 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) if (add_prefix)
{ {
@ -1393,19 +1393,19 @@ class binary_writer
case value_t::number_integer: 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'; 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'; 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'; 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'; return 'l';
} }
@ -1497,8 +1497,8 @@ class binary_writer
void write_compact_float(const number_float_t n, detail::input_format_t format) 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()) and 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)()) and static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
static_cast<double>(static_cast<float>(n)) == static_cast<double>(n)) static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
{ {
oa->write_character(format == detail::input_format_t::cbor oa->write_character(format == detail::input_format_t::cbor
@ -1521,14 +1521,14 @@ class binary_writer
// such a conversion is required to allow values greater than 128. // such a conversion is required to allow values greater than 128.
// See <https://github.com/nlohmann/json/issues/1286> for a discussion. // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
template < typename C = CharType, 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 static constexpr CharType to_char_type(std::uint8_t x) noexcept
{ {
return *reinterpret_cast<char*>(&x); return *reinterpret_cast<char*>(&x);
} }
template < typename C = CharType, 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 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"); static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
@ -1547,8 +1547,8 @@ class binary_writer
template < typename InputCharType, typename C = CharType, template < typename InputCharType, typename C = CharType,
enable_if_t < enable_if_t <
std::is_signed<C>::value and std::is_signed<C>::value &&
std::is_signed<char>::value and std::is_signed<char>::value &&
std::is_same<char, typename std::remove_cv<InputCharType>::type>::value std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
> * = nullptr > > * = nullptr >
static constexpr CharType to_char_type(InputCharType x) noexcept static constexpr CharType to_char_type(InputCharType x) noexcept

35
include/nlohmann/detail/output/serializer.hpp
View File

@ -12,7 +12,6 @@
#include <type_traits> // is_same #include <type_traits> // is_same
#include <utility> // move #include <utility> // move
#include <nlohmann/detail/boolean_operators.hpp>
#include <nlohmann/detail/conversions/to_chars.hpp> #include <nlohmann/detail/conversions/to_chars.hpp>
#include <nlohmann/detail/exceptions.hpp> #include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/macro_scope.hpp> #include <nlohmann/detail/macro_scope.hpp>
@ -204,7 +203,7 @@ class serializer
} }
// last element // last element
JSON_ASSERT(not val.m_value.array->empty()); JSON_ASSERT(!val.m_value.array->empty());
o->write_characters(indent_string.c_str(), new_indent); o->write_characters(indent_string.c_str(), new_indent);
dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent); dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
@ -225,7 +224,7 @@ class serializer
} }
// last element // last element
JSON_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); dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
o->write_character(']'); o->write_character(']');
@ -259,7 +258,7 @@ class serializer
o->write_characters("\"bytes\": [", 10); 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(); for (auto i = val.m_value.binary->cbegin();
i != val.m_value.binary->cend() - 1; ++i) i != val.m_value.binary->cend() - 1; ++i)
@ -290,7 +289,7 @@ class serializer
{ {
o->write_characters("{\"bytes\":[", 10); 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(); for (auto i = val.m_value.binary->cbegin();
i != val.m_value.binary->cend() - 1; ++i) i != val.m_value.binary->cend() - 1; ++i)
@ -451,7 +450,7 @@ class serializer
{ {
// escape control characters (0x00..0x1F) or, if // escape control characters (0x00..0x1F) or, if
// ensure_ascii parameter is used, non-ASCII characters // 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) if (codepoint <= 0xFFFF)
{ {
@ -565,7 +564,7 @@ class serializer
default: // decode found yet incomplete multi-byte code point 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 // code point will not be escaped - copy byte to buffer
string_buffer[bytes++] = s[i]; string_buffer[bytes++] = s[i];
@ -669,11 +668,11 @@ class serializer
@param[in] x integer number (signed or unsigned) to dump @param[in] x integer number (signed or unsigned) to dump
@tparam NumberType either @a number_integer_t or @a number_unsigned_t @tparam NumberType either @a number_integer_t or @a number_unsigned_t
*/ */
template<typename NumberType, detail::enable_if_t< template < typename NumberType, detail::enable_if_t <
std::is_same<NumberType, number_unsigned_t>::value or std::is_same<NumberType, number_unsigned_t>::value ||
std::is_same<NumberType, number_integer_t>::value or std::is_same<NumberType, number_integer_t>::value ||
std::is_same<NumberType, binary_char_t>::value, std::is_same<NumberType, binary_char_t>::value,
int> = 0> int > = 0 >
void dump_integer(NumberType x) void dump_integer(NumberType x)
{ {
static constexpr std::array<std::array<char, 2>, 100> digits_to_99 static constexpr std::array<std::array<char, 2>, 100> digits_to_99
@ -702,7 +701,7 @@ class serializer
// use a pointer to fill the buffer // use a pointer to fill the buffer
auto buffer_ptr = number_buffer.begin(); 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; number_unsigned_t abs_value;
unsigned int n_chars; unsigned int n_chars;
@ -763,7 +762,7 @@ class serializer
void dump_float(number_float_t x) void dump_float(number_float_t x)
{ {
// NaN / inf // NaN / inf
if (not std::isfinite(x)) if (!std::isfinite(x))
{ {
o->write_characters("null", 4); o->write_characters("null", 4);
return; return;
@ -775,8 +774,8 @@ class serializer
// //
// NB: The test below works if <long double> == <double>. // NB: The test below works if <long double> == <double>.
static constexpr bool is_ieee_single_or_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 && 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 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 == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>()); dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
} }
@ -813,7 +812,7 @@ class serializer
} }
// convert decimal point to '.' // 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); const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
if (dec_pos != number_buffer.end()) if (dec_pos != number_buffer.end())
@ -829,7 +828,7 @@ class serializer
std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1, std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
[](char c) [](char c)
{ {
return c == '.' or c == 'e'; return c == '.' || c == 'e';
}); });
if (value_is_int_like) if (value_is_int_like)
@ -915,7 +914,7 @@ class serializer
*/ */
inline number_unsigned_t remove_sign(number_integer_t x) noexcept inline number_unsigned_t remove_sign(number_integer_t x) noexcept
{ {
JSON_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; return static_cast<number_unsigned_t>(-(x + 1)) + 1;
} }

4
include/nlohmann/detail/value_t.hpp
View File

@ -5,8 +5,6 @@
#include <cstdint> // uint8_t #include <cstdint> // uint8_t
#include <string> // string #include <string> // string
#include <nlohmann/detail/boolean_operators.hpp>
namespace nlohmann namespace nlohmann
{ {
namespace detail 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 l_index = static_cast<std::size_t>(lhs);
const auto r_index = static_cast<std::size_t>(rhs); 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 detail
} // namespace nlohmann } // namespace nlohmann

242
include/nlohmann/json.hpp
View File

@ -48,7 +48,6 @@ SOFTWARE.
#include <nlohmann/adl_serializer.hpp> #include <nlohmann/adl_serializer.hpp>
#include <nlohmann/byte_container_with_subtype.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/from_json.hpp>
#include <nlohmann/detail/conversions/to_json.hpp> #include <nlohmann/detail/conversions/to_json.hpp>
#include <nlohmann/detail/exceptions.hpp> #include <nlohmann/detail/exceptions.hpp>
@ -71,6 +70,7 @@ SOFTWARE.
#include <nlohmann/detail/output/serializer.hpp> #include <nlohmann/detail/output/serializer.hpp>
#include <nlohmann/detail/value_t.hpp> #include <nlohmann/detail/value_t.hpp>
#include <nlohmann/json_fwd.hpp> #include <nlohmann/json_fwd.hpp>
#include <nlohmann/ordered_map.hpp>
/*! /*!
@brief namespace for Niels Lohmann @brief namespace for Niels Lohmann
@ -1136,7 +1136,7 @@ class basic_json
} }
} }
while (not stack.empty()) while (!stack.empty())
{ {
// move the last item to local variable to be processed // move the last item to local variable to be processed
basic_json current_item(std::move(stack.back())); basic_json current_item(std::move(stack.back()));
@ -1218,10 +1218,10 @@ class basic_json
*/ */
void assert_invariant() const noexcept void assert_invariant() const noexcept
{ {
JSON_ASSERT(m_type != value_t::object or m_value.object != nullptr); JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
JSON_ASSERT(m_type != value_t::array or m_value.array != nullptr); JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
JSON_ASSERT(m_type != value_t::string or m_value.string != nullptr); JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
JSON_ASSERT(m_type != value_t::binary or m_value.binary != nullptr); JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
} }
public: public:
@ -1429,10 +1429,10 @@ class basic_json
@since version 2.1.0 @since version 2.1.0
*/ */
template <typename CompatibleType, template < typename CompatibleType,
typename U = detail::uncvref_t<CompatibleType>, typename U = detail::uncvref_t<CompatibleType>,
detail::enable_if_t< detail::enable_if_t <
not detail::is_basic_json<U>::value and detail::is_compatible_type<basic_json_t, U>::value, int> = 0> !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
basic_json(CompatibleType && val) noexcept(noexcept( basic_json(CompatibleType && val) noexcept(noexcept(
JSONSerializer<U>::to_json(std::declval<basic_json_t&>(), JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
std::forward<CompatibleType>(val)))) std::forward<CompatibleType>(val))))
@ -1467,9 +1467,9 @@ class basic_json
@since version 3.2.0 @since version 3.2.0
*/ */
template <typename BasicJsonType, template < typename BasicJsonType,
detail::enable_if_t< detail::enable_if_t <
detail::is_basic_json<BasicJsonType>::value and not std::is_same<basic_json, BasicJsonType>::value, int> = 0> detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
basic_json(const BasicJsonType& val) basic_json(const BasicJsonType& val)
{ {
using other_boolean_t = typename BasicJsonType::boolean_t; using other_boolean_t = typename BasicJsonType::boolean_t;
@ -1602,11 +1602,11 @@ class basic_json
bool is_an_object = std::all_of(init.begin(), init.end(), bool is_an_object = std::all_of(init.begin(), init.end(),
[](const detail::json_ref<basic_json>& element_ref) [](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 // 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 array is wanted, do not create an object though possible
if (manual_type == value_t::array) if (manual_type == value_t::array)
@ -1615,7 +1615,7 @@ class basic_json
} }
// if object is wanted but impossible, throw an exception // 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")); JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
} }
@ -1909,9 +1909,9 @@ class basic_json
@since version 1.0.0 @since version 1.0.0
*/ */
template<class InputIT, typename std::enable_if< 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::iterator>::value ||
std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int>::type = 0> std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
basic_json(InputIT first, InputIT last) basic_json(InputIT first, InputIT last)
{ {
JSON_ASSERT(first.m_object != nullptr); JSON_ASSERT(first.m_object != nullptr);
@ -1935,8 +1935,8 @@ class basic_json
case value_t::number_unsigned: case value_t::number_unsigned:
case value_t::string: case value_t::string:
{ {
if (JSON_HEDLEY_UNLIKELY(not first.m_it.primitive_iterator.is_begin() if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
or not last.m_it.primitive_iterator.is_end())) || !last.m_it.primitive_iterator.is_end()))
{ {
JSON_THROW(invalid_iterator::create(204, "iterators out of range")); JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
} }
@ -2012,7 +2012,7 @@ class basic_json
// other constructors and destructor // // other constructors and destructor //
/////////////////////////////////////// ///////////////////////////////////////
template <typename JsonRef, template<typename JsonRef,
detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>, detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 > std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {} basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
@ -2169,9 +2169,9 @@ class basic_json
@since version 1.0.0 @since version 1.0.0
*/ */
basic_json& operator=(basic_json other) noexcept ( basic_json& operator=(basic_json other) noexcept (
std::is_nothrow_move_constructible<value_t>::value and std::is_nothrow_move_constructible<value_t>::value&&
std::is_nothrow_move_assignable<value_t>::value and std::is_nothrow_move_assignable<value_t>::value&&
std::is_nothrow_move_constructible<json_value>::value and std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value std::is_nothrow_move_assignable<json_value>::value
) )
{ {
@ -2351,7 +2351,7 @@ class basic_json
*/ */
constexpr bool is_primitive() const noexcept 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();
} }
/*! /*!
@ -2378,7 +2378,7 @@ class basic_json
*/ */
constexpr bool is_structured() const noexcept constexpr bool is_structured() const noexcept
{ {
return is_array() or is_object(); return is_array() || is_object();
} }
/*! /*!
@ -2452,7 +2452,7 @@ class basic_json
*/ */
constexpr bool is_number() const noexcept constexpr bool is_number() const noexcept
{ {
return is_number_integer() or is_number_float(); return is_number_integer() || is_number_float();
} }
/*! /*!
@ -2481,7 +2481,7 @@ class basic_json
*/ */
constexpr bool is_number_integer() const noexcept 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;
} }
/*! /*!
@ -2862,9 +2862,9 @@ class basic_json
@since version 3.2.0 @since version 3.2.0
*/ */
template<typename BasicJsonType, detail::enable_if_t< template < typename BasicJsonType, detail::enable_if_t <
not std::is_same<BasicJsonType, basic_json>::value and !std::is_same<BasicJsonType, basic_json>::value&&
detail::is_basic_json<BasicJsonType>::value, int> = 0> detail::is_basic_json<BasicJsonType>::value, int > = 0 >
BasicJsonType get() const BasicJsonType get() const
{ {
return *this; return *this;
@ -2909,19 +2909,19 @@ class basic_json
@since version 2.1.0 @since version 2.1.0
*/ */
template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>, template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
detail::enable_if_t < detail::enable_if_t <
not detail::is_basic_json<ValueType>::value and !detail::is_basic_json<ValueType>::value &&
detail::has_from_json<basic_json_t, ValueType>::value and detail::has_from_json<basic_json_t, ValueType>::value &&
not detail::has_non_default_from_json<basic_json_t, ValueType>::value, !detail::has_non_default_from_json<basic_json_t, ValueType>::value,
int> = 0> int > = 0 >
ValueType get() const noexcept(noexcept( ValueType get() const noexcept(noexcept(
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>()))) JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
{ {
// we cannot static_assert on ValueTypeCV being non-const, because // we cannot static_assert on ValueTypeCV being non-const, because
// there is support for get<const basic_json_t>(), which is why we // there is support for get<const basic_json_t>(), which is why we
// still need the uncvref // 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()"); "get() cannot be used with reference types, you might want to use get_ref()");
static_assert(std::is_default_constructible<ValueType>::value, static_assert(std::is_default_constructible<ValueType>::value,
"types must be DefaultConstructible when used with get()"); "types must be DefaultConstructible when used with get()");
@ -2962,14 +2962,14 @@ class basic_json
@since version 2.1.0 @since version 2.1.0
*/ */
template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>, template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
detail::enable_if_t<not std::is_same<basic_json_t, ValueType>::value and detail::enable_if_t < !std::is_same<basic_json_t, ValueType>::value &&
detail::has_non_default_from_json<basic_json_t, ValueType>::value, detail::has_non_default_from_json<basic_json_t, ValueType>::value,
int> = 0> int > = 0 >
ValueType get() const noexcept(noexcept( ValueType get() const noexcept(noexcept(
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>()))) 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()"); "get() cannot be used with reference types, you might want to use get_ref()");
return JSONSerializer<ValueType>::from_json(*this); return JSONSerializer<ValueType>::from_json(*this);
} }
@ -3007,11 +3007,11 @@ class basic_json
@since version 3.3.0 @since version 3.3.0
*/ */
template<typename ValueType, template < typename ValueType,
detail::enable_if_t < detail::enable_if_t <
not detail::is_basic_json<ValueType>::value and !detail::is_basic_json<ValueType>::value&&
detail::has_from_json<basic_json_t, ValueType>::value, detail::has_from_json<basic_json_t, ValueType>::value,
int> = 0> int > = 0 >
ValueType & get_to(ValueType& v) const noexcept(noexcept( ValueType & get_to(ValueType& v) const noexcept(noexcept(
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v))) JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
{ {
@ -3083,9 +3083,9 @@ class basic_json
@brief get a pointer value (implicit) @brief get a pointer value (implicit)
@copydoc get_ptr() @copydoc get_ptr()
*/ */
template<typename PointerType, typename std::enable_if< template < typename PointerType, typename std::enable_if <
std::is_pointer<PointerType>::value and std::is_pointer<PointerType>::value&&
std::is_const<typename std::remove_pointer<PointerType>::type>::value, int>::type = 0> 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>())) 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 // delegate the call to get_impl_ptr<>() const
@ -3177,9 +3177,9 @@ class basic_json
@brief get a reference value (implicit) @brief get a reference value (implicit)
@copydoc get_ref() @copydoc get_ref()
*/ */
template<typename ReferenceType, typename std::enable_if< template < typename ReferenceType, typename std::enable_if <
std::is_reference<ReferenceType>::value and std::is_reference<ReferenceType>::value&&
std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int>::type = 0> std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
ReferenceType get_ref() const ReferenceType get_ref() const
{ {
// delegate call to get_ref_impl // delegate call to get_ref_impl
@ -3216,15 +3216,15 @@ class basic_json
@since version 1.0.0 @since version 1.0.0
*/ */
template < typename ValueType, typename std::enable_if < template < typename ValueType, typename std::enable_if <
not std::is_pointer<ValueType>::value and !std::is_pointer<ValueType>::value&&
not std::is_same<ValueType, detail::json_ref<basic_json>>::value and !std::is_same<ValueType, detail::json_ref<basic_json>>::value&&
not std::is_same<ValueType, typename string_t::value_type>::value and !std::is_same<ValueType, typename string_t::value_type>::value&&
not detail::is_basic_json<ValueType>::value !detail::is_basic_json<ValueType>::value
and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::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) and _MSC_VER >= 1910 and _MSC_VER <= 1914)) #if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
and not std::is_same<ValueType, typename std::string_view>::value && !std::is_same<ValueType, typename std::string_view>::value
#endif #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 > , int >::type = 0 >
operator ValueType() const operator ValueType() const
{ {
@ -3243,7 +3243,7 @@ class basic_json
*/ */
binary_t& get_binary() 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()))); JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
} }
@ -3254,7 +3254,7 @@ class basic_json
/// @copydoc get_binary() /// @copydoc get_binary()
const binary_t& get_binary() const 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()))); JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
} }
@ -3781,9 +3781,9 @@ class basic_json
@since version 1.0.0 @since version 1.0.0
*/ */
template<class ValueType, typename std::enable_if< template < class ValueType, typename std::enable_if <
std::is_convertible<basic_json_t, ValueType>::value std::is_convertible<basic_json_t, ValueType>::value
and not std::is_same<value_t, ValueType>::value, int>::type = 0> && !std::is_same<value_t, ValueType>::value, int >::type = 0 >
ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
{ {
// at only works for objects // at only works for objects
@ -4017,10 +4017,10 @@ class basic_json
@since version 1.0.0 @since version 1.0.0
*/ */
template<class IteratorType, typename std::enable_if< 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::iterator>::value ||
std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
= 0> = 0 >
IteratorType erase(IteratorType pos) IteratorType erase(IteratorType pos)
{ {
// make sure iterator fits the current value // make sure iterator fits the current value
@ -4040,7 +4040,7 @@ class basic_json
case value_t::string: case value_t::string:
case value_t::binary: 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")); JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
} }
@ -4130,14 +4130,14 @@ class basic_json
@since version 1.0.0 @since version 1.0.0
*/ */
template<class IteratorType, typename std::enable_if< 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::iterator>::value ||
std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
= 0> = 0 >
IteratorType erase(IteratorType first, IteratorType last) IteratorType erase(IteratorType first, IteratorType last)
{ {
// make sure iterator fits the current value // 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")); JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
} }
@ -4153,8 +4153,8 @@ class basic_json
case value_t::string: case value_t::string:
case value_t::binary: case value_t::binary:
{ {
if (JSON_HEDLEY_LIKELY(not first.m_it.primitive_iterator.is_begin() if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
or not last.m_it.primitive_iterator.is_end())) || !last.m_it.primitive_iterator.is_end()))
{ {
JSON_THROW(invalid_iterator::create(204, "iterators out of range")); JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
} }
@ -4399,11 +4399,11 @@ class basic_json
@since version 3.6.0 @since version 3.6.0
*/ */
template<typename KeyT, typename std::enable_if< template < typename KeyT, typename std::enable_if <
not std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int>::type = 0> !std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int >::type = 0 >
bool contains(KeyT && key) const 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();
} }
/*! /*!
@ -5221,7 +5221,7 @@ class basic_json
void push_back(basic_json&& val) void push_back(basic_json&& val)
{ {
// push_back only works for null objects or arrays // 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()))); JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
} }
@ -5256,7 +5256,7 @@ class basic_json
void push_back(const basic_json& val) void push_back(const basic_json& val)
{ {
// push_back only works for null objects or arrays // 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()))); JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
} }
@ -5306,7 +5306,7 @@ class basic_json
void push_back(const typename object_t::value_type& val) void push_back(const typename object_t::value_type& val)
{ {
// push_back only works for null objects or objects // 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()))); JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
} }
@ -5360,7 +5360,7 @@ class basic_json
*/ */
void push_back(initializer_list_t init) 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(); basic_json&& key = init.begin()->moved_or_copied();
push_back(typename object_t::value_type( push_back(typename object_t::value_type(
@ -5409,7 +5409,7 @@ class basic_json
reference emplace_back(Args&& ... args) reference emplace_back(Args&& ... args)
{ {
// emplace_back only works for null objects or arrays // 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()))); JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
} }
@ -5462,7 +5462,7 @@ class basic_json
std::pair<iterator, bool> emplace(Args&& ... args) std::pair<iterator, bool> emplace(Args&& ... args)
{ {
// emplace only works for null objects or arrays // 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()))); JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
} }
@ -5629,7 +5629,7 @@ class basic_json
iterator insert(const_iterator pos, const_iterator first, const_iterator last) iterator insert(const_iterator pos, const_iterator first, const_iterator last)
{ {
// insert only works for arrays // 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()))); JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
} }
@ -5682,7 +5682,7 @@ class basic_json
iterator insert(const_iterator pos, initializer_list_t ilist) iterator insert(const_iterator pos, initializer_list_t ilist)
{ {
// insert only works for arrays // 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()))); JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
} }
@ -5723,7 +5723,7 @@ class basic_json
void insert(const_iterator first, const_iterator last) void insert(const_iterator first, const_iterator last)
{ {
// insert only works for objects // 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()))); JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
} }
@ -5735,7 +5735,7 @@ class basic_json
} }
// passed iterators must belong to objects // 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")); JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
} }
@ -5772,11 +5772,11 @@ class basic_json
assert_invariant(); 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()))); 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()))); JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
} }
@ -5823,7 +5823,7 @@ class basic_json
assert_invariant(); 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()))); JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
} }
@ -5835,8 +5835,8 @@ class basic_json
} }
// passed iterators must belong to objects // 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()
or not last.m_object->is_object())) || !last.m_object->is_object()))
{ {
JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects")); JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
} }
@ -5865,9 +5865,9 @@ class basic_json
@since version 1.0.0 @since version 1.0.0
*/ */
void swap(reference other) noexcept ( void swap(reference other) noexcept (
std::is_nothrow_move_constructible<value_t>::value and std::is_nothrow_move_constructible<value_t>::value&&
std::is_nothrow_move_assignable<value_t>::value and std::is_nothrow_move_assignable<value_t>::value&&
std::is_nothrow_move_constructible<json_value>::value and std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value std::is_nothrow_move_assignable<json_value>::value
) )
{ {
@ -5895,9 +5895,9 @@ class basic_json
@since version 1.0.0 @since version 1.0.0
*/ */
friend void swap(reference left, reference right) noexcept ( friend void swap(reference left, reference right) noexcept (
std::is_nothrow_move_constructible<value_t>::value and std::is_nothrow_move_constructible<value_t>::value&&
std::is_nothrow_move_assignable<value_t>::value and std::is_nothrow_move_assignable<value_t>::value&&
std::is_nothrow_move_constructible<json_value>::value and std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value std::is_nothrow_move_assignable<json_value>::value
) )
{ {
@ -6155,27 +6155,27 @@ class basic_json
return false; 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; 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); 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; 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); 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; 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); return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
} }
@ -6225,7 +6225,7 @@ class basic_json
*/ */
friend bool operator!=(const_reference lhs, const_reference rhs) noexcept friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
{ {
return not (lhs == rhs); return !(lhs == rhs);
} }
/*! /*!
@ -6318,27 +6318,27 @@ class basic_json
return false; 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; 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); 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; 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); 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); 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; return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
} }
@ -6392,7 +6392,7 @@ class basic_json
*/ */
friend bool operator<=(const_reference lhs, const_reference rhs) noexcept friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
{ {
return not (rhs < lhs); return !(rhs < lhs);
} }
/*! /*!
@ -6438,7 +6438,7 @@ class basic_json
*/ */
friend bool operator>(const_reference lhs, const_reference rhs) noexcept friend bool operator>(const_reference lhs, const_reference rhs) noexcept
{ {
return not (lhs <= rhs); return !(lhs <= rhs);
} }
/*! /*!
@ -6484,7 +6484,7 @@ class basic_json
*/ */
friend bool operator>=(const_reference lhs, const_reference rhs) noexcept friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
{ {
return not (lhs < rhs); return !(lhs < rhs);
} }
/*! /*!
@ -8291,7 +8291,7 @@ class basic_json
}; };
// type check: top level value must be an array // 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")); JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
} }
@ -8317,7 +8317,7 @@ class basic_json
} }
// check if result is of type string // 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 + "'")); JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
} }
@ -8327,7 +8327,7 @@ class basic_json
}; };
// type check: every element of the array must be an object // 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")); JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
} }
@ -8405,7 +8405,7 @@ class basic_json
} }
// throw an exception if test fails // 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())); JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
} }
@ -8487,7 +8487,7 @@ class basic_json
{ {
// first pass: traverse common elements // first pass: traverse common elements
std::size_t i = 0; 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 // recursive call to compare array values at index i
auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i)); auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
@ -8638,7 +8638,7 @@ class basic_json
{ {
if (apply_patch.is_object()) if (apply_patch.is_object())
{ {
if (not is_object()) if (!is_object())
{ {
*this = object(); *this = object();
} }
@ -8731,7 +8731,7 @@ struct less<::nlohmann::detail::value_t>
*/ */
template<> template<>
inline void swap<nlohmann::json>(nlohmann::json& j1, nlohmann::json& j2) noexcept( 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 is_nothrow_move_assignable<nlohmann::json>::value
) )
{ {

13
include/nlohmann/json_fwd.hpp
View File

@ -60,6 +60,19 @@ uses the standard template types.
@since version 1.0.0 @since version 1.0.0
*/ */
using json = basic_json<>; 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 } // namespace nlohmann
#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_ #endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_

71
include/nlohmann/ordered_map.hpp Normal file
View File

@ -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

1329
single_include/nlohmann/json.hpp
View File

File diff suppressed because it is too large Load Diff

1
test/CMakeLists.txt
View File

@ -125,6 +125,7 @@ set(files
src/unit-modifiers.cpp src/unit-modifiers.cpp
src/unit-msgpack.cpp src/unit-msgpack.cpp
src/unit-noexcept.cpp src/unit-noexcept.cpp
src/unit-ordered_json.cpp
src/unit-pointer_access.cpp src/unit-pointer_access.cpp
src/unit-readme.cpp src/unit-readme.cpp
src/unit-reference_access.cpp src/unit-reference_access.cpp

8
test/src/unit-algorithms.cpp
View File

@ -55,7 +55,7 @@ TEST_CASE("algorithms")
{ {
CHECK(std::any_of(j_array.begin(), j_array.end(), [](const json & value) 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) 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_array.begin(), j_array.end(), j_array.begin()));
CHECK(std::equal(j_object.begin(), j_object.end(), j_object.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") SECTION("using user-defined comparison")
{ {
// compare objects only by size of its elements // 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"}; 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(), CHECK(std::equal(j_array.begin(), j_array.end(), j_array2.begin(),
[](const json & a, const json & b) [](const json & a, const json & b)
{ {
@ -213,7 +213,7 @@ TEST_CASE("algorithms")
return v.is_string(); return v.is_string();
}); });
CHECK(std::distance(j_array.begin(), it) == 2); CHECK(std::distance(j_array.begin(), it) == 2);
CHECK(not it[2].is_string()); CHECK(!it[2].is_string());
} }
} }

2
test/src/unit-assert_macro.cpp
View File

@ -44,7 +44,7 @@ static int assert_counter;
using nlohmann::json; using nlohmann::json;
// the test assumes exceptions to work // the test assumes exceptions to work
#if not defined(JSON_NOEXCEPTION) #if !defined(JSON_NOEXCEPTION)
TEST_CASE("JSON_ASSERT(x)") TEST_CASE("JSON_ASSERT(x)")
{ {
SECTION("basic_json(first, second)") SECTION("basic_json(first, second)")

14
test/src/unit-bson.cpp
View File

@ -766,7 +766,7 @@ TEST_CASE("Incomplete BSON Input")
CHECK(json::from_bson(incomplete_bson, true, false).is_discarded()); CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
SaxCountdown scp(0); 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") SECTION("Incomplete BSON Input 2")
@ -784,7 +784,7 @@ TEST_CASE("Incomplete BSON Input")
CHECK(json::from_bson(incomplete_bson, true, false).is_discarded()); CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
SaxCountdown scp(0); 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") SECTION("Incomplete BSON Input 3")
@ -808,7 +808,7 @@ TEST_CASE("Incomplete BSON Input")
CHECK(json::from_bson(incomplete_bson, true, false).is_discarded()); CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
SaxCountdown scp(1); 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") SECTION("Incomplete BSON Input 4")
@ -825,7 +825,7 @@ TEST_CASE("Incomplete BSON Input")
CHECK(json::from_bson(incomplete_bson, true, false).is_discarded()); CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
SaxCountdown scp(0); 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") SECTION("Improve coverage")
@ -835,7 +835,7 @@ TEST_CASE("Incomplete BSON Input")
json j = {{"key", "value"}}; json j = {{"key", "value"}};
auto bson_vec = json::to_bson(j); auto bson_vec = json::to_bson(j);
SaxCountdown scp(2); 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") SECTION("array")
@ -846,7 +846,7 @@ TEST_CASE("Incomplete BSON Input")
}; };
auto bson_vec = json::to_bson(j); auto bson_vec = json::to_bson(j);
SaxCountdown scp(2); 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 +887,7 @@ TEST_CASE("Unsupported BSON input")
CHECK(json::from_bson(bson, true, false).is_discarded()); CHECK(json::from_bson(bson, true, false).is_discarded());
SaxCountdown scp(0); 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") TEST_CASE("BSON numerical data")

14
test/src/unit-cbor.cpp
View File

@ -1077,7 +1077,7 @@ TEST_CASE("CBOR")
{ {
json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c, 0x00})); 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(not std::isfinite(d)); CHECK(!std::isfinite(d));
CHECK(j.dump() == "null"); CHECK(j.dump() == "null");
} }
@ -1869,7 +1869,7 @@ TEST_CASE("CBOR")
{ {
const auto result = json::from_cbor(vec, false); const auto result = json::from_cbor(vec, false);
CHECK(result == json()); 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") SECTION("strict mode")
@ -1889,21 +1889,21 @@ TEST_CASE("CBOR")
{ {
std::vector<uint8_t> v = {0x83, 0x01, 0x02, 0x03}; std::vector<uint8_t> v = {0x83, 0x01, 0x02, 0x03};
SaxCountdown scp(0); 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)") SECTION("start_object(len)")
{ {
std::vector<uint8_t> v = {0xA1, 0x63, 0x66, 0x6F, 0x6F, 0xF4}; std::vector<uint8_t> v = {0xA1, 0x63, 0x66, 0x6F, 0x6F, 0xF4};
SaxCountdown scp(0); 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()") SECTION("key()")
{ {
std::vector<uint8_t> v = {0xA1, 0x63, 0x66, 0x6F, 0x6F, 0xF4}; std::vector<uint8_t> v = {0xA1, 0x63, 0x66, 0x6F, 0x6F, 0xF4};
SaxCountdown scp(1); 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));
} }
} }
} }
@ -1954,7 +1954,7 @@ TEST_CASE("single CBOR roundtrip")
} }
} }
#if not defined(JSON_NOEXCEPTION) #if !defined(JSON_NOEXCEPTION)
TEST_CASE("CBOR regressions") TEST_CASE("CBOR regressions")
{ {
SECTION("fuzz test results") SECTION("fuzz test results")
@ -2274,7 +2274,7 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
} }
} }
#if not defined(JSON_NOEXCEPTION) #if !defined(JSON_NOEXCEPTION)
TEST_CASE("all CBOR first bytes") TEST_CASE("all CBOR first bytes")
{ {
// these bytes will fail immediately with exception parse_error.112 // these bytes will fail immediately with exception parse_error.112

12
test/src/unit-class_const_iterator.cpp
View File

@ -224,7 +224,7 @@ TEST_CASE("const_iterator class")
json::const_iterator it = j.cbegin(); json::const_iterator it = j.cbegin();
CHECK((it.m_it.primitive_iterator.m_it == 1)); CHECK((it.m_it.primitive_iterator.m_it == 1));
it++; 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") SECTION("number")
@ -235,7 +235,7 @@ TEST_CASE("const_iterator class")
it++; it++;
CHECK((it.m_it.primitive_iterator.m_it == 1)); CHECK((it.m_it.primitive_iterator.m_it == 1));
it++; 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") SECTION("object")
@ -275,7 +275,7 @@ TEST_CASE("const_iterator class")
json::const_iterator it = j.cbegin(); json::const_iterator it = j.cbegin();
CHECK((it.m_it.primitive_iterator.m_it == 1)); CHECK((it.m_it.primitive_iterator.m_it == 1));
++it; ++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") SECTION("number")
@ -286,7 +286,7 @@ TEST_CASE("const_iterator class")
++it; ++it;
CHECK((it.m_it.primitive_iterator.m_it == 1)); CHECK((it.m_it.primitive_iterator.m_it == 1));
++it; ++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") SECTION("object")
@ -335,7 +335,7 @@ TEST_CASE("const_iterator class")
it--; it--;
CHECK((it.m_it.primitive_iterator.m_it == 0)); CHECK((it.m_it.primitive_iterator.m_it == 0));
it--; 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") SECTION("object")
@ -384,7 +384,7 @@ TEST_CASE("const_iterator class")
--it; --it;
CHECK((it.m_it.primitive_iterator.m_it == 0)); CHECK((it.m_it.primitive_iterator.m_it == 0));
--it; --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") SECTION("object")

12
test/src/unit-class_iterator.cpp
View File

@ -208,7 +208,7 @@ TEST_CASE("iterator class")
json::iterator it = j.begin(); json::iterator it = j.begin();
CHECK((it.m_it.primitive_iterator.m_it == 1)); CHECK((it.m_it.primitive_iterator.m_it == 1));
it++; 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") SECTION("number")
@ -219,7 +219,7 @@ TEST_CASE("iterator class")
it++; it++;
CHECK((it.m_it.primitive_iterator.m_it == 1)); CHECK((it.m_it.primitive_iterator.m_it == 1));
it++; 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") SECTION("object")
@ -259,7 +259,7 @@ TEST_CASE("iterator class")
json::iterator it = j.begin(); json::iterator it = j.begin();
CHECK((it.m_it.primitive_iterator.m_it == 1)); CHECK((it.m_it.primitive_iterator.m_it == 1));
++it; ++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") SECTION("number")
@ -270,7 +270,7 @@ TEST_CASE("iterator class")
++it; ++it;
CHECK((it.m_it.primitive_iterator.m_it == 1)); CHECK((it.m_it.primitive_iterator.m_it == 1));
++it; ++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") SECTION("object")
@ -319,7 +319,7 @@ TEST_CASE("iterator class")
it--; it--;
CHECK((it.m_it.primitive_iterator.m_it == 0)); CHECK((it.m_it.primitive_iterator.m_it == 0));
it--; 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") SECTION("object")
@ -368,7 +368,7 @@ TEST_CASE("iterator class")
--it; --it;
CHECK((it.m_it.primitive_iterator.m_it == 0)); CHECK((it.m_it.primitive_iterator.m_it == 0));
--it; --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") SECTION("object")

16
test/src/unit-class_parser.cpp
View File

@ -254,7 +254,7 @@ bool accept_helper(const std::string& s)
// 1. parse s without exceptions // 1. parse s without exceptions
json j; json j;
CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter(s), nullptr, false).parse(true, 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 // 2. accept s
const bool ok_accept = json::parser(nlohmann::detail::input_adapter(s)).accept(true); const bool ok_accept = json::parser(nlohmann::detail::input_adapter(s)).accept(true);
@ -265,7 +265,7 @@ bool accept_helper(const std::string& s)
// 4. parse with SAX (compare with relaxed accept result) // 4. parse with SAX (compare with relaxed accept result)
SaxEventLogger el; SaxEventLogger el;
CHECK_NOTHROW(json::sax_parse(s, &el, json::input_format_t::json, false)); 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 // 5. parse with simple callback
json::parser_callback_t cb = [](int, json::parse_event_t, json&) json::parser_callback_t cb = [](int, json::parse_event_t, json&)
@ -273,7 +273,7 @@ bool accept_helper(const std::string& s)
return true; return true;
}; };
json j_cb = json::parse(s, cb, false); 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 // 6. check if this approach came to the same result
CHECK(ok_noexcept == ok_noexcept_cb); CHECK(ok_noexcept == ok_noexcept_cb);
@ -314,7 +314,7 @@ void comments_helper(const std::string& s)
{ {
CAPTURE(json_with_comment) CAPTURE(json_with_comment)
CHECK_THROWS_AS(_ = json::parse(json_with_comment), json::parse_error); CHECK_THROWS_AS(_ = json::parse(json_with_comment), json::parse_error);
CHECK(not json::accept(json_with_comment)); CHECK(!json::accept(json_with_comment));
CHECK_NOTHROW(_ = json::parse(json_with_comment, nullptr, true, true)); CHECK_NOTHROW(_ = json::parse(json_with_comment, nullptr, true, true));
CHECK(json::accept(json_with_comment, true)); CHECK(json::accept(json_with_comment, true));
@ -941,7 +941,7 @@ TEST_CASE("parser class")
SECTION("overflow") SECTION("overflow")
{ {
// overflows during parsing // overflows during parsing
CHECK(not accept_helper("1.18973e+4932")); CHECK(!accept_helper("1.18973e+4932"));
} }
SECTION("invalid numbers") SECTION("invalid numbers")
@ -1616,7 +1616,7 @@ TEST_CASE("parser class")
{ {
json j_filtered1 = json::parse(structured_array, [](int, json::parse_event_t e, const json & parsed) 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; return false;
} }
@ -1655,7 +1655,7 @@ TEST_CASE("parser class")
json j_object = json::parse(s_object, [](int, json::parse_event_t e, const json&) json j_object = json::parse(s_object, [](int, json::parse_event_t e, const json&)
{ {
static bool first = true; 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; first = false;
return false; return false;
@ -1674,7 +1674,7 @@ TEST_CASE("parser class")
json j_array = json::parse(s_array, [](int, json::parse_event_t e, const json&) json j_array = json::parse(s_array, [](int, json::parse_event_t e, const json&)
{ {
static bool first = true; 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; first = false;
return false; return false;

10
test/src/unit-comparison.cpp
View File

@ -165,7 +165,7 @@ TEST_CASE("lexicographical comparison operators")
CAPTURE(i) CAPTURE(i)
CAPTURE(j) CAPTURE(j)
// check definition // 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; json j_null;
CHECK( (j_null != nullptr) == false); CHECK( (j_null != nullptr) == false);
CHECK( (nullptr != j_null) == false); CHECK( (nullptr != j_null) == false);
CHECK( (j_null != nullptr) == not(j_null == nullptr)); CHECK( (j_null != nullptr) == !(j_null == nullptr));
CHECK( (nullptr != j_null) == not(nullptr == j_null)); CHECK( (nullptr != j_null) == !(nullptr == j_null));
} }
SECTION("comparison: less") SECTION("comparison: less")
@ -234,7 +234,7 @@ TEST_CASE("lexicographical comparison operators")
CAPTURE(i) CAPTURE(i)
CAPTURE(j) CAPTURE(j)
// check definition // 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(i)
CAPTURE(j) CAPTURE(j)
// check definition // 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]) );
} }
} }
} }

2
test/src/unit-constructor1.cpp
View File

@ -847,7 +847,7 @@ TEST_CASE("constructors")
// check round trip of NaN // check round trip of NaN
json::number_float_t d = j; json::number_float_t d = j;
CHECK((std::isnan(d) and std::isnan(n)) == true); CHECK((std::isnan(d) && std::isnan(n)) == true);
// check that NaN is serialized to null // check that NaN is serialized to null
CHECK(j.dump() == "null"); CHECK(j.dump() == "null");

2
test/src/unit-conversions.cpp
View File

@ -272,7 +272,7 @@ TEST_CASE("value conversion")
json(json::value_t::null).get<std::vector<json>>(), json(json::value_t::null).get<std::vector<json>>(),
"[json.exception.type_error.302] type must be array, but is null"); "[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") SECTION("reserve is called on containers that supports it")
{ {
// make sure all values are properly copied // make sure all values are properly copied

94
test/src/unit-deserialization.cpp
View File

@ -289,14 +289,14 @@ TEST_CASE("deserialization")
CHECK_THROWS_AS(_ = json::parse(ss1), json::parse_error&); CHECK_THROWS_AS(_ = json::parse(ss1), json::parse_error&);
CHECK_THROWS_WITH(_ = json::parse(ss2), 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 ']'"); "[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; json j_error;
CHECK_NOTHROW(j_error = json::parse(ss4, nullptr, false)); CHECK_NOTHROW(j_error = json::parse(ss4, nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; SaxEventLogger l;
CHECK(not json::sax_parse(ss5, &l)); CHECK(!json::sax_parse(ss5, &l));
CHECK(l.events.size() == 11); CHECK(l.events.size() == 11);
CHECK(l.events == std::vector<std::string>( 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_AS(_ = json::parse(s), json::parse_error&);
CHECK_THROWS_WITH(_ = json::parse(s), 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 ']'"); "[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; json j_error;
CHECK_NOTHROW(j_error = json::parse(s, nullptr, false)); CHECK_NOTHROW(j_error = json::parse(s, nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; SaxEventLogger l;
CHECK(not json::sax_parse(s, &l)); CHECK(!json::sax_parse(s, &l));
CHECK(l.events.size() == 11); CHECK(l.events.size() == 11);
CHECK(l.events == std::vector<std::string>( CHECK(l.events == std::vector<std::string>(
{ {
@ -450,10 +450,10 @@ TEST_CASE("deserialization")
std::vector<uint8_t> v; std::vector<uint8_t> v;
json _; json _;
CHECK_THROWS_AS(_ = json::parse(v), json::parse_error&); CHECK_THROWS_AS(_ = json::parse(v), json::parse_error&);
CHECK(not json::accept(v)); CHECK(!json::accept(v));
SaxEventLogger l; SaxEventLogger l;
CHECK(not json::sax_parse(v, &l)); CHECK(!json::sax_parse(v, &l));
CHECK(l.events.size() == 1); CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(1)"})); CHECK(l.events == std::vector<std::string>({"parse_error(1)"}));
} }
@ -538,10 +538,10 @@ TEST_CASE("deserialization")
{ {
std::vector<uint8_t> v; std::vector<uint8_t> v;
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&); 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; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(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'}; 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_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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(10)"})); 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'}; 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_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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(11)"})); 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'}; 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_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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(18)"})); 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', '\\'}; 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_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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(18)"})); CHECK(l.events == std::vector<std::string>({"parse_error(18)"}));
} }
@ -618,14 +618,14 @@ TEST_CASE("deserialization")
{ {
uint8_t v[] = {'\"', 0x7F, 0xC1}; uint8_t v[] = {'\"', 0x7F, 0xC1};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&); 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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(3)"})); 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_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
CHECK_THROWS_WITH(_ = json::parse(std::begin(v), std::end(v)), 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'"); "[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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"})); CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
} }
@ -653,14 +653,14 @@ TEST_CASE("deserialization")
{ {
uint8_t v[] = {'\"', 0x7F, 0xDF, 0xC0}; uint8_t v[] = {'\"', 0x7F, 0xDF, 0xC0};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&); 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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"})); CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
} }
@ -669,14 +669,14 @@ TEST_CASE("deserialization")
{ {
uint8_t v[] = {'\"', 0x7F, 0xE0, 0x9F}; uint8_t v[] = {'\"', 0x7F, 0xE0, 0x9F};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&); 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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"})); CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
} }
@ -685,14 +685,14 @@ TEST_CASE("deserialization")
{ {
uint8_t v[] = {'\"', 0x7F, 0xEF, 0xC0}; uint8_t v[] = {'\"', 0x7F, 0xEF, 0xC0};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&); 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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"})); CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
} }
@ -701,14 +701,14 @@ TEST_CASE("deserialization")
{ {
uint8_t v[] = {'\"', 0x7F, 0xED, 0x7F}; uint8_t v[] = {'\"', 0x7F, 0xED, 0x7F};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&); 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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"})); CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
} }
@ -717,14 +717,14 @@ TEST_CASE("deserialization")
{ {
uint8_t v[] = {'\"', 0x7F, 0xF0, 0x8F}; uint8_t v[] = {'\"', 0x7F, 0xF0, 0x8F};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&); 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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"})); CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
} }
@ -733,14 +733,14 @@ TEST_CASE("deserialization")
{ {
uint8_t v[] = {'\"', 0x7F, 0xF0, 0xC0}; uint8_t v[] = {'\"', 0x7F, 0xF0, 0xC0};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&); 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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"})); CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
} }
@ -749,14 +749,14 @@ TEST_CASE("deserialization")
{ {
uint8_t v[] = {'\"', 0x7F, 0xF3, 0x7F}; uint8_t v[] = {'\"', 0x7F, 0xF3, 0x7F};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&); 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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"})); CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
} }
@ -765,14 +765,14 @@ TEST_CASE("deserialization")
{ {
uint8_t v[] = {'\"', 0x7F, 0xF3, 0xC0}; uint8_t v[] = {'\"', 0x7F, 0xF3, 0xC0};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&); 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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"})); CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
} }
@ -781,14 +781,14 @@ TEST_CASE("deserialization")
{ {
uint8_t v[] = {'\"', 0x7F, 0xF4, 0x7F}; uint8_t v[] = {'\"', 0x7F, 0xF4, 0x7F};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&); 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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 1);
CHECK(l.events == std::vector<std::string>({"parse_error(4)"})); CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
} }
@ -797,14 +797,14 @@ TEST_CASE("deserialization")
{ {
uint8_t v[] = {'{', '\"', '\"', ':', '1', '1'}; uint8_t v[] = {'{', '\"', '\"', ':', '1', '1'};
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&); 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; json j_error;
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false)); CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
CHECK(j_error.is_discarded()); CHECK(j_error.is_discarded());
SaxEventLogger l; 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.size() == 4);
CHECK(l.events == std::vector<std::string>( 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"); "[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; SaxEventLogger l;
CHECK(not json::sax_parse(bom, &l)); CHECK(!json::sax_parse(bom, &l));
CHECK(l.events.size() == 1); CHECK(l.events.size() == 1);
CHECK(l.events == std::vector<std::string>( 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'"); "[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; SaxEventLogger l1, l2;
CHECK(not json::sax_parse(std::istringstream(bom.substr(0, 2)), &l1)); CHECK(!json::sax_parse(std::istringstream(bom.substr(0, 2)), &l1));
CHECK(not json::sax_parse(bom.substr(0, 2), &l2)); CHECK(!json::sax_parse(bom.substr(0, 2), &l2));
CHECK(l1.events.size() == 1); CHECK(l1.events.size() == 1);
CHECK(l1.events == std::vector<std::string>( 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'"); "[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; SaxEventLogger l1, l2;
CHECK(not json::sax_parse(std::istringstream(bom.substr(0, 1)), &l1)); CHECK(!json::sax_parse(std::istringstream(bom.substr(0, 1)), &l1));
CHECK(not json::sax_parse(bom.substr(0, 1), &l2)); CHECK(!json::sax_parse(bom.substr(0, 1), &l2));
CHECK(l1.events.size() == 1); CHECK(l1.events.size() == 1);
CHECK(l1.events == std::vector<std::string>( 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[1] + i1));
s.push_back(static_cast<char>(bom[2] + i2)); 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 // without any variation, we skip the BOM
CHECK(json::parse(s + "null") == json()); 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&); CHECK_THROWS_AS(_ = json::parse(std::istringstream(s + "null")), json::parse_error&);
SaxEventLogger l; SaxEventLogger l;
CHECK(not json::sax_parse(s + "null", &l)); CHECK(!json::sax_parse(s + "null", &l));
CHECK(l.events.size() == 1); CHECK(l.events.size() == 1);
if (i0 != 0) if (i0 != 0)

2
test/src/unit-element_access2.cpp
View File

@ -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)") TEST_CASE("element access 2 (throwing tests)")
{ {
SECTION("object") SECTION("object")

214
test/src/unit-inspection.cpp
View File

@ -43,36 +43,36 @@ TEST_CASE("object inspection")
SECTION("object") SECTION("object")
{ {
json j {{"foo", 1}, {"bar", false}}; json j {{"foo", 1}, {"bar", false}};
CHECK(not j.is_null()); CHECK(!j.is_null());
CHECK(not j.is_boolean()); CHECK(!j.is_boolean());
CHECK(not j.is_number()); CHECK(!j.is_number());
CHECK(not j.is_number_integer()); CHECK(!j.is_number_integer());
CHECK(not j.is_number_unsigned()); CHECK(!j.is_number_unsigned());
CHECK(not j.is_number_float()); CHECK(!j.is_number_float());
CHECK(not j.is_binary()); CHECK(!j.is_binary());
CHECK(j.is_object()); CHECK(j.is_object());
CHECK(not j.is_array()); CHECK(!j.is_array());
CHECK(not j.is_string()); CHECK(!j.is_string());
CHECK(not j.is_discarded()); CHECK(!j.is_discarded());
CHECK(not j.is_primitive()); CHECK(!j.is_primitive());
CHECK(j.is_structured()); CHECK(j.is_structured());
} }
SECTION("array") SECTION("array")
{ {
json j {"foo", 1, 1u, 42.23, false}; json j {"foo", 1, 1u, 42.23, false};
CHECK(not j.is_null()); CHECK(!j.is_null());
CHECK(not j.is_boolean()); CHECK(!j.is_boolean());
CHECK(not j.is_number()); CHECK(!j.is_number());
CHECK(not j.is_number_integer()); CHECK(!j.is_number_integer());
CHECK(not j.is_number_unsigned()); CHECK(!j.is_number_unsigned());
CHECK(not j.is_number_float()); CHECK(!j.is_number_float());
CHECK(not j.is_binary()); CHECK(!j.is_binary());
CHECK(not j.is_object()); CHECK(!j.is_object());
CHECK(j.is_array()); CHECK(j.is_array());
CHECK(not j.is_string()); CHECK(!j.is_string());
CHECK(not j.is_discarded()); CHECK(!j.is_discarded());
CHECK(not j.is_primitive()); CHECK(!j.is_primitive());
CHECK(j.is_structured()); CHECK(j.is_structured());
} }
@ -80,144 +80,144 @@ TEST_CASE("object inspection")
{ {
json j(nullptr); json j(nullptr);
CHECK(j.is_null()); CHECK(j.is_null());
CHECK(not j.is_boolean()); CHECK(!j.is_boolean());
CHECK(not j.is_number()); CHECK(!j.is_number());
CHECK(not j.is_number_integer()); CHECK(!j.is_number_integer());
CHECK(not j.is_number_unsigned()); CHECK(!j.is_number_unsigned());
CHECK(not j.is_number_float()); CHECK(!j.is_number_float());
CHECK(not j.is_binary()); CHECK(!j.is_binary());
CHECK(not j.is_object()); CHECK(!j.is_object());
CHECK(not j.is_array()); CHECK(!j.is_array());
CHECK(not j.is_string()); CHECK(!j.is_string());
CHECK(not j.is_discarded()); CHECK(!j.is_discarded());
CHECK(j.is_primitive()); CHECK(j.is_primitive());
CHECK(not j.is_structured()); CHECK(!j.is_structured());
} }
SECTION("boolean") SECTION("boolean")
{ {
json j(true); json j(true);
CHECK(not j.is_null()); CHECK(!j.is_null());
CHECK(j.is_boolean()); CHECK(j.is_boolean());
CHECK(not j.is_number()); CHECK(!j.is_number());
CHECK(not j.is_number_integer()); CHECK(!j.is_number_integer());
CHECK(not j.is_number_unsigned()); CHECK(!j.is_number_unsigned());
CHECK(not j.is_number_float()); CHECK(!j.is_number_float());
CHECK(not j.is_binary()); CHECK(!j.is_binary());
CHECK(not j.is_object()); CHECK(!j.is_object());
CHECK(not j.is_array()); CHECK(!j.is_array());
CHECK(not j.is_string()); CHECK(!j.is_string());
CHECK(not j.is_discarded()); CHECK(!j.is_discarded());
CHECK(j.is_primitive()); CHECK(j.is_primitive());
CHECK(not j.is_structured()); CHECK(!j.is_structured());
} }
SECTION("string") SECTION("string")
{ {
json j("Hello world"); json j("Hello world");
CHECK(not j.is_null()); CHECK(!j.is_null());
CHECK(not j.is_boolean()); CHECK(!j.is_boolean());
CHECK(not j.is_number()); CHECK(!j.is_number());
CHECK(not j.is_number_integer()); CHECK(!j.is_number_integer());
CHECK(not j.is_number_unsigned()); CHECK(!j.is_number_unsigned());
CHECK(not j.is_number_float()); CHECK(!j.is_number_float());
CHECK(not j.is_binary()); CHECK(!j.is_binary());
CHECK(not j.is_object()); CHECK(!j.is_object());
CHECK(not j.is_array()); CHECK(!j.is_array());
CHECK(j.is_string()); CHECK(j.is_string());
CHECK(not j.is_discarded()); CHECK(!j.is_discarded());
CHECK(j.is_primitive()); CHECK(j.is_primitive());
CHECK(not j.is_structured()); CHECK(!j.is_structured());
} }
SECTION("number (integer)") SECTION("number (integer)")
{ {
json j(42); json j(42);
CHECK(not j.is_null()); CHECK(!j.is_null());
CHECK(not j.is_boolean()); CHECK(!j.is_boolean());
CHECK(j.is_number()); CHECK(j.is_number());
CHECK(j.is_number_integer()); CHECK(j.is_number_integer());
CHECK(not j.is_number_unsigned()); CHECK(!j.is_number_unsigned());
CHECK(not j.is_number_float()); CHECK(!j.is_number_float());
CHECK(not j.is_binary()); CHECK(!j.is_binary());
CHECK(not j.is_object()); CHECK(!j.is_object());
CHECK(not j.is_array()); CHECK(!j.is_array());
CHECK(not j.is_string()); CHECK(!j.is_string());
CHECK(not j.is_discarded()); CHECK(!j.is_discarded());
CHECK(j.is_primitive()); CHECK(j.is_primitive());
CHECK(not j.is_structured()); CHECK(!j.is_structured());
} }
SECTION("number (unsigned)") SECTION("number (unsigned)")
{ {
json j(42u); json j(42u);
CHECK(not j.is_null()); CHECK(!j.is_null());
CHECK(not j.is_boolean()); CHECK(!j.is_boolean());
CHECK(j.is_number()); CHECK(j.is_number());
CHECK(j.is_number_integer()); CHECK(j.is_number_integer());
CHECK(j.is_number_unsigned()); CHECK(j.is_number_unsigned());
CHECK(not j.is_number_float()); CHECK(!j.is_number_float());
CHECK(not j.is_binary()); CHECK(!j.is_binary());
CHECK(not j.is_object()); CHECK(!j.is_object());
CHECK(not j.is_array()); CHECK(!j.is_array());
CHECK(not j.is_string()); CHECK(!j.is_string());
CHECK(not j.is_discarded()); CHECK(!j.is_discarded());
CHECK(j.is_primitive()); CHECK(j.is_primitive());
CHECK(not j.is_structured()); CHECK(!j.is_structured());
} }
SECTION("number (floating-point)") SECTION("number (floating-point)")
{ {
json j(42.23); json j(42.23);
CHECK(not j.is_null()); CHECK(!j.is_null());
CHECK(not j.is_boolean()); CHECK(!j.is_boolean());
CHECK(j.is_number()); CHECK(j.is_number());
CHECK(not j.is_number_integer()); CHECK(!j.is_number_integer());
CHECK(not j.is_number_unsigned()); CHECK(!j.is_number_unsigned());
CHECK(j.is_number_float()); CHECK(j.is_number_float());
CHECK(not j.is_binary()); CHECK(!j.is_binary());
CHECK(not j.is_object()); CHECK(!j.is_object());
CHECK(not j.is_array()); CHECK(!j.is_array());
CHECK(not j.is_string()); CHECK(!j.is_string());
CHECK(not j.is_discarded()); CHECK(!j.is_discarded());
CHECK(j.is_primitive()); CHECK(j.is_primitive());
CHECK(not j.is_structured()); CHECK(!j.is_structured());
} }
SECTION("binary") SECTION("binary")
{ {
json j(json::value_t::binary); json j(json::value_t::binary);
CHECK(not j.is_null()); CHECK(!j.is_null());
CHECK(not j.is_boolean()); CHECK(!j.is_boolean());
CHECK(not j.is_number()); CHECK(!j.is_number());
CHECK(not j.is_number_integer()); CHECK(!j.is_number_integer());
CHECK(not j.is_number_unsigned()); CHECK(!j.is_number_unsigned());
CHECK(not j.is_number_float()); CHECK(!j.is_number_float());
CHECK(j.is_binary()); CHECK(j.is_binary());
CHECK(not j.is_object()); CHECK(!j.is_object());
CHECK(not j.is_array()); CHECK(!j.is_array());
CHECK(not j.is_string()); CHECK(!j.is_string());
CHECK(not j.is_discarded()); CHECK(!j.is_discarded());
CHECK(j.is_primitive()); CHECK(j.is_primitive());
CHECK(not j.is_structured()); CHECK(!j.is_structured());
} }
SECTION("discarded") SECTION("discarded")
{ {
json j(json::value_t::discarded); json j(json::value_t::discarded);
CHECK(not j.is_null()); CHECK(!j.is_null());
CHECK(not j.is_boolean()); CHECK(!j.is_boolean());
CHECK(not j.is_number()); CHECK(!j.is_number());
CHECK(not j.is_number_integer()); CHECK(!j.is_number_integer());
CHECK(not j.is_number_unsigned()); CHECK(!j.is_number_unsigned());
CHECK(not j.is_number_float()); CHECK(!j.is_number_float());
CHECK(not j.is_binary()); CHECK(!j.is_binary());
CHECK(not j.is_object()); CHECK(!j.is_object());
CHECK(not j.is_array()); CHECK(!j.is_array());
CHECK(not j.is_string()); CHECK(!j.is_string());
CHECK(j.is_discarded()); CHECK(j.is_discarded());
CHECK(not j.is_primitive()); CHECK(!j.is_primitive());
CHECK(not j.is_structured()); CHECK(!j.is_structured());
} }
} }

6
test/src/unit-iterators1.cpp
View File

@ -231,12 +231,12 @@ TEST_CASE("iterators 1")
{ {
SECTION("!(begin != begin)") SECTION("!(begin != begin)")
{ {
CHECK(not(j.begin() != j.begin())); CHECK(!(j.begin() != j.begin()));
} }
SECTION("!(end != end)") SECTION("!(end != end)")
{ {
CHECK(not(j.end() != j.end())); CHECK(!(j.end() != j.end()));
} }
SECTION("begin < end") SECTION("begin < end")
@ -286,7 +286,7 @@ TEST_CASE("iterators 1")
SECTION("!(begin == end)") SECTION("!(begin == end)")
{ {
CHECK(not(j.begin() == j.end())); CHECK(!(j.begin() == j.end()));
} }
SECTION("begin != end") SECTION("begin != end")

128
test/src/unit-iterators2.cpp
View File

@ -56,26 +56,26 @@ TEST_CASE("iterators 2")
// comparison: equal // comparison: equal
{ {
CHECK(it1 == it1); CHECK(it1 == it1);
CHECK(not (it1 == it2)); CHECK(!(it1 == it2));
CHECK(not (it1 == it3)); CHECK(!(it1 == it3));
CHECK(not (it2 == it3)); CHECK(!(it2 == it3));
CHECK(it1_c == it1_c); CHECK(it1_c == it1_c);
CHECK(not (it1_c == it2_c)); CHECK(!(it1_c == it2_c));
CHECK(not (it1_c == it3_c)); CHECK(!(it1_c == it3_c));
CHECK(not (it2_c == it3_c)); CHECK(!(it2_c == it3_c));
} }
// comparison: not equal // comparison: not equal
{ {
// check definition // check definition
CHECK( (it1 != it1) == not(it1 == it1) ); CHECK( (it1 != it1) == !(it1 == it1) );
CHECK( (it1 != it2) == not(it1 == it2) ); CHECK( (it1 != it2) == !(it1 == it2) );
CHECK( (it1 != it3) == not(it1 == it3) ); CHECK( (it1 != it3) == !(it1 == it3) );
CHECK( (it2 != it3) == not(it2 == it3) ); CHECK( (it2 != it3) == !(it2 == it3) );
CHECK( (it1_c != it1_c) == not(it1_c == it1_c) ); CHECK( (it1_c != it1_c) == !(it1_c == it1_c) );
CHECK( (it1_c != it2_c) == not(it1_c == it2_c) ); CHECK( (it1_c != it2_c) == !(it1_c == it2_c) );
CHECK( (it1_c != it3_c) == not(it1_c == it3_c) ); CHECK( (it1_c != it3_c) == !(it1_c == it3_c) );
CHECK( (it2_c != it3_c) == not(it2_c == it3_c) ); CHECK( (it2_c != it3_c) == !(it2_c == it3_c) );
} }
// comparison: smaller // comparison: smaller
@ -101,11 +101,11 @@ TEST_CASE("iterators 2")
} }
else else
{ {
CHECK(not (it1 < it1)); CHECK(!(it1 < it1));
CHECK(it1 < it2); CHECK(it1 < it2);
CHECK(it1 < it3); CHECK(it1 < it3);
CHECK(it2 < it3); CHECK(it2 < it3);
CHECK(not (it1_c < it1_c)); CHECK(!(it1_c < it1_c));
CHECK(it1_c < it2_c); CHECK(it1_c < it2_c);
CHECK(it1_c < it3_c); CHECK(it1_c < it3_c);
CHECK(it2_c < it3_c); CHECK(it2_c < it3_c);
@ -136,14 +136,14 @@ TEST_CASE("iterators 2")
else else
{ {
// check definition // check definition
CHECK( (it1 <= it1) == not(it1 < it1) ); CHECK( (it1 <= it1) == !(it1 < it1) );
CHECK( (it1 <= it2) == not(it2 < it1) ); CHECK( (it1 <= it2) == !(it2 < it1) );
CHECK( (it1 <= it3) == not(it3 < it1) ); CHECK( (it1 <= it3) == !(it3 < it1) );
CHECK( (it2 <= it3) == not(it3 < it2) ); CHECK( (it2 <= it3) == !(it3 < it2) );
CHECK( (it1_c <= it1_c) == not(it1_c < it1_c) ); CHECK( (it1_c <= it1_c) == !(it1_c < it1_c) );
CHECK( (it1_c <= it2_c) == not(it2_c < it1_c) ); CHECK( (it1_c <= it2_c) == !(it2_c < it1_c) );
CHECK( (it1_c <= it3_c) == not(it3_c < it1_c) ); CHECK( (it1_c <= it3_c) == !(it3_c < it1_c) );
CHECK( (it2_c <= it3_c) == not(it3_c < it2_c) ); CHECK( (it2_c <= it3_c) == !(it3_c < it2_c) );
} }
} }
@ -206,14 +206,14 @@ TEST_CASE("iterators 2")
else else
{ {
// check definition // check definition
CHECK( (it1 >= it1) == not(it1 < it1) ); CHECK( (it1 >= it1) == !(it1 < it1) );
CHECK( (it1 >= it2) == not(it1 < it2) ); CHECK( (it1 >= it2) == !(it1 < it2) );
CHECK( (it1 >= it3) == not(it1 < it3) ); CHECK( (it1 >= it3) == !(it1 < it3) );
CHECK( (it2 >= it3) == not(it2 < it3) ); CHECK( (it2 >= it3) == !(it2 < it3) );
CHECK( (it1_c >= it1_c) == not(it1_c < it1_c) ); CHECK( (it1_c >= it1_c) == !(it1_c < it1_c) );
CHECK( (it1_c >= it2_c) == not(it1_c < it2_c) ); CHECK( (it1_c >= it2_c) == !(it1_c < it2_c) );
CHECK( (it1_c >= it3_c) == not(it1_c < it3_c) ); CHECK( (it1_c >= it3_c) == !(it1_c < it3_c) );
CHECK( (it2_c >= it3_c) == not(it2_c < it3_c) ); CHECK( (it2_c >= it3_c) == !(it2_c < it3_c) );
} }
} }
} }
@ -491,26 +491,26 @@ TEST_CASE("iterators 2")
// comparison: equal // comparison: equal
{ {
CHECK(it1 == it1); CHECK(it1 == it1);
CHECK(not (it1 == it2)); CHECK(!(it1 == it2));
CHECK(not (it1 == it3)); CHECK(!(it1 == it3));
CHECK(not (it2 == it3)); CHECK(!(it2 == it3));
CHECK(it1_c == it1_c); CHECK(it1_c == it1_c);
CHECK(not (it1_c == it2_c)); CHECK(!(it1_c == it2_c));
CHECK(not (it1_c == it3_c)); CHECK(!(it1_c == it3_c));
CHECK(not (it2_c == it3_c)); CHECK(!(it2_c == it3_c));
} }
// comparison: not equal // comparison: not equal
{ {
// check definition // check definition
CHECK( (it1 != it1) == not(it1 == it1) ); CHECK( (it1 != it1) == !(it1 == it1) );
CHECK( (it1 != it2) == not(it1 == it2) ); CHECK( (it1 != it2) == !(it1 == it2) );
CHECK( (it1 != it3) == not(it1 == it3) ); CHECK( (it1 != it3) == !(it1 == it3) );
CHECK( (it2 != it3) == not(it2 == it3) ); CHECK( (it2 != it3) == !(it2 == it3) );
CHECK( (it1_c != it1_c) == not(it1_c == it1_c) ); CHECK( (it1_c != it1_c) == !(it1_c == it1_c) );
CHECK( (it1_c != it2_c) == not(it1_c == it2_c) ); CHECK( (it1_c != it2_c) == !(it1_c == it2_c) );
CHECK( (it1_c != it3_c) == not(it1_c == it3_c) ); CHECK( (it1_c != it3_c) == !(it1_c == it3_c) );
CHECK( (it2_c != it3_c) == not(it2_c == it3_c) ); CHECK( (it2_c != it3_c) == !(it2_c == it3_c) );
} }
// comparison: smaller // comparison: smaller
@ -536,11 +536,11 @@ TEST_CASE("iterators 2")
} }
else else
{ {
CHECK(not (it1 < it1)); CHECK(!(it1 < it1));
CHECK(it1 < it2); CHECK(it1 < it2);
CHECK(it1 < it3); CHECK(it1 < it3);
CHECK(it2 < it3); CHECK(it2 < it3);
CHECK(not (it1_c < it1_c)); CHECK(!(it1_c < it1_c));
CHECK(it1_c < it2_c); CHECK(it1_c < it2_c);
CHECK(it1_c < it3_c); CHECK(it1_c < it3_c);
CHECK(it2_c < it3_c); CHECK(it2_c < it3_c);
@ -571,14 +571,14 @@ TEST_CASE("iterators 2")
else else
{ {
// check definition // check definition
CHECK( (it1 <= it1) == not(it1 < it1) ); CHECK( (it1 <= it1) == !(it1 < it1) );
CHECK( (it1 <= it2) == not(it2 < it1) ); CHECK( (it1 <= it2) == !(it2 < it1) );
CHECK( (it1 <= it3) == not(it3 < it1) ); CHECK( (it1 <= it3) == !(it3 < it1) );
CHECK( (it2 <= it3) == not(it3 < it2) ); CHECK( (it2 <= it3) == !(it3 < it2) );
CHECK( (it1_c <= it1_c) == not(it1_c < it1_c) ); CHECK( (it1_c <= it1_c) == !(it1_c < it1_c) );
CHECK( (it1_c <= it2_c) == not(it2_c < it1_c) ); CHECK( (it1_c <= it2_c) == !(it2_c < it1_c) );
CHECK( (it1_c <= it3_c) == not(it3_c < it1_c) ); CHECK( (it1_c <= it3_c) == !(it3_c < it1_c) );
CHECK( (it2_c <= it3_c) == not(it3_c < it2_c) ); CHECK( (it2_c <= it3_c) == !(it3_c < it2_c) );
} }
} }
@ -641,14 +641,14 @@ TEST_CASE("iterators 2")
else else
{ {
// check definition // check definition
CHECK( (it1 >= it1) == not(it1 < it1) ); CHECK( (it1 >= it1) == !(it1 < it1) );
CHECK( (it1 >= it2) == not(it1 < it2) ); CHECK( (it1 >= it2) == !(it1 < it2) );
CHECK( (it1 >= it3) == not(it1 < it3) ); CHECK( (it1 >= it3) == !(it1 < it3) );
CHECK( (it2 >= it3) == not(it2 < it3) ); CHECK( (it2 >= it3) == !(it2 < it3) );
CHECK( (it1_c >= it1_c) == not(it1_c < it1_c) ); CHECK( (it1_c >= it1_c) == !(it1_c < it1_c) );
CHECK( (it1_c >= it2_c) == not(it1_c < it2_c) ); CHECK( (it1_c >= it2_c) == !(it1_c < it2_c) );
CHECK( (it1_c >= it3_c) == not(it1_c < it3_c) ); CHECK( (it1_c >= it3_c) == !(it1_c < it3_c) );
CHECK( (it2_c >= it3_c) == not(it2_c < it3_c) ); CHECK( (it2_c >= it3_c) == !(it2_c < it3_c) );
} }
} }
} }

46
test/src/unit-json_pointer.cpp
View File

@ -101,10 +101,10 @@ TEST_CASE("JSON pointers")
CHECK(j["/foo/1"_json_pointer] == j["foo"][1]); CHECK(j["/foo/1"_json_pointer] == j["foo"][1]);
CHECK(j.contains(json::json_pointer("/foo/0"))); CHECK(j.contains(json::json_pointer("/foo/0")));
CHECK(j.contains(json::json_pointer("/foo/1"))); CHECK(j.contains(json::json_pointer("/foo/1")));
CHECK(not j.contains(json::json_pointer("/foo/3"))); CHECK(!j.contains(json::json_pointer("/foo/3")));
CHECK(not j.contains(json::json_pointer("/foo/+"))); CHECK(!j.contains(json::json_pointer("/foo/+")));
CHECK(not j.contains(json::json_pointer("/foo/1+2"))); CHECK(!j.contains(json::json_pointer("/foo/1+2")));
CHECK(not j.contains(json::json_pointer("/foo/-"))); CHECK(!j.contains(json::json_pointer("/foo/-")));
// checked array access // checked array access
CHECK(j.at(json::json_pointer("/foo/0")) == j["foo"][0]); CHECK(j.at(json::json_pointer("/foo/0")) == j["foo"][0]);
@ -147,19 +147,19 @@ TEST_CASE("JSON pointers")
// unescaped access // unescaped access
// access to nonexisting values yield object creation // 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_NOTHROW(j[json::json_pointer("/a/b")] = 42);
CHECK(j.contains(json::json_pointer("/a/b"))); CHECK(j.contains(json::json_pointer("/a/b")));
CHECK(j["a"]["b"] == json(42)); 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_NOTHROW(j[json::json_pointer("/a/c/1")] = 42);
CHECK(j["a"]["c"] == json({nullptr, 42})); CHECK(j["a"]["c"] == json({nullptr, 42}));
CHECK(j.contains(json::json_pointer("/a/c/1"))); 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_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})); CHECK(j["a"]["d"] == json::array({42}));
// "/a/b" works for JSON {"a": {"b": 42}} // "/a/b" works for JSON {"a": {"b": 42}}
CHECK(json({{"a", {{"b", 42}}}})[json::json_pointer("/a/b")] == json(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_AS(j_primitive.at("/foo"_json_pointer), json::out_of_range&);
CHECK_THROWS_WITH(j_primitive.at("/foo"_json_pointer), CHECK_THROWS_WITH(j_primitive.at("/foo"_json_pointer),
"[json.exception.out_of_range.404] unresolved reference token 'foo'"); "[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") SECTION("const access")
@ -272,7 +272,7 @@ TEST_CASE("JSON pointers")
CHECK(j.contains("/foo"_json_pointer)); CHECK(j.contains("/foo"_json_pointer));
CHECK(j.contains("/foo/0"_json_pointer)); CHECK(j.contains("/foo/0"_json_pointer));
CHECK(j.contains("/foo/1"_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), CHECK_THROWS_WITH(j_const.at("/01"_json_pointer),
"[json.exception.parse_error.106] parse error: array index '01' must not begin with '0'"); "[json.exception.parse_error.106] parse error: array index '01' must not begin with '0'");
CHECK(not j.contains("/01"_json_pointer)); CHECK(!j.contains("/01"_json_pointer));
CHECK(not j.contains("/01"_json_pointer)); CHECK(!j.contains("/01"_json_pointer));
CHECK(not j_const.contains("/01"_json_pointer)); CHECK(!j_const.contains("/01"_json_pointer));
CHECK(not j_const.contains("/01"_json_pointer)); CHECK(!j_const.contains("/01"_json_pointer));
// error with incorrect numbers // error with incorrect numbers
CHECK_THROWS_AS(j["/one"_json_pointer] = 1, json::parse_error&); CHECK_THROWS_AS(j["/one"_json_pointer] = 1, json::parse_error&);
@ -379,10 +379,10 @@ TEST_CASE("JSON pointers")
CHECK_THROWS_WITH(j_const.at("/one"_json_pointer) == 1, CHECK_THROWS_WITH(j_const.at("/one"_json_pointer) == 1,
"[json.exception.parse_error.109] parse error: array index 'one' is not a number"); "[json.exception.parse_error.109] parse error: array index 'one' is not a number");
CHECK(not j.contains("/one"_json_pointer)); CHECK(!j.contains("/one"_json_pointer));
CHECK(not j.contains("/one"_json_pointer)); CHECK(!j.contains("/one"_json_pointer));
CHECK(not j_const.contains("/one"_json_pointer)); CHECK(!j_const.contains("/one"_json_pointer));
CHECK(not 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_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(), CHECK_THROWS_WITH(json({{"/list/0", 1}, {"/list/1", 2}, {"/list/three", 3}}).unflatten(),
@ -396,7 +396,7 @@ TEST_CASE("JSON pointers")
CHECK_THROWS_AS(j_const["/-"_json_pointer], json::out_of_range&); CHECK_THROWS_AS(j_const["/-"_json_pointer], json::out_of_range&);
CHECK_THROWS_WITH(j_const["/-"_json_pointer], CHECK_THROWS_WITH(j_const["/-"_json_pointer],
"[json.exception.out_of_range.402] array index '-' (3) is out of range"); "[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 // error when using "-" with at
CHECK_THROWS_AS(j.at("/-"_json_pointer), json::out_of_range&); CHECK_THROWS_AS(j.at("/-"_json_pointer), json::out_of_range&);
@ -405,7 +405,7 @@ TEST_CASE("JSON pointers")
CHECK_THROWS_AS(j_const.at("/-"_json_pointer), json::out_of_range&); CHECK_THROWS_AS(j_const.at("/-"_json_pointer), json::out_of_range&);
CHECK_THROWS_WITH(j_const.at("/-"_json_pointer), CHECK_THROWS_WITH(j_const.at("/-"_json_pointer),
"[json.exception.out_of_range.402] array index '-' (3) is out of range"); "[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") SECTION("const access")
@ -421,13 +421,13 @@ TEST_CASE("JSON pointers")
CHECK_THROWS_AS(j.at("/3"_json_pointer), json::out_of_range&); CHECK_THROWS_AS(j.at("/3"_json_pointer), json::out_of_range&);
CHECK_THROWS_WITH(j.at("/3"_json_pointer), CHECK_THROWS_WITH(j.at("/3"_json_pointer),
"[json.exception.out_of_range.401] array index 3 is out of range"); "[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) // assign to nonexisting index (with gap)
CHECK_THROWS_AS(j.at("/5"_json_pointer), json::out_of_range&); CHECK_THROWS_AS(j.at("/5"_json_pointer), json::out_of_range&);
CHECK_THROWS_WITH(j.at("/5"_json_pointer), CHECK_THROWS_WITH(j.at("/5"_json_pointer),
"[json.exception.out_of_range.401] array index 5 is out of range"); "[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 "-" // assign to "-"
CHECK_THROWS_AS(j["/-"_json_pointer], json::out_of_range&); CHECK_THROWS_AS(j["/-"_json_pointer], json::out_of_range&);
@ -436,7 +436,7 @@ TEST_CASE("JSON pointers")
CHECK_THROWS_AS(j.at("/-"_json_pointer), json::out_of_range&); CHECK_THROWS_AS(j.at("/-"_json_pointer), json::out_of_range&);
CHECK_THROWS_WITH(j.at("/-"_json_pointer), CHECK_THROWS_WITH(j.at("/-"_json_pointer),
"[json.exception.out_of_range.402] array index '-' (3) is out of range"); "[json.exception.out_of_range.402] array index '-' (3) is out of range");
CHECK(not j.contains("/-"_json_pointer)); CHECK(!j.contains("/-"_json_pointer));
} }
} }

4
test/src/unit-modifiers.cpp
View File

@ -114,7 +114,7 @@ TEST_CASE("modifiers")
json k = j; json k = j;
j.clear(); j.clear();
CHECK(not j.empty()); CHECK(!j.empty());
CHECK(j == json(json::value_t::binary)); CHECK(j == json(json::value_t::binary));
CHECK(j == json(k.type())); CHECK(j == json(k.type()));
} }
@ -125,7 +125,7 @@ TEST_CASE("modifiers")
json k = j; json k = j;
j.clear(); j.clear();
CHECK(not j.empty()); CHECK(!j.empty());
CHECK(j == json(json::value_t::binary)); CHECK(j == json(json::value_t::binary));
CHECK(j == json(k.type())); CHECK(j == json(k.type()));
} }

6
test/src/unit-msgpack.cpp
View File

@ -1578,21 +1578,21 @@ TEST_CASE("MessagePack")
{ {
std::vector<uint8_t> v = {0x93, 0x01, 0x02, 0x03}; std::vector<uint8_t> v = {0x93, 0x01, 0x02, 0x03};
SaxCountdown scp(0); 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)") SECTION("start_object(len)")
{ {
std::vector<uint8_t> v = {0x81, 0xa3, 0x66, 0x6F, 0x6F, 0xc2}; std::vector<uint8_t> v = {0x81, 0xa3, 0x66, 0x6F, 0x6F, 0xc2};
SaxCountdown scp(0); 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()") SECTION("key()")
{ {
std::vector<uint8_t> v = {0x81, 0xa3, 0x66, 0x6F, 0x6F, 0xc2}; std::vector<uint8_t> v = {0x81, 0xa3, 0x66, 0x6F, 0x6F, 0xc2};
SaxCountdown scp(1); 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));
} }
} }
} }

4
test/src/unit-noexcept.cpp
View File

@ -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, true)), "");
static_assert(noexcept(nlohmann::to_json(*j, test{})), ""); static_assert(noexcept(nlohmann::to_json(*j, test{})), "");
static_assert(noexcept(nlohmann::to_json(*j, pod{})), ""); 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(2)), "");
static_assert(noexcept(json(test{})), ""); static_assert(noexcept(json(test{})), "");
static_assert(noexcept(json(pod{})), ""); static_assert(noexcept(json(pod{})), "");
static_assert(noexcept(j->get<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{})), ""); static_assert(noexcept(json(pod{})), "");
} }

79
test/src/unit-ordered_json.cpp Normal file
View File

@ -0,0 +1,79 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
| | |__ | | | | | | version 3.8.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}");
}

33
test/src/unit-regression.cpp
View File

@ -254,12 +254,12 @@ TEST_CASE("regression tests")
json j1 = INFINITY; json j1 = INFINITY;
CHECK(j1.is_number_float()); CHECK(j1.is_number_float());
json::number_float_t f1 = j1; json::number_float_t f1 = j1;
CHECK(not std::isfinite(f1)); CHECK(!std::isfinite(f1));
json j2 = json::number_float_t(INFINITY); json j2 = json::number_float_t(INFINITY);
CHECK(j2.is_number_float()); CHECK(j2.is_number_float());
json::number_float_t f2 = j2; json::number_float_t f2 = j2;
CHECK(not std::isfinite(f2)); CHECK(!std::isfinite(f2));
} }
} }
@ -1350,10 +1350,10 @@ TEST_CASE("regression tests")
CHECK(j["a"] > 3); CHECK(j["a"] > 3);
CHECK(not(j["a"] <= 4)); CHECK(!(j["a"] <= 4));
CHECK(not(j["a"] < 4)); CHECK(!(j["a"] < 4));
CHECK(not(j["a"] >= 6)); CHECK(!(j["a"] >= 6));
CHECK(not(j["a"] > 6)); CHECK(!(j["a"] > 6));
// scalar op json // scalar op json
CHECK(5 == j["a"]); CHECK(5 == j["a"]);
@ -1364,10 +1364,10 @@ TEST_CASE("regression tests")
CHECK(3 <= j["a"]); CHECK(3 <= j["a"]);
CHECK(3 < j["a"]); CHECK(3 < j["a"]);
CHECK(not(4 >= j["a"])); CHECK(!(4 >= j["a"]));
CHECK(not(4 > j["a"])); CHECK(!(4 > j["a"]));
CHECK(not(6 <= j["a"])); CHECK(!(6 <= j["a"]));
CHECK(not(6 < j["a"])); CHECK(!(6 < j["a"]));
} }
SECTION("issue #575 - heap-buffer-overflow (OSS-Fuzz 1400)") SECTION("issue #575 - heap-buffer-overflow (OSS-Fuzz 1400)")
@ -1608,7 +1608,7 @@ TEST_CASE("regression tests")
json::parser_callback_t cb = [](int /*depth*/, json::parse_event_t event, json & parsed) json::parser_callback_t cb = [](int /*depth*/, json::parse_event_t event, json & parsed)
{ {
// skip object elements with key "Thumbnail" // 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; return false;
} }
@ -1680,7 +1680,7 @@ TEST_CASE("regression tests")
json::parser_callback_t cb = [&](int, json::parse_event_t event, json & parsed) json::parser_callback_t cb = [&](int, json::parse_event_t event, json & parsed)
{ {
// skip uninteresting events // 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; return false;
} }
@ -1760,7 +1760,7 @@ TEST_CASE("regression tests")
SECTION("issue #1292 - Serializing std::variant causes stack overflow") SECTION("issue #1292 - Serializing std::variant causes stack overflow")
{ {
static_assert( static_assert(
not std::is_constructible<json, std::variant<int, float>>::value, ""); !std::is_constructible<json, std::variant<int, float>>::value, "");
} }
#endif #endif
@ -1956,7 +1956,7 @@ TEST_CASE("regression tests")
} }
} }
#if not defined(JSON_NOEXCEPTION) #if !defined(JSON_NOEXCEPTION)
TEST_CASE("regression tests, exceptions dependent") TEST_CASE("regression tests, exceptions dependent")
{ {
SECTION("issue #1340 - eof not set on exhausted input stream") SECTION("issue #1340 - eof not set on exhausted input stream")
@ -1974,9 +1974,14 @@ TEST_CASE("regression tests, exceptions dependent")
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
// for #1642 // 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 array {};
template <typename T> class object {}; template <typename T> class object {};
template <typename T> class string {}; template <typename T> class string {};
template <typename T> class number_integer {}; template <typename T> class number_integer {};
template <typename T> class number_unsigned {}; template <typename T> class number_unsigned {};
template <typename T> class number_float {}; template <typename T> class number_float {};
#endif

6
test/src/unit-testsuites.cpp
View File

@ -1235,7 +1235,7 @@ TEST_CASE("nst's JSONTestSuite (2)")
json _; json _;
CHECK_THROWS_AS(_ = json::parse(f), json::parse_error&); CHECK_THROWS_AS(_ = json::parse(f), json::parse_error&);
std::ifstream f2(filename); 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) CAPTURE(filename)
std::ifstream f(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 _; json _;
CHECK_THROWS_AS(_ = json::parse(f), json::exception&); // could be parse_error or out_of_range CHECK_THROWS_AS(_ = json::parse(f), json::exception&); // could be parse_error or out_of_range
std::ifstream f2(filename); std::ifstream f2(filename);
CHECK(not json::accept(f2)); CHECK(!json::accept(f2));
} }
} }
} }

14
test/src/unit-ubjson.cpp
View File

@ -1586,42 +1586,42 @@ TEST_CASE("UBJSON")
{ {
std::vector<uint8_t> v = {'[', 'T', 'F', ']'}; std::vector<uint8_t> v = {'[', 'T', 'F', ']'};
SaxCountdown scp(0); 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()") SECTION("start_object()")
{ {
std::vector<uint8_t> v = {'{', 'i', 3, 'f', 'o', 'o', 'F', '}'}; std::vector<uint8_t> v = {'{', 'i', 3, 'f', 'o', 'o', 'F', '}'};
SaxCountdown scp(0); 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") SECTION("key() in object")
{ {
std::vector<uint8_t> v = {'{', 'i', 3, 'f', 'o', 'o', 'F', '}'}; std::vector<uint8_t> v = {'{', 'i', 3, 'f', 'o', 'o', 'F', '}'};
SaxCountdown scp(1); 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)") SECTION("start_array(len)")
{ {
std::vector<uint8_t> v = {'[', '#', 'i', '2', 'T', 'F'}; std::vector<uint8_t> v = {'[', '#', 'i', '2', 'T', 'F'};
SaxCountdown scp(0); 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)") SECTION("start_object(len)")
{ {
std::vector<uint8_t> v = {'{', '#', 'i', '1', 3, 'f', 'o', 'o', 'F'}; std::vector<uint8_t> v = {'{', '#', 'i', '1', 3, 'f', 'o', 'o', 'F'};
SaxCountdown scp(0); 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") SECTION("key() in object with length")
{ {
std::vector<uint8_t> v = {'{', 'i', 3, 'f', 'o', 'o', 'F', '}'}; std::vector<uint8_t> v = {'{', 'i', 3, 'f', 'o', 'o', 'F', '}'};
SaxCountdown scp(1); 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,7 +2363,7 @@ TEST_CASE("Universal Binary JSON Specification Examples 1")
} }
} }
#if not defined(JSON_NOEXCEPTION) #if !defined(JSON_NOEXCEPTION)
TEST_CASE("all UBJSON first bytes") TEST_CASE("all UBJSON first bytes")
{ {
// these bytes will fail immediately with exception parse_error.112 // these bytes will fail immediately with exception parse_error.112

20
test/src/unit-udt.cpp
View File

@ -551,7 +551,7 @@ struct pod_serializer
template < template <
typename BasicJsonType, typename U = T, typename BasicJsonType, typename U = T,
typename std::enable_if < 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) static void from_json(const BasicJsonType& j, U& t)
{ {
using nlohmann::from_json; using nlohmann::from_json;
@ -559,9 +559,9 @@ struct pod_serializer
} }
// special behaviour for pods // special behaviour for pods
template <typename BasicJsonType, typename U = T, template < typename BasicJsonType, typename U = T,
typename std::enable_if< typename std::enable_if <
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) static void from_json(const BasicJsonType& j, U& t)
{ {
std::uint64_t value; std::uint64_t value;
@ -587,16 +587,16 @@ struct pod_serializer
template < template <
typename BasicJsonType, typename U = T, typename BasicJsonType, typename U = T,
typename std::enable_if < 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) static void to_json(BasicJsonType& j, const T& t)
{ {
using nlohmann::to_json; using nlohmann::to_json;
to_json(j, t); to_json(j, t);
} }
template <typename BasicJsonType, typename U = T, template < typename BasicJsonType, typename U = T,
typename std::enable_if< typename std::enable_if <
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) noexcept static void to_json(BasicJsonType& j, const T& t) noexcept
{ {
auto bytes = static_cast< const unsigned char*>(static_cast<const void*>(&t)); auto bytes = static_cast< const unsigned char*>(static_cast<const void*>(&t));
@ -805,7 +805,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")) 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 namespace
@ -839,5 +839,5 @@ TEST_CASE("Issue #924")
TEST_CASE("Issue #1237") TEST_CASE("Issue #1237")
{ {
struct non_convertible_type {}; 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, "");
} }

44
test/src/unit-unicode.cpp
View File

@ -217,7 +217,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte1 = 0x00; byte1 <= 0x7F; ++byte1) for (int byte1 = 0x00; byte1 <= 0x7F; ++byte1)
{ {
// unescaped control characters are parse errors in JSON // unescaped control characters are parse errors in JSON
if (0x00 <= byte1 and byte1 <= 0x1F) if (0x00 <= byte1 && byte1 <= 0x1F)
{ {
check_utf8string(false, byte1); check_utf8string(false, byte1);
continue; continue;
@ -274,7 +274,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2) for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{ {
// skip correct second byte // skip correct second byte
if (0x80 <= byte2 and byte2 <= 0xBF) if (0x80 <= byte2 && byte2 <= 0xBF)
{ {
continue; continue;
} }
@ -331,7 +331,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2) for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{ {
// skip correct second byte // skip correct second byte
if (0xA0 <= byte2 and byte2 <= 0xBF) if (0xA0 <= byte2 && byte2 <= 0xBF)
{ {
continue; continue;
} }
@ -354,7 +354,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3) for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{ {
// skip correct third byte // skip correct third byte
if (0x80 <= byte3 and byte3 <= 0xBF) if (0x80 <= byte3 && byte3 <= 0xBF)
{ {
continue; continue;
} }
@ -412,7 +412,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2) for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{ {
// skip correct second byte // skip correct second byte
if (0x80 <= byte2 and byte2 <= 0xBF) if (0x80 <= byte2 && byte2 <= 0xBF)
{ {
continue; continue;
} }
@ -435,7 +435,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3) for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{ {
// skip correct third byte // skip correct third byte
if (0x80 <= byte3 and byte3 <= 0xBF) if (0x80 <= byte3 && byte3 <= 0xBF)
{ {
continue; continue;
} }
@ -493,7 +493,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2) for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{ {
// skip correct second byte // skip correct second byte
if (0x80 <= byte2 and byte2 <= 0x9F) if (0x80 <= byte2 && byte2 <= 0x9F)
{ {
continue; continue;
} }
@ -516,7 +516,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3) for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{ {
// skip correct third byte // skip correct third byte
if (0x80 <= byte3 and byte3 <= 0xBF) if (0x80 <= byte3 && byte3 <= 0xBF)
{ {
continue; continue;
} }
@ -574,7 +574,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2) for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{ {
// skip correct second byte // skip correct second byte
if (0x80 <= byte2 and byte2 <= 0xBF) if (0x80 <= byte2 && byte2 <= 0xBF)
{ {
continue; continue;
} }
@ -597,7 +597,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3) for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{ {
// skip correct third byte // skip correct third byte
if (0x80 <= byte3 and byte3 <= 0xBF) if (0x80 <= byte3 && byte3 <= 0xBF)
{ {
continue; continue;
} }
@ -673,7 +673,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2) for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{ {
// skip correct second byte // skip correct second byte
if (0x90 <= byte2 and byte2 <= 0xBF) if (0x90 <= byte2 && byte2 <= 0xBF)
{ {
continue; continue;
} }
@ -699,7 +699,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3) for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{ {
// skip correct third byte // skip correct third byte
if (0x80 <= byte3 and byte3 <= 0xBF) if (0x80 <= byte3 && byte3 <= 0xBF)
{ {
continue; continue;
} }
@ -725,7 +725,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4) for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
{ {
// skip fourth second byte // skip fourth second byte
if (0x80 <= byte3 and byte3 <= 0xBF) if (0x80 <= byte3 && byte3 <= 0xBF)
{ {
continue; continue;
} }
@ -802,7 +802,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2) for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{ {
// skip correct second byte // skip correct second byte
if (0x80 <= byte2 and byte2 <= 0xBF) if (0x80 <= byte2 && byte2 <= 0xBF)
{ {
continue; continue;
} }
@ -828,7 +828,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3) for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{ {
// skip correct third byte // skip correct third byte
if (0x80 <= byte3 and byte3 <= 0xBF) if (0x80 <= byte3 && byte3 <= 0xBF)
{ {
continue; continue;
} }
@ -854,7 +854,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4) for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
{ {
// skip correct fourth byte // skip correct fourth byte
if (0x80 <= byte3 and byte3 <= 0xBF) if (0x80 <= byte3 && byte3 <= 0xBF)
{ {
continue; continue;
} }
@ -931,7 +931,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2) for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
{ {
// skip correct second byte // skip correct second byte
if (0x80 <= byte2 and byte2 <= 0x8F) if (0x80 <= byte2 && byte2 <= 0x8F)
{ {
continue; continue;
} }
@ -957,7 +957,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3) for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
{ {
// skip correct third byte // skip correct third byte
if (0x80 <= byte3 and byte3 <= 0xBF) if (0x80 <= byte3 && byte3 <= 0xBF)
{ {
continue; continue;
} }
@ -983,7 +983,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4) for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
{ {
// skip correct fourth byte // skip correct fourth byte
if (0x80 <= byte3 and byte3 <= 0xBF) if (0x80 <= byte3 && byte3 <= 0xBF)
{ {
continue; continue;
} }
@ -1030,7 +1030,7 @@ TEST_CASE("Unicode" * doctest::skip())
// they will never be assigned a character, so there should be no // they will never be assigned a character, so there should be no
// reason to encode them. The official Unicode standard says that // reason to encode them. The official Unicode standard says that
// no UTF forms, including UTF-16, can encode these code points. // 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 // if we would not skip these code points, we would get a
// "missing low surrogate" exception // "missing low surrogate" exception
@ -1117,7 +1117,7 @@ TEST_CASE("Unicode" * doctest::skip())
{ {
for (std::size_t cp2 = 0x0000u; cp2 <= 0xFFFFu; ++cp2) for (std::size_t cp2 = 0x0000u; cp2 <= 0xFFFFu; ++cp2)
{ {
if (0xDC00u <= cp2 and cp2 <= 0xDFFFu) if (0xDC00u <= cp2 && cp2 <= 0xDFFFu)
{ {
continue; continue;
} }
@ -1163,7 +1163,7 @@ TEST_CASE("Unicode" * doctest::skip())
for (auto s : j) for (auto s : j)
{ {
// skip non-string JSON values // skip non-string JSON values
if (not s.is_string()) if (!s.is_string())
{ {
continue; continue;
} }