Merge pull request #2259 from nlohmann/clang_windows

Make library work with Clang on Windows

.github/workflows/windows_clang.yml

@@ -0,0 +1,32 @@
+name: Windows
+
+on: [push, pull_request]
+
+jobs:
+ clang9:
+ runs-on: windows-latest
+
+ steps:
+ - uses: actions/checkout@v1
+ - name: install Clang
+ run: curl -fsSL -o LLVM9.exe https://releases.llvm.org/9.0.0/LLVM-9.0.0-win64.exe ; 7z x LLVM9.exe -y -o"C:/Program Files/LLVM"
+ - name: cmake
+ run: cmake -S . -B build -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" -G"MinGW Makefiles" -DCMAKE_BUILD_TYPE=Debug -DJSON_BuildTests=On
+ - name: build
+ run: cmake --build build --parallel 10
+ - name: test
+ run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
+
+ clang10:
+ runs-on: windows-latest
+
+ steps:
+ - uses: actions/checkout@v1
+ - name: install Clang
+ run: curl -fsSL -o LLVM10.exe https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.0/LLVM-10.0.0-win64.exe ; 7z x LLVM10.exe -y -o"C:/Program Files/LLVM"
+ - name: cmake
+ run: cmake -S . -B build -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" -G"MinGW Makefiles" -DCMAKE_BUILD_TYPE=Debug -DJSON_BuildTests=On
+ - name: build
+ run: cmake --build build --parallel 10
+ - name: test
+ run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure

include/nlohmann/adl_serializer.hpp

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

include/nlohmann/detail/conversions/from_json.hpp

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

include/nlohmann/detail/conversions/to_chars.hpp

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