🎨 replace alternative operators (and, not, or)

parent 4f04ea1b
...@@ -37,7 +37,7 @@ struct adl_serializer ...@@ -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())
......
...@@ -26,7 +26,7 @@ namespace detail ...@@ -26,7 +26,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 +34,10 @@ void from_json(const BasicJsonType& j, typename std::nullptr_t& n) ...@@ -34,10 +34,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 +66,7 @@ void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val) ...@@ -66,7 +66,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 +76,7 @@ void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b) ...@@ -76,7 +76,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 +86,13 @@ void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s) ...@@ -86,13 +86,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 +132,7 @@ template<typename BasicJsonType, typename T, typename Allocator, ...@@ -132,7 +132,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 +149,7 @@ template<typename BasicJsonType, typename T, ...@@ -149,7 +149,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 +157,7 @@ void from_json(const BasicJsonType& j, std::valarray<T>& l) ...@@ -157,7 +157,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 +173,7 @@ void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_ ...@@ -173,7 +173,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 +205,7 @@ auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, p ...@@ -205,7 +205,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 +223,20 @@ void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, ...@@ -223,20 +223,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 +245,10 @@ void()) ...@@ -245,10 +245,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 +260,7 @@ template<typename BasicJsonType, typename ConstructibleObjectType, ...@@ -260,7 +260,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 +282,14 @@ void from_json(const BasicJsonType& j, ConstructibleObjectType& obj) ...@@ -282,14 +282,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 +338,19 @@ void from_json(const BasicJsonType& j, std::tuple<Args...>& t) ...@@ -338,19 +338,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 +358,19 @@ void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& ...@@ -358,19 +358,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())));
} }
......
...@@ -38,7 +38,7 @@ For a detailed description of the algorithm see: ...@@ -38,7 +38,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");
...@@ -179,7 +179,7 @@ boundaries. ...@@ -179,7 +179,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)
{ {
assert(std::isfinite(value)); assert(std::isfinite(value));
...@@ -232,7 +232,7 @@ boundaries compute_boundaries(FloatType value) ...@@ -232,7 +232,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)
...@@ -567,8 +567,8 @@ inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t d ...@@ -567,8 +567,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))
{ {
assert(buf[len - 1] != '0'); assert(buf[len - 1] != '0');
buf[len - 1]--; buf[len - 1]--;
...@@ -879,7 +879,7 @@ v = buf * 10^decimal_exponent ...@@ -879,7 +879,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)
{ {
...@@ -986,7 +986,7 @@ inline char* format_buffer(char* buf, int len, int decimal_exponent, ...@@ -986,7 +986,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
...@@ -998,7 +998,7 @@ inline char* format_buffer(char* buf, int len, int decimal_exponent, ...@@ -998,7 +998,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
...@@ -1010,7 +1010,7 @@ inline char* format_buffer(char* buf, int len, int decimal_exponent, ...@@ -1010,7 +1010,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
...@@ -1055,7 +1055,7 @@ format. Returns an iterator pointing past-the-end of the decimal representation. ...@@ -1055,7 +1055,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)
......
...@@ -56,9 +56,9 @@ struct external_constructor<value_t::string> ...@@ -56,9 +56,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 +144,9 @@ struct external_constructor<value_t::array> ...@@ -144,9 +144,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 +203,8 @@ struct external_constructor<value_t::object> ...@@ -203,8 +203,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 +275,20 @@ void to_json(BasicJsonType& j, const std::vector<bool>& e) ...@@ -275,20 +275,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 +307,8 @@ void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr) ...@@ -307,8 +307,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 +322,9 @@ void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj) ...@@ -322,9 +322,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,8 +337,8 @@ void to_json(BasicJsonType& j, const std::pair<T1, T2>& p) ...@@ -337,8 +337,8 @@ 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)
{ {
j = { {b.key(), b.value()} }; j = { {b.key(), b.value()} };
......
...@@ -111,7 +111,7 @@ class binary_reader ...@@ -111,7 +111,7 @@ class binary_reader
} }
// strict mode: next byte must be EOF // strict mode: next byte must be EOF
if (result and strict) if (result && strict)
{ {
if (format == input_format_t::ubjson) if (format == input_format_t::ubjson)
{ {
...@@ -146,12 +146,12 @@ class binary_reader ...@@ -146,12 +146,12 @@ class binary_reader
std::int32_t document_size; std::int32_t document_size;
get_number<std::int32_t, true>(input_format_t::bson, document_size); get_number<std::int32_t, true>(input_format_t::bson, document_size);
if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1)))) if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
{ {
return false; return false;
} }
if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_list(/*is_array*/false))) if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
{ {
return false; return false;
} }
...@@ -172,7 +172,7 @@ class binary_reader ...@@ -172,7 +172,7 @@ class binary_reader
while (true) while (true)
{ {
get(); get();
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::bson, "cstring"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
{ {
return false; return false;
} }
...@@ -206,7 +206,7 @@ class binary_reader ...@@ -206,7 +206,7 @@ class binary_reader
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string"))); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string")));
} }
return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) and get() != std::char_traits<char>::eof(); return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char>::eof();
} }
/*! /*!
...@@ -253,14 +253,14 @@ class binary_reader ...@@ -253,14 +253,14 @@ class binary_reader
case 0x01: // double case 0x01: // double
{ {
double number; double number;
return get_number<double, true>(input_format_t::bson, number) and sax->number_float(static_cast<number_float_t>(number), ""); return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
} }
case 0x02: // string case 0x02: // string
{ {
std::int32_t len; std::int32_t len;
string_t value; string_t value;
return get_number<std::int32_t, true>(input_format_t::bson, len) and get_bson_string(len, value) and sax->string(value); return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
} }
case 0x03: // object case 0x03: // object
...@@ -277,7 +277,7 @@ class binary_reader ...@@ -277,7 +277,7 @@ class binary_reader
{ {
std::int32_t len; std::int32_t len;
binary_t value; binary_t value;
return get_number<std::int32_t, true>(input_format_t::bson, len) and get_bson_binary(len, value) and sax->binary(value); return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
} }
case 0x08: // boolean case 0x08: // boolean
...@@ -293,13 +293,13 @@ class binary_reader ...@@ -293,13 +293,13 @@ class binary_reader
case 0x10: // int32 case 0x10: // int32
{ {
std::int32_t value; std::int32_t value;
return get_number<std::int32_t, true>(input_format_t::bson, value) and sax->number_integer(value); return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
} }
case 0x12: // int64 case 0x12: // int64
{ {
std::int64_t value; std::int64_t value;
return get_number<std::int64_t, true>(input_format_t::bson, value) and sax->number_integer(value); return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
} }
default: // anything else not supported (yet) default: // anything else not supported (yet)
...@@ -329,23 +329,23 @@ class binary_reader ...@@ -329,23 +329,23 @@ class binary_reader
while (int element_type = get()) while (int element_type = get())
{ {
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::bson, "element list"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
{ {
return false; return false;
} }
const std::size_t element_type_parse_position = chars_read; const std::size_t element_type_parse_position = chars_read;
if (JSON_HEDLEY_UNLIKELY(not get_bson_cstr(key))) if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
{ {
return false; return false;
} }
if (not is_array and not sax->key(key)) if (!is_array && !sax->key(key))
{ {
return false; return false;
} }
if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_internal(element_type, element_type_parse_position))) if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
{ {
return false; return false;
} }
...@@ -366,12 +366,12 @@ class binary_reader ...@@ -366,12 +366,12 @@ class binary_reader
std::int32_t document_size; std::int32_t document_size;
get_number<std::int32_t, true>(input_format_t::bson, document_size); get_number<std::int32_t, true>(input_format_t::bson, document_size);
if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1)))) if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
{ {
return false; return false;
} }
if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_list(/*is_array*/true))) if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
{ {
return false; return false;
} }
...@@ -428,25 +428,25 @@ class binary_reader ...@@ -428,25 +428,25 @@ class binary_reader
case 0x18: // Unsigned integer (one-byte uint8_t follows) case 0x18: // Unsigned integer (one-byte uint8_t follows)
{ {
std::uint8_t number; std::uint8_t number;
return get_number(input_format_t::cbor, number) and sax->number_unsigned(number); return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
} }
case 0x19: // Unsigned integer (two-byte uint16_t follows) case 0x19: // Unsigned integer (two-byte uint16_t follows)
{ {
std::uint16_t number; std::uint16_t number;
return get_number(input_format_t::cbor, number) and sax->number_unsigned(number); return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
} }
case 0x1A: // Unsigned integer (four-byte uint32_t follows) case 0x1A: // Unsigned integer (four-byte uint32_t follows)
{ {
std::uint32_t number; std::uint32_t number;
return get_number(input_format_t::cbor, number) and sax->number_unsigned(number); return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
} }
case 0x1B: // Unsigned integer (eight-byte uint64_t follows) case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
{ {
std::uint64_t number; std::uint64_t number;
return get_number(input_format_t::cbor, number) and sax->number_unsigned(number); return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
} }
// Negative integer -1-0x00..-1-0x17 (-1..-24) // Negative integer -1-0x00..-1-0x17 (-1..-24)
...@@ -479,25 +479,25 @@ class binary_reader ...@@ -479,25 +479,25 @@ class binary_reader
case 0x38: // Negative integer (one-byte uint8_t follows) case 0x38: // Negative integer (one-byte uint8_t follows)
{ {
std::uint8_t number; std::uint8_t number;
return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number); return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
} }
case 0x39: // Negative integer -1-n (two-byte uint16_t follows) case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
{ {
std::uint16_t number; std::uint16_t number;
return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number); return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
} }
case 0x3A: // Negative integer -1-n (four-byte uint32_t follows) case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
{ {
std::uint32_t number; std::uint32_t number;
return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number); return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
} }
case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows) case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
{ {
std::uint64_t number; std::uint64_t number;
return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
- static_cast<number_integer_t>(number)); - static_cast<number_integer_t>(number));
} }
...@@ -533,7 +533,7 @@ class binary_reader ...@@ -533,7 +533,7 @@ class binary_reader
case 0x5F: // Binary data (indefinite length) case 0x5F: // Binary data (indefinite length)
{ {
binary_t b; binary_t b;
return get_cbor_binary(b) and sax->binary(b); return get_cbor_binary(b) && sax->binary(b);
} }
// UTF-8 string (0x00..0x17 bytes follow) // UTF-8 string (0x00..0x17 bytes follow)
...@@ -568,7 +568,7 @@ class binary_reader ...@@ -568,7 +568,7 @@ class binary_reader
case 0x7F: // UTF-8 string (indefinite length) case 0x7F: // UTF-8 string (indefinite length)
{ {
string_t s; string_t s;
return get_cbor_string(s) and sax->string(s); return get_cbor_string(s) && sax->string(s);
} }
// array (0x00..0x17 data items follow) // array (0x00..0x17 data items follow)
...@@ -601,25 +601,25 @@ class binary_reader ...@@ -601,25 +601,25 @@ class binary_reader
case 0x98: // array (one-byte uint8_t for n follows) case 0x98: // array (one-byte uint8_t for n follows)
{ {
std::uint8_t len; std::uint8_t len;
return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len)); return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len));
} }
case 0x99: // array (two-byte uint16_t for n follow) case 0x99: // array (two-byte uint16_t for n follow)
{ {
std::uint16_t len; std::uint16_t len;
return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len)); return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len));
} }
case 0x9A: // array (four-byte uint32_t for n follow) case 0x9A: // array (four-byte uint32_t for n follow)
{ {
std::uint32_t len; std::uint32_t len;
return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len)); return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len));
} }
case 0x9B: // array (eight-byte uint64_t for n follow) case 0x9B: // array (eight-byte uint64_t for n follow)
{ {
std::uint64_t len; std::uint64_t len;
return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len)); return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len));
} }
case 0x9F: // array (indefinite length) case 0x9F: // array (indefinite length)
...@@ -655,25 +655,25 @@ class binary_reader ...@@ -655,25 +655,25 @@ class binary_reader
case 0xB8: // map (one-byte uint8_t for n follows) case 0xB8: // map (one-byte uint8_t for n follows)
{ {
std::uint8_t len; std::uint8_t len;
return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len)); return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len));
} }
case 0xB9: // map (two-byte uint16_t for n follow) case 0xB9: // map (two-byte uint16_t for n follow)
{ {
std::uint16_t len; std::uint16_t len;
return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len)); return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len));
} }
case 0xBA: // map (four-byte uint32_t for n follow) case 0xBA: // map (four-byte uint32_t for n follow)
{ {
std::uint32_t len; std::uint32_t len;
return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len)); return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len));
} }
case 0xBB: // map (eight-byte uint64_t for n follow) case 0xBB: // map (eight-byte uint64_t for n follow)
{ {
std::uint64_t len; std::uint64_t len;
return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len)); return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len));
} }
case 0xBF: // map (indefinite length) case 0xBF: // map (indefinite length)
...@@ -691,12 +691,12 @@ class binary_reader ...@@ -691,12 +691,12 @@ class binary_reader
case 0xF9: // Half-Precision Float (two-byte IEEE 754) case 0xF9: // Half-Precision Float (two-byte IEEE 754)
{ {
const int byte1_raw = get(); const int byte1_raw = get();
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
{ {
return false; return false;
} }
const int byte2_raw = get(); const int byte2_raw = get();
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
{ {
return false; return false;
} }
...@@ -717,7 +717,7 @@ class binary_reader ...@@ -717,7 +717,7 @@ class binary_reader
{ {
const int exp = (half >> 10u) & 0x1Fu; const int exp = (half >> 10u) & 0x1Fu;
const unsigned int mant = half & 0x3FFu; const unsigned int mant = half & 0x3FFu;
assert(0 <= exp and exp <= 32); assert(0 <= exp&& exp <= 32);
assert(mant <= 1024); assert(mant <= 1024);
switch (exp) switch (exp)
{ {
...@@ -739,13 +739,13 @@ class binary_reader ...@@ -739,13 +739,13 @@ class binary_reader
case 0xFA: // Single-Precision Float (four-byte IEEE 754) case 0xFA: // Single-Precision Float (four-byte IEEE 754)
{ {
float number; float number;
return get_number(input_format_t::cbor, number) and sax->number_float(static_cast<number_float_t>(number), ""); return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
} }
case 0xFB: // Double-Precision Float (eight-byte IEEE 754) case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
{ {
double number; double number;
return get_number(input_format_t::cbor, number) and sax->number_float(static_cast<number_float_t>(number), ""); return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
} }
default: // anything else (0xFF is handled inside the other types) default: // anything else (0xFF is handled inside the other types)
...@@ -769,7 +769,7 @@ class binary_reader ...@@ -769,7 +769,7 @@ class binary_reader
*/ */
bool get_cbor_string(string_t& result) bool get_cbor_string(string_t& result)
{ {
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "string"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
{ {
return false; return false;
} }
...@@ -808,25 +808,25 @@ class binary_reader ...@@ -808,25 +808,25 @@ class binary_reader
case 0x78: // UTF-8 string (one-byte uint8_t for n follows) case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
{ {
std::uint8_t len; std::uint8_t len;
return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result); return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
} }
case 0x79: // UTF-8 string (two-byte uint16_t for n follow) case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
{ {
std::uint16_t len; std::uint16_t len;
return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result); return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
} }
case 0x7A: // UTF-8 string (four-byte uint32_t for n follow) case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
{ {
std::uint32_t len; std::uint32_t len;
return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result); return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
} }
case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow) case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
{ {
std::uint64_t len; std::uint64_t len;
return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result); return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
} }
case 0x7F: // UTF-8 string (indefinite length) case 0x7F: // UTF-8 string (indefinite length)
...@@ -834,7 +834,7 @@ class binary_reader ...@@ -834,7 +834,7 @@ class binary_reader
while (get() != 0xFF) while (get() != 0xFF)
{ {
string_t chunk; string_t chunk;
if (not get_cbor_string(chunk)) if (!get_cbor_string(chunk))
{ {
return false; return false;
} }
...@@ -864,7 +864,7 @@ class binary_reader ...@@ -864,7 +864,7 @@ class binary_reader
*/ */
bool get_cbor_binary(binary_t& result) bool get_cbor_binary(binary_t& result)
{ {
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "binary"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
{ {
return false; return false;
} }
...@@ -903,28 +903,28 @@ class binary_reader ...@@ -903,28 +903,28 @@ class binary_reader
case 0x58: // Binary data (one-byte uint8_t for n follows) case 0x58: // Binary data (one-byte uint8_t for n follows)
{ {
std::uint8_t len; std::uint8_t len;
return get_number(input_format_t::cbor, len) and return get_number(input_format_t::cbor, len) &&
get_binary(input_format_t::cbor, len, result); get_binary(input_format_t::cbor, len, result);
} }
case 0x59: // Binary data (two-byte uint16_t for n follow) case 0x59: // Binary data (two-byte uint16_t for n follow)
{ {
std::uint16_t len; std::uint16_t len;
return get_number(input_format_t::cbor, len) and return get_number(input_format_t::cbor, len) &&
get_binary(input_format_t::cbor, len, result); get_binary(input_format_t::cbor, len, result);
} }
case 0x5A: // Binary data (four-byte uint32_t for n follow) case 0x5A: // Binary data (four-byte uint32_t for n follow)
{ {
std::uint32_t len; std::uint32_t len;
return get_number(input_format_t::cbor, len) and return get_number(input_format_t::cbor, len) &&
get_binary(input_format_t::cbor, len, result); get_binary(input_format_t::cbor, len, result);
} }
case 0x5B: // Binary data (eight-byte uint64_t for n follow) case 0x5B: // Binary data (eight-byte uint64_t for n follow)
{ {
std::uint64_t len; std::uint64_t len;
return get_number(input_format_t::cbor, len) and return get_number(input_format_t::cbor, len) &&
get_binary(input_format_t::cbor, len, result); get_binary(input_format_t::cbor, len, result);
} }
...@@ -933,7 +933,7 @@ class binary_reader ...@@ -933,7 +933,7 @@ class binary_reader
while (get() != 0xFF) while (get() != 0xFF)
{ {
binary_t chunk; binary_t chunk;
if (not get_cbor_binary(chunk)) if (!get_cbor_binary(chunk))
{ {
return false; return false;
} }
...@@ -957,7 +957,7 @@ class binary_reader ...@@ -957,7 +957,7 @@ class binary_reader
*/ */
bool get_cbor_array(const std::size_t len) bool get_cbor_array(const std::size_t len)
{ {
if (JSON_HEDLEY_UNLIKELY(not sax->start_array(len))) if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
{ {
return false; return false;
} }
...@@ -966,7 +966,7 @@ class binary_reader ...@@ -966,7 +966,7 @@ class binary_reader
{ {
for (std::size_t i = 0; i < len; ++i) for (std::size_t i = 0; i < len; ++i)
{ {
if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal())) if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal()))
{ {
return false; return false;
} }
...@@ -976,7 +976,7 @@ class binary_reader ...@@ -976,7 +976,7 @@ class binary_reader
{ {
while (get() != 0xFF) while (get() != 0xFF)
{ {
if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal(false))) if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false)))
{ {
return false; return false;
} }
...@@ -993,7 +993,7 @@ class binary_reader ...@@ -993,7 +993,7 @@ class binary_reader
*/ */
bool get_cbor_object(const std::size_t len) bool get_cbor_object(const std::size_t len)
{ {
if (JSON_HEDLEY_UNLIKELY(not sax->start_object(len))) if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
{ {
return false; return false;
} }
...@@ -1004,12 +1004,12 @@ class binary_reader ...@@ -1004,12 +1004,12 @@ class binary_reader
for (std::size_t i = 0; i < len; ++i) for (std::size_t i = 0; i < len; ++i)
{ {
get(); get();
if (JSON_HEDLEY_UNLIKELY(not get_cbor_string(key) or not sax->key(key))) if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
{ {
return false; return false;
} }
if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal())) if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal()))
{ {
return false; return false;
} }
...@@ -1020,12 +1020,12 @@ class binary_reader ...@@ -1020,12 +1020,12 @@ class binary_reader
{ {
while (get() != 0xFF) while (get() != 0xFF)
{ {
if (JSON_HEDLEY_UNLIKELY(not get_cbor_string(key) or not sax->key(key))) if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
{ {
return false; return false;
} }
if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal())) if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal()))
{ {
return false; return false;
} }
...@@ -1258,7 +1258,7 @@ class binary_reader ...@@ -1258,7 +1258,7 @@ class binary_reader
case 0xDB: // str 32 case 0xDB: // str 32
{ {
string_t s; string_t s;
return get_msgpack_string(s) and sax->string(s); return get_msgpack_string(s) && sax->string(s);
} }
case 0xC0: // nil case 0xC0: // nil
...@@ -1283,91 +1283,91 @@ class binary_reader ...@@ -1283,91 +1283,91 @@ class binary_reader
case 0xD8: // fixext 16 case 0xD8: // fixext 16
{ {
binary_t b; binary_t b;
return get_msgpack_binary(b) and sax->binary(b); return get_msgpack_binary(b) && sax->binary(b);
} }
case 0xCA: // float 32 case 0xCA: // float 32
{ {
float number; float number;
return get_number(input_format_t::msgpack, number) and sax->number_float(static_cast<number_float_t>(number), ""); return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
} }
case 0xCB: // float 64 case 0xCB: // float 64
{ {
double number; double number;
return get_number(input_format_t::msgpack, number) and sax->number_float(static_cast<number_float_t>(number), ""); return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
} }
case 0xCC: // uint 8 case 0xCC: // uint 8
{ {
std::uint8_t number; std::uint8_t number;
return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number); return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
} }
case 0xCD: // uint 16 case 0xCD: // uint 16
{ {
std::uint16_t number; std::uint16_t number;
return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number); return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
} }
case 0xCE: // uint 32 case 0xCE: // uint 32
{ {
std::uint32_t number; std::uint32_t number;
return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number); return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
} }
case 0xCF: // uint 64 case 0xCF: // uint 64
{ {
std::uint64_t number; std::uint64_t number;
return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number); return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
} }
case 0xD0: // int 8 case 0xD0: // int 8
{ {
std::int8_t number; std::int8_t number;
return get_number(input_format_t::msgpack, number) and sax->number_integer(number); return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
} }
case 0xD1: // int 16 case 0xD1: // int 16
{ {
std::int16_t number; std::int16_t number;
return get_number(input_format_t::msgpack, number) and sax->number_integer(number); return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
} }
case 0xD2: // int 32 case 0xD2: // int 32
{ {
std::int32_t number; std::int32_t number;
return get_number(input_format_t::msgpack, number) and sax->number_integer(number); return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
} }
case 0xD3: // int 64 case 0xD3: // int 64
{ {
std::int64_t number; std::int64_t number;
return get_number(input_format_t::msgpack, number) and sax->number_integer(number); return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
} }
case 0xDC: // array 16 case 0xDC: // array 16
{ {
std::uint16_t len; std::uint16_t len;
return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len)); return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
} }
case 0xDD: // array 32 case 0xDD: // array 32
{ {
std::uint32_t len; std::uint32_t len;
return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len)); return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
} }
case 0xDE: // map 16 case 0xDE: // map 16
{ {
std::uint16_t len; std::uint16_t len;
return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len)); return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
} }
case 0xDF: // map 32 case 0xDF: // map 32
{ {
std::uint32_t len; std::uint32_t len;
return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len)); return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
} }
// negative fixint // negative fixint
...@@ -1425,7 +1425,7 @@ class binary_reader ...@@ -1425,7 +1425,7 @@ class binary_reader
*/ */
bool get_msgpack_string(string_t& result) bool get_msgpack_string(string_t& result)
{ {
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::msgpack, "string"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
{ {
return false; return false;
} }
...@@ -1472,19 +1472,19 @@ class binary_reader ...@@ -1472,19 +1472,19 @@ class binary_reader
case 0xD9: // str 8 case 0xD9: // str 8
{ {
std::uint8_t len; std::uint8_t len;
return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result); return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
} }
case 0xDA: // str 16 case 0xDA: // str 16
{ {
std::uint16_t len; std::uint16_t len;
return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result); return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
} }
case 0xDB: // str 32 case 0xDB: // str 32
{ {
std::uint32_t len; std::uint32_t len;
return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result); return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
} }
default: default:
...@@ -1519,21 +1519,21 @@ class binary_reader ...@@ -1519,21 +1519,21 @@ class binary_reader
case 0xC4: // bin 8 case 0xC4: // bin 8
{ {
std::uint8_t len; std::uint8_t len;
return get_number(input_format_t::msgpack, len) and return get_number(input_format_t::msgpack, len) &&
get_binary(input_format_t::msgpack, len, result); get_binary(input_format_t::msgpack, len, result);
} }
case 0xC5: // bin 16 case 0xC5: // bin 16
{ {
std::uint16_t len; std::uint16_t len;
return get_number(input_format_t::msgpack, len) and return get_number(input_format_t::msgpack, len) &&
get_binary(input_format_t::msgpack, len, result); get_binary(input_format_t::msgpack, len, result);
} }
case 0xC6: // bin 32 case 0xC6: // bin 32
{ {
std::uint32_t len; std::uint32_t len;
return get_number(input_format_t::msgpack, len) and return get_number(input_format_t::msgpack, len) &&
get_binary(input_format_t::msgpack, len, result); get_binary(input_format_t::msgpack, len, result);
} }
...@@ -1541,9 +1541,9 @@ class binary_reader ...@@ -1541,9 +1541,9 @@ class binary_reader
{ {
std::uint8_t len; std::uint8_t len;
std::int8_t subtype; std::int8_t subtype;
return get_number(input_format_t::msgpack, len) and return get_number(input_format_t::msgpack, len) &&
get_number(input_format_t::msgpack, subtype) and get_number(input_format_t::msgpack, subtype) &&
get_binary(input_format_t::msgpack, len, result) and get_binary(input_format_t::msgpack, len, result) &&
assign_and_return_true(subtype); assign_and_return_true(subtype);
} }
...@@ -1551,9 +1551,9 @@ class binary_reader ...@@ -1551,9 +1551,9 @@ class binary_reader
{ {
std::uint16_t len; std::uint16_t len;
std::int8_t subtype; std::int8_t subtype;
return get_number(input_format_t::msgpack, len) and return get_number(input_format_t::msgpack, len) &&
get_number(input_format_t::msgpack, subtype) and get_number(input_format_t::msgpack, subtype) &&
get_binary(input_format_t::msgpack, len, result) and get_binary(input_format_t::msgpack, len, result) &&
assign_and_return_true(subtype); assign_and_return_true(subtype);
} }
...@@ -1561,49 +1561,49 @@ class binary_reader ...@@ -1561,49 +1561,49 @@ class binary_reader
{ {
std::uint32_t len; std::uint32_t len;
std::int8_t subtype; std::int8_t subtype;
return get_number(input_format_t::msgpack, len) and return get_number(input_format_t::msgpack, len) &&
get_number(input_format_t::msgpack, subtype) and get_number(input_format_t::msgpack, subtype) &&
get_binary(input_format_t::msgpack, len, result) and get_binary(input_format_t::msgpack, len, result) &&
assign_and_return_true(subtype); assign_and_return_true(subtype);
} }
case 0xD4: // fixext 1 case 0xD4: // fixext 1
{ {
std::int8_t subtype; std::int8_t subtype;
return get_number(input_format_t::msgpack, subtype) and return get_number(input_format_t::msgpack, subtype) &&
get_binary(input_format_t::msgpack, 1, result) and get_binary(input_format_t::msgpack, 1, result) &&
assign_and_return_true(subtype); assign_and_return_true(subtype);
} }
case 0xD5: // fixext 2 case 0xD5: // fixext 2
{ {
std::int8_t subtype; std::int8_t subtype;
return get_number(input_format_t::msgpack, subtype) and return get_number(input_format_t::msgpack, subtype) &&
get_binary(input_format_t::msgpack, 2, result) and get_binary(input_format_t::msgpack, 2, result) &&
assign_and_return_true(subtype); assign_and_return_true(subtype);
} }
case 0xD6: // fixext 4 case 0xD6: // fixext 4
{ {
std::int8_t subtype; std::int8_t subtype;
return get_number(input_format_t::msgpack, subtype) and return get_number(input_format_t::msgpack, subtype) &&
get_binary(input_format_t::msgpack, 4, result) and get_binary(input_format_t::msgpack, 4, result) &&
assign_and_return_true(subtype); assign_and_return_true(subtype);
} }
case 0xD7: // fixext 8 case 0xD7: // fixext 8
{ {
std::int8_t subtype; std::int8_t subtype;
return get_number(input_format_t::msgpack, subtype) and return get_number(input_format_t::msgpack, subtype) &&
get_binary(input_format_t::msgpack, 8, result) and get_binary(input_format_t::msgpack, 8, result) &&
assign_and_return_true(subtype); assign_and_return_true(subtype);
} }
case 0xD8: // fixext 16 case 0xD8: // fixext 16
{ {
std::int8_t subtype; std::int8_t subtype;
return get_number(input_format_t::msgpack, subtype) and return get_number(input_format_t::msgpack, subtype) &&
get_binary(input_format_t::msgpack, 16, result) and get_binary(input_format_t::msgpack, 16, result) &&
assign_and_return_true(subtype); assign_and_return_true(subtype);
} }
...@@ -1618,14 +1618,14 @@ class binary_reader ...@@ -1618,14 +1618,14 @@ class binary_reader
*/ */
bool get_msgpack_array(const std::size_t len) bool get_msgpack_array(const std::size_t len)
{ {
if (JSON_HEDLEY_UNLIKELY(not sax->start_array(len))) if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
{ {
return false; return false;
} }
for (std::size_t i = 0; i < len; ++i) for (std::size_t i = 0; i < len; ++i)
{ {
if (JSON_HEDLEY_UNLIKELY(not parse_msgpack_internal())) if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
{ {
return false; return false;
} }
...@@ -1640,7 +1640,7 @@ class binary_reader ...@@ -1640,7 +1640,7 @@ class binary_reader
*/ */
bool get_msgpack_object(const std::size_t len) bool get_msgpack_object(const std::size_t len)
{ {
if (JSON_HEDLEY_UNLIKELY(not sax->start_object(len))) if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
{ {
return false; return false;
} }
...@@ -1649,12 +1649,12 @@ class binary_reader ...@@ -1649,12 +1649,12 @@ class binary_reader
for (std::size_t i = 0; i < len; ++i) for (std::size_t i = 0; i < len; ++i)
{ {
get(); get();
if (JSON_HEDLEY_UNLIKELY(not get_msgpack_string(key) or not sax->key(key))) if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
{ {
return false; return false;
} }
if (JSON_HEDLEY_UNLIKELY(not parse_msgpack_internal())) if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
{ {
return false; return false;
} }
...@@ -1701,7 +1701,7 @@ class binary_reader ...@@ -1701,7 +1701,7 @@ class binary_reader
get(); // TODO(niels): may we ignore N here? get(); // TODO(niels): may we ignore N here?
} }
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
{ {
return false; return false;
} }
...@@ -1711,31 +1711,31 @@ class binary_reader ...@@ -1711,31 +1711,31 @@ class binary_reader
case 'U': case 'U':
{ {
std::uint8_t len; std::uint8_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result); return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
} }
case 'i': case 'i':
{ {
std::int8_t len; std::int8_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result); return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
} }
case 'I': case 'I':
{ {
std::int16_t len; std::int16_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result); return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
} }
case 'l': case 'l':
{ {
std::int32_t len; std::int32_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result); return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
} }
case 'L': case 'L':
{ {
std::int64_t len; std::int64_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result); return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
} }
default: default:
...@@ -1755,7 +1755,7 @@ class binary_reader ...@@ -1755,7 +1755,7 @@ class binary_reader
case 'U': case 'U':
{ {
std::uint8_t number; std::uint8_t number;
if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number))) if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
{ {
return false; return false;
} }
...@@ -1766,7 +1766,7 @@ class binary_reader ...@@ -1766,7 +1766,7 @@ class binary_reader
case 'i': case 'i':
{ {
std::int8_t number; std::int8_t number;
if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number))) if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
{ {
return false; return false;
} }
...@@ -1777,7 +1777,7 @@ class binary_reader ...@@ -1777,7 +1777,7 @@ class binary_reader
case 'I': case 'I':
{ {
std::int16_t number; std::int16_t number;
if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number))) if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
{ {
return false; return false;
} }
...@@ -1788,7 +1788,7 @@ class binary_reader ...@@ -1788,7 +1788,7 @@ class binary_reader
case 'l': case 'l':
{ {
std::int32_t number; std::int32_t number;
if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number))) if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
{ {
return false; return false;
} }
...@@ -1799,7 +1799,7 @@ class binary_reader ...@@ -1799,7 +1799,7 @@ class binary_reader
case 'L': case 'L':
{ {
std::int64_t number; std::int64_t number;
if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number))) if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
{ {
return false; return false;
} }
...@@ -1835,7 +1835,7 @@ class binary_reader ...@@ -1835,7 +1835,7 @@ class binary_reader
if (current == '$') if (current == '$')
{ {
result.second = get(); // must not ignore 'N', because 'N' maybe the type result.second = get(); // must not ignore 'N', because 'N' maybe the type
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "type"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "type")))
{ {
return false; return false;
} }
...@@ -1843,7 +1843,7 @@ class binary_reader ...@@ -1843,7 +1843,7 @@ class binary_reader
get_ignore_noop(); get_ignore_noop();
if (JSON_HEDLEY_UNLIKELY(current != '#')) if (JSON_HEDLEY_UNLIKELY(current != '#'))
{ {
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
{ {
return false; return false;
} }
...@@ -1884,49 +1884,49 @@ class binary_reader ...@@ -1884,49 +1884,49 @@ class binary_reader
case 'U': case 'U':
{ {
std::uint8_t number; std::uint8_t number;
return get_number(input_format_t::ubjson, number) and sax->number_unsigned(number); return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
} }
case 'i': case 'i':
{ {
std::int8_t number; std::int8_t number;
return get_number(input_format_t::ubjson, number) and sax->number_integer(number); return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
} }
case 'I': case 'I':
{ {
std::int16_t number; std::int16_t number;
return get_number(input_format_t::ubjson, number) and sax->number_integer(number); return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
} }
case 'l': case 'l':
{ {
std::int32_t number; std::int32_t number;
return get_number(input_format_t::ubjson, number) and sax->number_integer(number); return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
} }
case 'L': case 'L':
{ {
std::int64_t number; std::int64_t number;
return get_number(input_format_t::ubjson, number) and sax->number_integer(number); return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
} }
case 'd': case 'd':
{ {
float number; float number;
return get_number(input_format_t::ubjson, number) and sax->number_float(static_cast<number_float_t>(number), ""); return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
} }
case 'D': case 'D':
{ {
double number; double number;
return get_number(input_format_t::ubjson, number) and sax->number_float(static_cast<number_float_t>(number), ""); return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
} }
case 'C': // char case 'C': // char
{ {
get(); get();
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "char"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "char")))
{ {
return false; return false;
} }
...@@ -1942,7 +1942,7 @@ class binary_reader ...@@ -1942,7 +1942,7 @@ class binary_reader
case 'S': // string case 'S': // string
{ {
string_t s; string_t s;
return get_ubjson_string(s) and sax->string(s); return get_ubjson_string(s) && sax->string(s);
} }
case '[': // array case '[': // array
...@@ -1965,14 +1965,14 @@ class binary_reader ...@@ -1965,14 +1965,14 @@ class binary_reader
bool get_ubjson_array() bool get_ubjson_array()
{ {
std::pair<std::size_t, int> size_and_type; std::pair<std::size_t, int> size_and_type;
if (JSON_HEDLEY_UNLIKELY(not get_ubjson_size_type(size_and_type))) if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
{ {
return false; return false;
} }
if (size_and_type.first != string_t::npos) if (size_and_type.first != string_t::npos)
{ {
if (JSON_HEDLEY_UNLIKELY(not sax->start_array(size_and_type.first))) if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
{ {
return false; return false;
} }
...@@ -1983,7 +1983,7 @@ class binary_reader ...@@ -1983,7 +1983,7 @@ class binary_reader
{ {
for (std::size_t i = 0; i < size_and_type.first; ++i) for (std::size_t i = 0; i < size_and_type.first; ++i)
{ {
if (JSON_HEDLEY_UNLIKELY(not get_ubjson_value(size_and_type.second))) if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
{ {
return false; return false;
} }
...@@ -1994,7 +1994,7 @@ class binary_reader ...@@ -1994,7 +1994,7 @@ class binary_reader
{ {
for (std::size_t i = 0; i < size_and_type.first; ++i) for (std::size_t i = 0; i < size_and_type.first; ++i)
{ {
if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal())) if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
{ {
return false; return false;
} }
...@@ -2003,14 +2003,14 @@ class binary_reader ...@@ -2003,14 +2003,14 @@ class binary_reader
} }
else else
{ {
if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1)))) if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
{ {
return false; return false;
} }
while (current != ']') while (current != ']')
{ {
if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal(false))) if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
{ {
return false; return false;
} }
...@@ -2027,7 +2027,7 @@ class binary_reader ...@@ -2027,7 +2027,7 @@ class binary_reader
bool get_ubjson_object() bool get_ubjson_object()
{ {
std::pair<std::size_t, int> size_and_type; std::pair<std::size_t, int> size_and_type;
if (JSON_HEDLEY_UNLIKELY(not get_ubjson_size_type(size_and_type))) if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
{ {
return false; return false;
} }
...@@ -2035,7 +2035,7 @@ class binary_reader ...@@ -2035,7 +2035,7 @@ class binary_reader
string_t key; string_t key;
if (size_and_type.first != string_t::npos) if (size_and_type.first != string_t::npos)
{ {
if (JSON_HEDLEY_UNLIKELY(not sax->start_object(size_and_type.first))) if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
{ {
return false; return false;
} }
...@@ -2044,11 +2044,11 @@ class binary_reader ...@@ -2044,11 +2044,11 @@ class binary_reader
{ {
for (std::size_t i = 0; i < size_and_type.first; ++i) for (std::size_t i = 0; i < size_and_type.first; ++i)
{ {
if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key) or not sax->key(key))) if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
{ {
return false; return false;
} }
if (JSON_HEDLEY_UNLIKELY(not get_ubjson_value(size_and_type.second))) if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
{ {
return false; return false;
} }
...@@ -2059,11 +2059,11 @@ class binary_reader ...@@ -2059,11 +2059,11 @@ class binary_reader
{ {
for (std::size_t i = 0; i < size_and_type.first; ++i) for (std::size_t i = 0; i < size_and_type.first; ++i)
{ {
if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key) or not sax->key(key))) if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
{ {
return false; return false;
} }
if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal())) if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
{ {
return false; return false;
} }
...@@ -2073,18 +2073,18 @@ class binary_reader ...@@ -2073,18 +2073,18 @@ class binary_reader
} }
else else
{ {
if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1)))) if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
{ {
return false; return false;
} }
while (current != '}') while (current != '}')
{ {
if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key, false) or not sax->key(key))) if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
{ {
return false; return false;
} }
if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal())) if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
{ {
return false; return false;
} }
...@@ -2153,7 +2153,7 @@ class binary_reader ...@@ -2153,7 +2153,7 @@ class binary_reader
for (std::size_t i = 0; i < sizeof(NumberType); ++i) for (std::size_t i = 0; i < sizeof(NumberType); ++i)
{ {
get(); get();
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "number"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
{ {
return false; return false;
} }
...@@ -2197,7 +2197,7 @@ class binary_reader ...@@ -2197,7 +2197,7 @@ class binary_reader
std::generate_n(std::back_inserter(result), len, [this, &success, &format]() std::generate_n(std::back_inserter(result), len, [this, &success, &format]()
{ {
get(); get();
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "string"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
{ {
success = false; success = false;
} }
...@@ -2229,7 +2229,7 @@ class binary_reader ...@@ -2229,7 +2229,7 @@ class binary_reader
std::generate_n(std::back_inserter(result), len, [this, &success, &format]() std::generate_n(std::back_inserter(result), len, [this, &success, &format]()
{ {
get(); get();
if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "binary"))) if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
{ {
success = false; success = false;
} }
......
...@@ -131,7 +131,7 @@ class input_buffer_adapter ...@@ -131,7 +131,7 @@ class input_buffer_adapter
{ {
if (JSON_HEDLEY_LIKELY(cursor < limit)) if (JSON_HEDLEY_LIKELY(cursor < limit))
{ {
assert(cursor != nullptr and limit != nullptr); assert(cursor != nullptr && limit != nullptr);
return std::char_traits<char>::to_int_type(*(cursor++)); return std::char_traits<char>::to_int_type(*(cursor++));
} }
...@@ -238,7 +238,7 @@ struct wide_string_input_helper<WideStringType, 2> ...@@ -238,7 +238,7 @@ struct wide_string_input_helper<WideStringType, 2>
utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu)); utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (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 | ((wc >> 12u))); utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((wc >> 12u)));
utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu)); utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu));
...@@ -331,24 +331,24 @@ inline input_stream_adapter input_adapter(std::istream&& stream) ...@@ -331,24 +331,24 @@ inline input_stream_adapter input_adapter(std::istream&& stream)
return input_stream_adapter(stream); return input_stream_adapter(stream);
} }
template<typename CharT, typename SizeT, template < typename CharT, typename SizeT,
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&&
not std::is_same<SizeT, bool>::value and !std::is_same<SizeT, bool>::value&&
sizeof(typename std::remove_pointer<CharT>::type) == 1, sizeof(typename std::remove_pointer<CharT>::type) == 1,
int>::type = 0> int >::type = 0 >
input_buffer_adapter input_adapter(CharT b, SizeT l) input_buffer_adapter input_adapter(CharT b, SizeT l)
{ {
return input_buffer_adapter(reinterpret_cast<const char*>(b), l); return input_buffer_adapter(reinterpret_cast<const char*>(b), l);
} }
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 >
input_buffer_adapter input_adapter(CharT b) input_buffer_adapter input_adapter(CharT b)
{ {
return input_adapter(reinterpret_cast<const char*>(b), return input_adapter(reinterpret_cast<const char*>(b),
...@@ -408,10 +408,10 @@ inline wide_string_input_adapter<std::u32string> input_adapter(const std::u32str ...@@ -408,10 +408,10 @@ inline wide_string_input_adapter<std::u32string> input_adapter(const std::u32str
return wide_string_input_adapter<std::u32string>(ws); return wide_string_input_adapter<std::u32string>(ws);
} }
template<class ContiguousContainer, typename template < class ContiguousContainer, typename
std::enable_if<not std::is_pointer<ContiguousContainer>::value and std::enable_if < !std::is_pointer<ContiguousContainer>::value&&
std::is_base_of<std::random_access_iterator_tag, typename iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value, std::is_base_of<std::random_access_iterator_tag, typename iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value,
int>::type = 0> int >::type = 0 >
input_buffer_adapter input_adapter(const ContiguousContainer& c) input_buffer_adapter input_adapter(const ContiguousContainer& c)
{ {
return input_adapter(std::begin(c), std::end(c)); return input_adapter(std::begin(c), std::end(c));
...@@ -430,21 +430,21 @@ input_buffer_adapter input_adapter(T (&array)[N]) ...@@ -430,21 +430,21 @@ input_buffer_adapter input_adapter(T (&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), l) {} : ia(reinterpret_cast<const char*>(b), l) {}
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) span_input_adapter(CharT b)
: span_input_adapter(reinterpret_cast<const char*>(b), : span_input_adapter(reinterpret_cast<const char*>(b),
std::strlen(reinterpret_cast<const char*>(b))) {} std::strlen(reinterpret_cast<const char*>(b))) {}
...@@ -461,10 +461,10 @@ class span_input_adapter ...@@ -461,10 +461,10 @@ class span_input_adapter
: span_input_adapter(std::begin(array), std::end(array)) {} : span_input_adapter(std::begin(array), std::end(array)) {}
/// input adapter for contiguous container /// input adapter for contiguous container
template<class ContiguousContainer, typename template < class ContiguousContainer, typename
std::enable_if<not std::is_pointer<ContiguousContainer>::value and std::enable_if < !std::is_pointer<ContiguousContainer>::value&&
std::is_base_of<std::random_access_iterator_tag, typename iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value, std::is_base_of<std::random_access_iterator_tag, typename iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value,
int>::type = 0> int >::type = 0 >
span_input_adapter(const ContiguousContainer& c) span_input_adapter(const ContiguousContainer& c)
: span_input_adapter(std::begin(c), std::end(c)) {} : span_input_adapter(std::begin(c), std::end(c)) {}
......
...@@ -218,7 +218,7 @@ class json_sax_dom_parser ...@@ -218,7 +218,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)));
...@@ -244,7 +244,7 @@ class json_sax_dom_parser ...@@ -244,7 +244,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)));
...@@ -309,7 +309,7 @@ class json_sax_dom_parser ...@@ -309,7 +309,7 @@ class json_sax_dom_parser
return &root; return &root;
} }
assert(ref_stack.back()->is_array() or ref_stack.back()->is_object()); assert(ref_stack.back()->is_array() || ref_stack.back()->is_object());
if (ref_stack.back()->is_array()) if (ref_stack.back()->is_array())
{ {
...@@ -414,7 +414,7 @@ class json_sax_dom_callback_parser ...@@ -414,7 +414,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)));
} }
...@@ -431,7 +431,7 @@ class json_sax_dom_callback_parser ...@@ -431,7 +431,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);
} }
...@@ -441,18 +441,18 @@ class json_sax_dom_callback_parser ...@@ -441,18 +441,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;
} }
assert(not ref_stack.empty()); assert(!ref_stack.empty());
assert(not keep_stack.empty()); 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)
...@@ -477,7 +477,7 @@ class json_sax_dom_callback_parser ...@@ -477,7 +477,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)));
} }
...@@ -492,20 +492,20 @@ class json_sax_dom_callback_parser ...@@ -492,20 +492,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;
} }
} }
assert(not ref_stack.empty()); assert(!ref_stack.empty());
assert(not keep_stack.empty()); 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();
} }
...@@ -565,11 +565,11 @@ class json_sax_dom_callback_parser ...@@ -565,11 +565,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)
{ {
assert(not keep_stack.empty()); 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};
} }
...@@ -578,10 +578,10 @@ class json_sax_dom_callback_parser ...@@ -578,10 +578,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};
} }
...@@ -594,13 +594,13 @@ class json_sax_dom_callback_parser ...@@ -594,13 +594,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
assert(ref_stack.back()->is_array() or ref_stack.back()->is_object()); 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())
...@@ -612,11 +612,11 @@ class json_sax_dom_callback_parser ...@@ -612,11 +612,11 @@ class json_sax_dom_callback_parser
// object // object
assert(ref_stack.back()->is_object()); 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
assert(not key_keep_stack.empty()); 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};
} }
......
...@@ -164,15 +164,15 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -164,15 +164,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);
} }
...@@ -182,7 +182,7 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -182,7 +182,7 @@ class lexer : public lexer_base<BasicJsonType>
} }
} }
assert(0x0000 <= codepoint and codepoint <= 0xFFFF); assert(0x0000 <= codepoint && codepoint <= 0xFFFF);
return codepoint; return codepoint;
} }
...@@ -203,13 +203,13 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -203,13 +203,13 @@ class lexer : public lexer_base<BasicJsonType>
*/ */
bool next_byte_in_range(std::initializer_list<int> ranges) bool next_byte_in_range(std::initializer_list<int> ranges)
{ {
assert(ranges.size() == 2 or ranges.size() == 4 or ranges.size() == 6); 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);
} }
...@@ -315,10 +315,10 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -315,10 +315,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();
...@@ -329,7 +329,7 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -329,7 +329,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>(
...@@ -356,7 +356,7 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -356,7 +356,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;
...@@ -364,7 +364,7 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -364,7 +364,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
assert(0x00 <= codepoint and codepoint <= 0x10FFFF); assert(0x00 <= codepoint && codepoint <= 0x10FFFF);
// translate codepoint into bytes // translate codepoint into bytes
if (codepoint < 0x80) if (codepoint < 0x80)
...@@ -731,7 +731,7 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -731,7 +731,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;
} }
...@@ -741,7 +741,7 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -741,7 +741,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;
} }
...@@ -765,7 +765,7 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -765,7 +765,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;
} }
...@@ -775,7 +775,7 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -775,7 +775,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;
} }
...@@ -785,7 +785,7 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -785,7 +785,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;
} }
...@@ -797,7 +797,7 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -797,7 +797,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;
} }
...@@ -807,7 +807,7 @@ class lexer : public lexer_base<BasicJsonType> ...@@ -807,7 +807,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;
} }
...@@ -1308,7 +1308,7 @@ scan_number_done: ...@@ -1308,7 +1308,7 @@ scan_number_done:
if (JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof())) if (JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof()))
{ {
assert(not token_string.empty()); assert(!token_string.empty());
token_string.pop_back(); token_string.pop_back();
} }
} }
...@@ -1404,7 +1404,7 @@ scan_number_done: ...@@ -1404,7 +1404,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
...@@ -1416,7 +1416,7 @@ scan_number_done: ...@@ -1416,7 +1416,7 @@ scan_number_done:
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;
...@@ -1427,7 +1427,7 @@ scan_number_done: ...@@ -1427,7 +1427,7 @@ scan_number_done:
{ {
get(); get();
} }
while (current == ' ' or current == '\t' or current == '\n' or current == '\r'); while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
switch (current) switch (current)
{ {
......
...@@ -89,7 +89,7 @@ class parser ...@@ -89,7 +89,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(),
...@@ -118,7 +118,7 @@ class parser ...@@ -118,7 +118,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(),
...@@ -147,7 +147,7 @@ class parser ...@@ -147,7 +147,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)
{ {
...@@ -155,7 +155,7 @@ class parser ...@@ -155,7 +155,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(),
...@@ -167,7 +167,7 @@ class parser ...@@ -167,7 +167,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)
{ {
...@@ -179,14 +179,14 @@ class parser ...@@ -179,14 +179,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;
} }
...@@ -194,7 +194,7 @@ class parser ...@@ -194,7 +194,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;
} }
...@@ -209,7 +209,7 @@ class parser ...@@ -209,7 +209,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;
} }
...@@ -233,7 +233,7 @@ class parser ...@@ -233,7 +233,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;
} }
...@@ -241,7 +241,7 @@ class parser ...@@ -241,7 +241,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;
} }
...@@ -259,14 +259,14 @@ class parser ...@@ -259,14 +259,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;
} }
...@@ -276,7 +276,7 @@ class parser ...@@ -276,7 +276,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;
} }
...@@ -285,7 +285,7 @@ class parser ...@@ -285,7 +285,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;
} }
...@@ -294,7 +294,7 @@ class parser ...@@ -294,7 +294,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;
} }
...@@ -303,7 +303,7 @@ class parser ...@@ -303,7 +303,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;
} }
...@@ -312,7 +312,7 @@ class parser ...@@ -312,7 +312,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;
} }
...@@ -321,7 +321,7 @@ class parser ...@@ -321,7 +321,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;
} }
...@@ -371,7 +371,7 @@ class parser ...@@ -371,7 +371,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;
} }
...@@ -380,7 +380,7 @@ class parser ...@@ -380,7 +380,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.
assert(not states.empty()); assert(!states.empty());
states.pop_back(); states.pop_back();
skip_to_state_evaluation = true; skip_to_state_evaluation = true;
continue; continue;
...@@ -405,7 +405,7 @@ class parser ...@@ -405,7 +405,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;
} }
...@@ -427,7 +427,7 @@ class parser ...@@ -427,7 +427,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;
} }
...@@ -436,7 +436,7 @@ class parser ...@@ -436,7 +436,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.
assert(not states.empty()); assert(!states.empty());
states.pop_back(); states.pop_back();
skip_to_state_evaluation = true; skip_to_state_evaluation = true;
continue; continue;
...@@ -460,7 +460,7 @@ class parser ...@@ -460,7 +460,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 + " ";
} }
......
...@@ -423,7 +423,7 @@ class iter_impl ...@@ -423,7 +423,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 +459,7 @@ class iter_impl ...@@ -459,7 +459,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 +468,7 @@ class iter_impl ...@@ -468,7 +468,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 +477,7 @@ class iter_impl ...@@ -477,7 +477,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);
} }
/*! /*!
......
...@@ -17,7 +17,7 @@ void int_to_string( string_type& target, std::size_t value ) ...@@ -17,7 +17,7 @@ void int_to_string( string_type& target, std::size_t value )
{ {
target = std::to_string(value); target = std::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;
...@@ -131,7 +131,7 @@ template<typename IteratorType> class iteration_proxy ...@@ -131,7 +131,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();
...@@ -139,7 +139,7 @@ auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decl ...@@ -139,7 +139,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();
...@@ -158,11 +158,11 @@ namespace std ...@@ -158,11 +158,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:
......
...@@ -9,10 +9,10 @@ namespace nlohmann ...@@ -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 < ...@@ -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;
......
...@@ -330,7 +330,7 @@ class json_pointer ...@@ -330,7 +330,7 @@ class json_pointer
static int array_index(const std::string& s) static int array_index(const std::string& s)
{ {
// 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 +
...@@ -338,7 +338,7 @@ class json_pointer ...@@ -338,7 +338,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"));
} }
...@@ -473,7 +473,7 @@ class json_pointer ...@@ -473,7 +473,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;
} }
...@@ -661,7 +661,7 @@ class json_pointer ...@@ -661,7 +661,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;
...@@ -678,21 +678,21 @@ class json_pointer ...@@ -678,21 +678,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;
...@@ -779,8 +779,8 @@ class json_pointer ...@@ -779,8 +779,8 @@ class json_pointer
assert(reference_token[pos] == '~'); 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'"));
...@@ -811,7 +811,7 @@ class json_pointer ...@@ -811,7 +811,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)
{ {
assert(not f.empty()); 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
...@@ -906,7 +906,7 @@ class json_pointer ...@@ -906,7 +906,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"));
} }
...@@ -916,7 +916,7 @@ class json_pointer ...@@ -916,7 +916,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"));
} }
...@@ -962,7 +962,7 @@ class json_pointer ...@@ -962,7 +962,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
......
...@@ -19,39 +19,39 @@ struct nonesuch ...@@ -19,39 +19,39 @@ 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
{ {
using value_t = std::false_type; using value_t = std::false_type;
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
......
...@@ -11,53 +11,53 @@ namespace nlohmann ...@@ -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 ...@@ -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:
......
...@@ -45,59 +45,59 @@ struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {}; ...@@ -45,59 +45,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 +108,11 @@ struct has_from_json<BasicJsonType, T, ...@@ -108,11 +108,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 +123,11 @@ struct has_non_default_from_json<BasicJsonType, T, enable_if_t<not is_basic_json ...@@ -123,11 +123,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 +141,10 @@ struct has_to_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>> ...@@ -141,10 +141,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 +161,20 @@ struct is_iterator_traits<iterator_traits<T>> ...@@ -161,20 +161,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 +183,53 @@ struct is_compatible_object_type_impl < ...@@ -183,53 +183,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 +239,15 @@ struct is_compatible_string_type_impl < ...@@ -239,15 +239,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 +258,55 @@ struct is_constructible_string_type_impl < ...@@ -258,55 +258,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 +314,30 @@ detected_t<value_type_t, ConstructibleArrayType>>::value >> ...@@ -314,30 +314,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 +345,20 @@ struct is_compatible_integer_type_impl < ...@@ -345,20 +345,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 +367,7 @@ struct is_compatible_type_impl < ...@@ -367,7 +367,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 +378,10 @@ template<class B1, class... Bn> ...@@ -378,10 +378,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,10 +4,10 @@ namespace nlohmann ...@@ -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
...@@ -194,8 +194,8 @@ class binary_writer ...@@ -194,8 +194,8 @@ class binary_writer
} }
else else
{ {
if (static_cast<double>(j.m_value.number_float) >= static_cast<double>(std::numeric_limits<float>::lowest()) and if (static_cast<double>(j.m_value.number_float) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
static_cast<double>(j.m_value.number_float) <= static_cast<double>((std::numeric_limits<float>::max)()) and static_cast<double>(j.m_value.number_float) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
static_cast<double>(static_cast<float>(j.m_value.number_float)) == static_cast<double>(j.m_value.number_float)) static_cast<double>(static_cast<float>(j.m_value.number_float)) == static_cast<double>(j.m_value.number_float))
{ {
oa->write_character(get_cbor_float_prefix(static_cast<float>(j.m_value.number_float))); oa->write_character(get_cbor_float_prefix(static_cast<float>(j.m_value.number_float)));
...@@ -436,28 +436,28 @@ class binary_writer ...@@ -436,28 +436,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
...@@ -619,7 +619,7 @@ class binary_writer ...@@ -619,7 +619,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));
} }
...@@ -775,7 +775,7 @@ class binary_writer ...@@ -775,7 +775,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())
{ {
assert(use_count); assert(use_count);
const CharType first_prefix = ubjson_prefix(j.front()); const CharType first_prefix = ubjson_prefix(j.front());
...@@ -804,7 +804,7 @@ class binary_writer ...@@ -804,7 +804,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(']'));
} }
...@@ -819,7 +819,7 @@ class binary_writer ...@@ -819,7 +819,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())
{ {
assert(use_count); assert(use_count);
oa->write_character(to_char_type('$')); oa->write_character(to_char_type('$'));
...@@ -847,7 +847,7 @@ class binary_writer ...@@ -847,7 +847,7 @@ class binary_writer
} }
} }
if (not use_count) if (!use_count)
{ {
oa->write_character(to_char_type(']')); oa->write_character(to_char_type(']'));
} }
...@@ -863,7 +863,7 @@ class binary_writer ...@@ -863,7 +863,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())
{ {
assert(use_count); assert(use_count);
const CharType first_prefix = ubjson_prefix(j.front()); const CharType first_prefix = ubjson_prefix(j.front());
...@@ -896,7 +896,7 @@ class binary_writer ...@@ -896,7 +896,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('}'));
} }
...@@ -997,7 +997,7 @@ class binary_writer ...@@ -997,7 +997,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);
} }
...@@ -1008,7 +1008,7 @@ class binary_writer ...@@ -1008,7 +1008,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));
...@@ -1341,13 +1341,13 @@ class binary_writer ...@@ -1341,13 +1341,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)
{ {
...@@ -1355,7 +1355,7 @@ class binary_writer ...@@ -1355,7 +1355,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)
{ {
...@@ -1363,7 +1363,7 @@ class binary_writer ...@@ -1363,7 +1363,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)
{ {
...@@ -1371,7 +1371,7 @@ class binary_writer ...@@ -1371,7 +1371,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)
{ {
...@@ -1379,7 +1379,7 @@ class binary_writer ...@@ -1379,7 +1379,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)
{ {
...@@ -1416,19 +1416,19 @@ class binary_writer ...@@ -1416,19 +1416,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';
} }
...@@ -1524,14 +1524,14 @@ class binary_writer ...@@ -1524,14 +1524,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");
...@@ -1550,8 +1550,8 @@ class binary_writer ...@@ -1550,8 +1550,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
......
...@@ -205,7 +205,7 @@ class serializer ...@@ -205,7 +205,7 @@ class serializer
} }
// last element // last element
assert(not val.m_value.array->empty()); 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);
...@@ -226,7 +226,7 @@ class serializer ...@@ -226,7 +226,7 @@ class serializer
} }
// last element // last element
assert(not val.m_value.array->empty()); 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(']');
...@@ -260,7 +260,7 @@ class serializer ...@@ -260,7 +260,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)
...@@ -291,7 +291,7 @@ class serializer ...@@ -291,7 +291,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)
...@@ -452,7 +452,7 @@ class serializer ...@@ -452,7 +452,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)
{ {
...@@ -566,7 +566,7 @@ class serializer ...@@ -566,7 +566,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];
...@@ -670,11 +670,11 @@ class serializer ...@@ -670,11 +670,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
...@@ -703,7 +703,7 @@ class serializer ...@@ -703,7 +703,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;
...@@ -764,7 +764,7 @@ class serializer ...@@ -764,7 +764,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;
...@@ -776,8 +776,8 @@ class serializer ...@@ -776,8 +776,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>());
} }
...@@ -814,7 +814,7 @@ class serializer ...@@ -814,7 +814,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())
...@@ -830,7 +830,7 @@ class serializer ...@@ -830,7 +830,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)
...@@ -916,7 +916,7 @@ class serializer ...@@ -916,7 +916,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
{ {
assert(x < 0 and x < (std::numeric_limits<number_integer_t>::max)()); 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;
} }
......
...@@ -77,7 +77,7 @@ inline bool operator<(const value_t lhs, const value_t rhs) noexcept ...@@ -77,7 +77,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
...@@ -1135,7 +1135,7 @@ class basic_json ...@@ -1135,7 +1135,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()));
...@@ -1217,10 +1217,10 @@ class basic_json ...@@ -1217,10 +1217,10 @@ class basic_json
*/ */
void assert_invariant() const noexcept void assert_invariant() const noexcept
{ {
assert(m_type != value_t::object or m_value.object != nullptr); assert(m_type != value_t::object || m_value.object != nullptr);
assert(m_type != value_t::array or m_value.array != nullptr); assert(m_type != value_t::array || m_value.array != nullptr);
assert(m_type != value_t::string or m_value.string != nullptr); assert(m_type != value_t::string || m_value.string != nullptr);
assert(m_type != value_t::binary or m_value.binary != nullptr); assert(m_type != value_t::binary || m_value.binary != nullptr);
} }
public: public:
...@@ -1428,10 +1428,10 @@ class basic_json ...@@ -1428,10 +1428,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))))
...@@ -1466,9 +1466,9 @@ class basic_json ...@@ -1466,9 +1466,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;
...@@ -1601,11 +1601,11 @@ class basic_json ...@@ -1601,11 +1601,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)
...@@ -1614,7 +1614,7 @@ class basic_json ...@@ -1614,7 +1614,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"));
} }
...@@ -1908,9 +1908,9 @@ class basic_json ...@@ -1908,9 +1908,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)
{ {
assert(first.m_object != nullptr); assert(first.m_object != nullptr);
...@@ -1934,8 +1934,8 @@ class basic_json ...@@ -1934,8 +1934,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"));
} }
...@@ -2011,9 +2011,9 @@ class basic_json ...@@ -2011,9 +2011,9 @@ 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()) {}
/*! /*!
...@@ -2168,9 +2168,9 @@ class basic_json ...@@ -2168,9 +2168,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
) )
{ {
...@@ -2349,7 +2349,7 @@ class basic_json ...@@ -2349,7 +2349,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();
} }
/*! /*!
...@@ -2376,7 +2376,7 @@ class basic_json ...@@ -2376,7 +2376,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();
} }
/*! /*!
...@@ -2450,7 +2450,7 @@ class basic_json ...@@ -2450,7 +2450,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();
} }
/*! /*!
...@@ -2479,7 +2479,7 @@ class basic_json ...@@ -2479,7 +2479,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;
} }
/*! /*!
...@@ -2860,9 +2860,9 @@ class basic_json ...@@ -2860,9 +2860,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;
...@@ -2907,19 +2907,19 @@ class basic_json ...@@ -2907,19 +2907,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()");
...@@ -2960,14 +2960,14 @@ class basic_json ...@@ -2960,14 +2960,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);
} }
...@@ -3005,11 +3005,11 @@ class basic_json ...@@ -3005,11 +3005,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)))
{ {
...@@ -3069,9 +3069,9 @@ class basic_json ...@@ -3069,9 +3069,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
...@@ -3163,9 +3163,9 @@ class basic_json ...@@ -3163,9 +3163,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
...@@ -3202,15 +3202,15 @@ class basic_json ...@@ -3202,15 +3202,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
{ {
...@@ -3229,7 +3229,7 @@ class basic_json ...@@ -3229,7 +3229,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())));
} }
...@@ -3240,7 +3240,7 @@ class basic_json ...@@ -3240,7 +3240,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())));
} }
...@@ -3767,9 +3767,9 @@ class basic_json ...@@ -3767,9 +3767,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
...@@ -4003,10 +4003,10 @@ class basic_json ...@@ -4003,10 +4003,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
...@@ -4026,7 +4026,7 @@ class basic_json ...@@ -4026,7 +4026,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"));
} }
...@@ -4116,14 +4116,14 @@ class basic_json ...@@ -4116,14 +4116,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"));
} }
...@@ -4139,8 +4139,8 @@ class basic_json ...@@ -4139,8 +4139,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"));
} }
...@@ -4385,11 +4385,11 @@ class basic_json ...@@ -4385,11 +4385,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();
} }
/*! /*!
...@@ -5207,7 +5207,7 @@ class basic_json ...@@ -5207,7 +5207,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())));
} }
...@@ -5242,7 +5242,7 @@ class basic_json ...@@ -5242,7 +5242,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())));
} }
...@@ -5292,7 +5292,7 @@ class basic_json ...@@ -5292,7 +5292,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())));
} }
...@@ -5346,7 +5346,7 @@ class basic_json ...@@ -5346,7 +5346,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(
...@@ -5395,7 +5395,7 @@ class basic_json ...@@ -5395,7 +5395,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())));
} }
...@@ -5448,7 +5448,7 @@ class basic_json ...@@ -5448,7 +5448,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())));
} }
...@@ -5615,7 +5615,7 @@ class basic_json ...@@ -5615,7 +5615,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())));
} }
...@@ -5668,7 +5668,7 @@ class basic_json ...@@ -5668,7 +5668,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())));
} }
...@@ -5709,7 +5709,7 @@ class basic_json ...@@ -5709,7 +5709,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())));
} }
...@@ -5721,7 +5721,7 @@ class basic_json ...@@ -5721,7 +5721,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"));
} }
...@@ -5758,11 +5758,11 @@ class basic_json ...@@ -5758,11 +5758,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())));
} }
...@@ -5809,7 +5809,7 @@ class basic_json ...@@ -5809,7 +5809,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())));
} }
...@@ -5821,8 +5821,8 @@ class basic_json ...@@ -5821,8 +5821,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"));
} }
...@@ -5851,9 +5851,9 @@ class basic_json ...@@ -5851,9 +5851,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
) )
{ {
...@@ -6113,27 +6113,27 @@ class basic_json ...@@ -6113,27 +6113,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);
} }
...@@ -6183,7 +6183,7 @@ class basic_json ...@@ -6183,7 +6183,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);
} }
/*! /*!
...@@ -6276,27 +6276,27 @@ class basic_json ...@@ -6276,27 +6276,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;
} }
...@@ -6350,7 +6350,7 @@ class basic_json ...@@ -6350,7 +6350,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);
} }
/*! /*!
...@@ -6396,7 +6396,7 @@ class basic_json ...@@ -6396,7 +6396,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);
} }
/*! /*!
...@@ -6442,7 +6442,7 @@ class basic_json ...@@ -6442,7 +6442,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);
} }
/*! /*!
...@@ -6695,7 +6695,7 @@ class basic_json ...@@ -6695,7 +6695,7 @@ class basic_json
@since version 3.2.0 @since version 3.2.0
*/ */
template <typename SAX, typename InputType> template<typename SAX, typename InputType>
JSON_HEDLEY_NON_NULL(2) JSON_HEDLEY_NON_NULL(2)
static bool sax_parse(InputType&& i, SAX* sax, static bool sax_parse(InputType&& i, SAX* sax,
input_format_t format = input_format_t::json, input_format_t format = input_format_t::json,
...@@ -6707,7 +6707,7 @@ class basic_json ...@@ -6707,7 +6707,7 @@ class basic_json
: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict); : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
} }
template <typename SAX> template<typename SAX>
JSON_HEDLEY_NON_NULL(2) JSON_HEDLEY_NON_NULL(2)
static bool sax_parse(detail::span_input_adapter&& i, SAX* sax, static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
input_format_t format = input_format_t::json, input_format_t format = input_format_t::json,
...@@ -8211,7 +8211,7 @@ class basic_json ...@@ -8211,7 +8211,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"));
} }
...@@ -8237,7 +8237,7 @@ class basic_json ...@@ -8237,7 +8237,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 + "'"));
} }
...@@ -8247,7 +8247,7 @@ class basic_json ...@@ -8247,7 +8247,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"));
} }
...@@ -8325,7 +8325,7 @@ class basic_json ...@@ -8325,7 +8325,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()));
} }
...@@ -8407,7 +8407,7 @@ class basic_json ...@@ -8407,7 +8407,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));
...@@ -8558,7 +8558,7 @@ class basic_json ...@@ -8558,7 +8558,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();
} }
...@@ -8648,7 +8648,7 @@ struct less<::nlohmann::detail::value_t> ...@@ -8648,7 +8648,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
) )
{ {
......
This source diff could not be displayed because it is too large. You can view the blob instead.
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment