folly::detail::CheckOverflowToDuration< IsFloatingPoint > Struct Template Reference

#include <Conv.h>

Static Public Member Functions
template<typename Tgt , typename SubsecondRatio , typename Seconds , typename Subseconds >
static ConversionCode	check (Seconds seconds, Subseconds subseconds)

Detailed Description

template<bool IsFloatingPoint>
struct folly::detail::CheckOverflowToDuration< IsFloatingPoint >

Check for overflow when converting to a duration type that is second granularity or finer (e.g., nanoseconds, milliseconds, seconds)

This assumes the input is normalized, with subseconds >= 0 and subseconds less than 1 second.

Definition at line 268 of file Conv.h.

Member Function Documentation

template<bool IsFloatingPoint>

template<typename Tgt , typename SubsecondRatio , typename Seconds , typename Subseconds >

static ConversionCode folly::detail::CheckOverflowToDuration< IsFloatingPoint >::check ( Seconds  seconds, Subseconds  subseconds  )

inlinestatic

Definition at line 274 of file Conv.h.

References LIKELY, max, folly::NEGATIVE_OVERFLOW, folly::POSITIVE_OVERFLOW, folly::SUCCESS, folly::to_signed(), folly::to_unsigned(), UNLIKELY, and value.

                                                                      {
    static_assert(
        Tgt::period::num == 1,
        "this implementation should only be used for subsecond granularity "
        "duration types");
    static_assert(
        !std::is_floating_point<typename Tgt::rep>::value, "incorrect usage");
    static_assert(
        SubsecondRatio::num == 1, "subsecond numerator should always be 1");

    if (LIKELY(seconds >= 0)) {
      constexpr auto maxCount = std::numeric_limits<typename Tgt::rep>::max();
      constexpr auto maxSeconds = maxCount / Tgt::period::den;

      auto unsignedSeconds = to_unsigned(seconds);
      if (LIKELY(unsignedSeconds < maxSeconds)) {
        return ConversionCode::SUCCESS;
      }

      if (UNLIKELY(unsignedSeconds == maxSeconds)) {
        constexpr auto maxRemainder =
            maxCount - (maxSeconds * Tgt::period::den);
        constexpr auto maxSubseconds =
            (maxRemainder * SubsecondRatio::den) / Tgt::period::den;
        if (subseconds <= 0) {
          return ConversionCode::SUCCESS;
        }
        if (to_unsigned(subseconds) <= maxSubseconds) {
          return ConversionCode::SUCCESS;
        }
      }
      return ConversionCode::POSITIVE_OVERFLOW;
    } else if (std::is_unsigned<typename Tgt::rep>::value) {
      return ConversionCode::NEGATIVE_OVERFLOW;
    } else {
      constexpr auto minCount =
          to_signed(std::numeric_limits<typename Tgt::rep>::lowest());
      constexpr auto minSeconds = (minCount / Tgt::period::den);
      if (LIKELY(seconds >= minSeconds)) {
        return ConversionCode::SUCCESS;
      }

      if (UNLIKELY(seconds == minSeconds - 1)) {
        constexpr auto maxRemainder =
            minCount - (minSeconds * Tgt::period::den) + Tgt::period::den;
        constexpr auto maxSubseconds =
            (maxRemainder * SubsecondRatio::den) / Tgt::period::den;
        if (subseconds <= 0) {
          return ConversionCode::NEGATIVE_OVERFLOW;
        }
        if (subseconds >= maxSubseconds) {
          return ConversionCode::SUCCESS;
        }
      }
      return ConversionCode::NEGATIVE_OVERFLOW;
    }
  }

---

The documentation for this struct was generated from the following file:

• proxygen/folly/folly/chrono/Conv.h