mirror/fmt
1
0
Fork 0
mirror of https://github.com/fmtlib/fmt.git synced 2025-01-27 15:35:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix warnings

Browse Source
This commit is contained in:
Victor Zverovich 2019-07-12 09:54:02 -07:00
parent a3a74672a0
commit af4734fd15
3 changed files with 38 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ChangeLog.rst
View File

@ -1,3 +1,6 @@
6.0.0 - TBD
-----------
5.3.0 - 2018-12-28 5.3.0 - 2018-12-28
------------------ ------------------

5
include/fmt/chrono.h
View File

@ -477,7 +477,10 @@ template <typename Rep, typename Period,
FMT_ENABLE_IF(std::is_floating_point<Rep>::value)> FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
inline std::chrono::duration<Rep, std::milli> get_milliseconds( inline std::chrono::duration<Rep, std::milli> get_milliseconds(
std::chrono::duration<Rep, Period> d) { std::chrono::duration<Rep, Period> d) {
auto ms = mod(d.count() * Period::num / Period::den * 1000, 1000); using common_type = typename std::common_type<Rep, std::intmax_t>::type;
auto ms = mod(d.count() * static_cast<common_type>(Period::num) /
static_cast<common_type>(Period::den) * 1000,
1000);
return std::chrono::duration<Rep, std::milli>(static_cast<Rep>(ms)); return std::chrono::duration<Rep, std::milli>(static_cast<Rep>(ms));
} }

48
include/fmt/safe-duration-cast.h
View File

@ -20,12 +20,10 @@ FMT_BEGIN_NAMESPACE
namespace safe_duration_cast { namespace safe_duration_cast {
/**
* converts From to To, without loss. If the dynamic value of from
* can't be converted to To without loss, ec is set.
*/
template <typename To, typename From, template <typename To, typename From,
FMT_ENABLE_IF(!std::is_same<From, To>::value)> FMT_ENABLE_IF(!std::is_same<From, To>::value &&
std::numeric_limits<From>::is_signed ==
std::numeric_limits<To>::is_signed)>
FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
ec = 0; ec = 0;
using F = std::numeric_limits<From>; using F = std::numeric_limits<From>;
@ -33,19 +31,34 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
static_assert(F::is_integer, "From must be integral"); static_assert(F::is_integer, "From must be integral");
static_assert(T::is_integer, "To must be integral"); static_assert(T::is_integer, "To must be integral");
if (F::is_signed == T::is_signed) { // A and B are both signed, or both unsigned.
// A and B are both signed, or both unsigned. if (F::digits <= T::digits) {
if (F::digits <= T::digits) { // From fits in To without any problem.
// From fits in To without any problem } else {
} else { // From does not always fit in To, resort to a dynamic check.
// From does not always fit in To, resort to a dynamic check. if (from < T::min() || from > T::max()) {
if (from < T::min() || from > T::max()) { // outside range.
// outside range. ec = 1;
ec = 1; return {};
return {};
}
} }
} }
return static_cast<To>(from);
}
/**
* converts From to To, without loss. If the dynamic value of from
* can't be converted to To without loss, ec is set.
*/
template <typename To, typename From,
FMT_ENABLE_IF(!std::is_same<From, To>::value &&
std::numeric_limits<From>::is_signed !=
std::numeric_limits<To>::is_signed)>
FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
ec = 0;
using F = std::numeric_limits<From>;
using T = std::numeric_limits<To>;
static_assert(F::is_integer, "From must be integral");
static_assert(T::is_integer, "To must be integral");
if (F::is_signed && !T::is_signed) { if (F::is_signed && !T::is_signed) {
// From may be negative, not allowed! // From may be negative, not allowed!
@ -261,7 +274,8 @@ To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
// this can't go wrong, right? den>0 is checked earlier. // this can't go wrong, right? den>0 is checked earlier.
if (Factor::den != 1) { if (Factor::den != 1) {
count /= Factor::den; using common_t = typename std::common_type<IntermediateRep, intmax_t>::type;
count /= static_cast<common_t>(Factor::den);
} }
// convert to the to type, safely // convert to the to type, safely