Fix value to_number warning for lossy conversion

Author: vinniefalco

include/boost/json/detail/value.hpp

@@ -13,6 +13,7 @@
 #include <boost/json/kind.hpp>
 #include <boost/json/storage_ptr.hpp>
 #include <cstdint>
+#include <limits>
 #include <new>
 #include <utility>
 
@@ -23,6 +24,142 @@ struct key_t
 {
 };
 
+#if 0
+template<class T>
+struct to_number_limit
+ : std::numeric_limits<T>
+{
+};
+
+template<class T>
+struct to_number_limit<T const>
+ : to_number_limit<T>
+{
+};
+
+template<>
+struct to_number_limit<long long>
+{
+ static constexpr long long (min)() noexcept
+ {
+ return -9223372036854774784;
+ }
+
+ static constexpr long long (max)() noexcept
+ {
+ return 9223372036854774784;
+ }
+};
+
+template<>
+struct to_number_limit<unsigned long long>
+{
+ static constexpr
+ unsigned long long (min)() noexcept
+ {
+ return 0;
+ }
+
+ static constexpr
+ unsigned long long (max)() noexcept
+ {
+ return 18446744073709549568ULL;
+ }
+};
+#else
+
+template<class T>
+class to_number_limit
+{
+ // unsigned
+
+ static constexpr
+ double min1(std::false_type)
+ {
+ return 0.0;
+ }
+
+ static constexpr
+ double max1(std::false_type)
+ {
+ return max2u(std::integral_constant<
+ bool, (std::numeric_limits<T>::max)() ==
+ UINT64_MAX>{});
+ }
+
+ static constexpr
+ double max2u(std::false_type)
+ {
+ return static_cast<double>(
+ (std::numeric_limits<T>::max)());
+ }
+
+ static constexpr
+ double max2u(std::true_type)
+ {
+ return 18446744073709549568.0;
+ }
+
+ // signed
+
+ static constexpr
+ double min1(std::true_type)
+ {
+ return min2s(std::integral_constant<
+ bool, (std::numeric_limits<T>::max)() ==
+ INT64_MAX>{});
+ }
+
+ static constexpr
+ double min2s(std::false_type)
+ {
+ return static_cast<double>(
+ (std::numeric_limits<T>::min)());
+ }
+
+ static constexpr
+ double min2s(std::true_type)
+ {
+ return -9223372036854774784.0;
+ }
+
+ static constexpr
+ double max1(std::true_type)
+ {
+ return max2s(std::integral_constant<
+ bool, (std::numeric_limits<T>::max)() ==
+ INT64_MAX>{});
+ }
+
+ static constexpr
+ double max2s(std::false_type)
+ {
+ return static_cast<double>(
+ (std::numeric_limits<T>::max)());
+ }
+
+ static constexpr
+ double max2s(std::true_type)
+ {
+ return 9223372036854774784.0;
+ }
+
+public:
+ static constexpr
+ double (min)() noexcept
+ {
+ return min1(std::is_signed<T>{});
+ }
+
+ static constexpr
+ double (max)() noexcept
+ {
+ return max1(std::is_signed<T>{});
+ }
+};
+
+#endif
+
 struct scalar
 {
  storage_ptr sp; // must come first

include/boost/json/value.hpp

@@ -2423,54 +2423,47 @@ class value
  ! std::is_floating_point<T>::value,
  T>::type
  {
- T result{};
  if(sca_.k == json::kind::int64)
  {
  auto const i = sca_.i;
- if( i > (std::numeric_limits<T>::max)() ||
- i < (std::numeric_limits<T>::min)())
+ if( i >= (std::numeric_limits<T>::min)() &&
+ i <= (std::numeric_limits<T>::max)())
  {
- ec = error::not_exact;
- }
- else
- {
- result = static_cast<T>(i);
+ ec = {};
+ return static_cast<T>(i);
  }
+ ec = error::not_exact;
  }
  else if(sca_.k == json::kind::uint64)
  {
  auto const u = sca_.u;
- if(u > static_cast<std::uint64_t>((
+ if(u <= static_cast<std::uint64_t>((
  std::numeric_limits<T>::max)()))
  {
- ec = error::not_exact;
- }
- else
- {
- result = static_cast<T>(u);
+ ec = {};
+ return static_cast<T>(u);
  }
+ ec = error::not_exact;
  }
  else if(sca_.k == json::kind::double_)
  {
  auto const d = sca_.d;
- if( d > static_cast<double>(
- (std::numeric_limits<T>::max)()) ||
- d < static_cast<double>(
- (std::numeric_limits<T>::min)()) ||
- static_cast<T>(d) != d)
+ if( d >= static_cast<double>(
+ (detail::to_number_limit<T>::min)()) &&
+ d <= static_cast<double>(
+ (detail::to_number_limit<T>::max)()) &&
+ static_cast<T>(d) == d)
  {
- ec = error::not_exact;
- }
- else
- {
- result = static_cast<T>(d);
+ ec = {};
+ return static_cast<T>(d);
  }
+ ec = error::not_exact;
  }
  else
  {
  ec = error::not_number;
  }
- return result;
+ return T{};
  }
 
  template<class T>
@@ -2481,52 +2474,44 @@ class value
  ! std::is_same<T, bool>::value,
  T>::type
  {
- T result{};
  if(sca_.k == json::kind::int64)
  {
  auto const i = sca_.i;
- if( i < 0 || static_cast<std::uint64_t>(i) >
+ if( i >= 0 && static_cast<std::uint64_t>(i) <=
  (std::numeric_limits<T>::max)())
  {
- ec = error::not_exact;
- }
- else
- {
- result = static_cast<T>(i);
+ ec = {};
+ return static_cast<T>(i);
  }
+ ec = error::not_exact;
  }
  else if(sca_.k == json::kind::uint64)
  {
  auto const u = sca_.u;
- if(u > (std::numeric_limits<T>::max)())
- {
- ec = error::not_exact;
- }
- else
+ if(u <= (std::numeric_limits<T>::max)())
  {
- result = static_cast<T>(u);
+ ec = {};
+ return static_cast<T>(u);
  }
+ ec = error::not_exact;
  }
  else if(sca_.k == json::kind::double_)
  {
  auto const d = sca_.d;
- if( d < 0 ||
- d > static_cast<double>(
- (std::numeric_limits<T>::max)()) ||
- static_cast<T>(d) != d)
+ if( d >= 0 &&
+ d <= (detail::to_number_limit<T>::max)() &&
+ static_cast<T>(d) == d)
  {
- ec = error::not_exact;
- }
- else
- {
- result = static_cast<T>(d);
+ ec = {};
+ return static_cast<T>(d);
  }
+ ec = error::not_exact;
  }
  else
  {
  ec = error::not_number;
  }
- return result;
+ return T{};
  }
 
  template<class T>