Cleanup RangeCheck class and dependencies

base/numerics/safe_conversions_impl.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_
 #define BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_
 
 #include <stdint.h>
 
 #include <limits>
@@ skipping 118 matching lines @@
 
 // Signed to unsigned: Dst cannot be statically determined to contain Src.
 template <typename Dst, typename Src>
 struct StaticDstRangeRelationToSrcRange<Dst,
                                         Src,
                                         INTEGER_REPRESENTATION_UNSIGNED,
                                         INTEGER_REPRESENTATION_SIGNED> {
   static const NumericRangeRepresentation value = NUMERIC_RANGE_NOT_CONTAINED;
 };
 
-enum RangeConstraint {
-  RANGE_VALID = 0x0,      // Value can be represented by the destination type.
-  RANGE_UNDERFLOW = 0x1,  // Value would underflow.
-  RANGE_OVERFLOW = 0x2,   // Value would overflow.
-  RANGE_INVALID = RANGE_UNDERFLOW | RANGE_OVERFLOW  // Invalid (i.e. NaN).
-};
-
 // This class wraps the range constraints as separate booleans so the compiler
 // can identify constants and eliminate unused code paths.
 class RangeCheck {
  public:
-  constexpr RangeCheck(bool is_in_upper_bound, bool is_in_lower_bound)
+  constexpr RangeCheck(bool is_in_lower_bound, bool is_in_upper_bound)
       : is_underflow_(!is_in_lower_bound), is_overflow_(!is_in_upper_bound) {}
   constexpr RangeCheck() : is_underflow_(0), is_overflow_(0) {}
   constexpr bool IsValid() const { return !is_overflow_ && !is_underflow_; }
   constexpr bool IsInvalid() const { return is_overflow_ && is_underflow_; }
   constexpr bool IsOverflow() const { return is_overflow_ && !is_underflow_; }
   constexpr bool IsUnderflow() const { return !is_overflow_ && is_underflow_; }
   constexpr bool IsOverflowFlagSet() const { return is_overflow_; }
   constexpr bool IsUnderflowFlagSet() const { return is_underflow_; }
-
-  // These are some wrappers to make the tests a bit cleaner.
-  constexpr operator RangeConstraint() const {
-    return static_cast<RangeConstraint>(static_cast<int>(is_overflow_) << 1 |
-                                        static_cast<int>(is_underflow_));
+  constexpr bool operator==(const RangeCheck rhs) const {
+    return is_underflow_ == rhs.is_underflow_ &&
+           is_overflow_ == rhs.is_overflow_;
   }
-  constexpr bool operator==(const RangeConstraint rhs) const {
-    return rhs == static_cast<RangeConstraint>(*this);
+  constexpr bool operator!=(const RangeCheck rhs) const {
+    return !(*this == rhs);
   }
 
  private:
   // Do not change the order of these member variables. The integral conversion
   // optimization depends on this exact order.
-  const bool is_underflow_ : 1;
-  const bool is_overflow_ : 1;
+  const bool is_underflow_;
+  const bool is_overflow_;
 };
 
 // The following helper template addresses a corner case in range checks for
 // conversion from a floating-point type to an integral type of smaller range
 // but larger precision (e.g. float -> unsigned). The problem is as follows:
 //   1. Integral maximum is always one less than a power of two, so it must be
 //      truncated to fit the mantissa of the floating point. The direction of
 //      rounding is implementation defined, but by default it's always IEEE
 //      floats, which round to nearest and thus result in a value of larger
 //      magnitude than the integral value.
@@ skipping 74 matching lines @@
 struct DstRangeRelationToSrcRangeImpl<Dst,
                                       Src,
                                       Bounds,
                                       DstSign,
                                       SrcSign,
                                       NUMERIC_RANGE_CONTAINED> {
   static constexpr RangeCheck Check(Src value) {
     using SrcLimits = std::numeric_limits<Src>;
     using DstLimits = NarrowingRange<Dst, Src, Bounds>;
     return RangeCheck(
+        static_cast<Dst>(SrcLimits::lowest()) >= DstLimits::lowest() ||
+            static_cast<Dst>(value) >= DstLimits::lowest(),
         static_cast<Dst>(SrcLimits::max()) <= DstLimits::max() ||
-            static_cast<Dst>(value) <= DstLimits::max(),
-        static_cast<Dst>(SrcLimits::lowest()) >= DstLimits::lowest() ||
-            static_cast<Dst>(value) >= DstLimits::lowest());
+            static_cast<Dst>(value) <= DstLimits::max());
   }
 };
 
 // Signed to signed narrowing: Both the upper and lower boundaries may be
 // exceeded for standard limits.
 template <typename Dst, typename Src, template <typename> class Bounds>
 struct DstRangeRelationToSrcRangeImpl<Dst,
                                       Src,
                                       Bounds,
                                       INTEGER_REPRESENTATION_SIGNED,
                                       INTEGER_REPRESENTATION_SIGNED,
                                       NUMERIC_RANGE_NOT_CONTAINED> {
   static constexpr RangeCheck Check(Src value) {
     using DstLimits = NarrowingRange<Dst, Src, Bounds>;
-    return RangeCheck(value <= DstLimits::max(), value >= DstLimits::lowest());
+    return RangeCheck(value >= DstLimits::lowest(), value <= DstLimits::max());
   }
 };
 
 // Unsigned to unsigned narrowing: Only the upper bound can be exceeded for
 // standard limits.
 template <typename Dst, typename Src, template <typename> class Bounds>
 struct DstRangeRelationToSrcRangeImpl<Dst,
                                       Src,
                                       Bounds,
                                       INTEGER_REPRESENTATION_UNSIGNED,
                                       INTEGER_REPRESENTATION_UNSIGNED,
                                       NUMERIC_RANGE_NOT_CONTAINED> {
   static constexpr RangeCheck Check(Src value) {
     using DstLimits = NarrowingRange<Dst, Src, Bounds>;
     return RangeCheck(
-        value <= DstLimits::max(),
-        DstLimits::lowest() == Dst(0) || value >= DstLimits::lowest());
+        DstLimits::lowest() == Dst(0) || value >= DstLimits::lowest(),
+        value <= DstLimits::max());
   }
 };
 
 // Unsigned to signed: Only the upper bound can be exceeded for standard limits.
 template <typename Dst, typename Src, template <typename> class Bounds>
 struct DstRangeRelationToSrcRangeImpl<Dst,
                                       Src,
                                       Bounds,
                                       INTEGER_REPRESENTATION_SIGNED,
                                       INTEGER_REPRESENTATION_UNSIGNED,
                                       NUMERIC_RANGE_NOT_CONTAINED> {
   static constexpr RangeCheck Check(Src value) {
     using DstLimits = NarrowingRange<Dst, Src, Bounds>;
     using Promotion = decltype(Src() + Dst());
-    return RangeCheck(static_cast<Promotion>(value) <=
-                          static_cast<Promotion>(DstLimits::max()),
-                      DstLimits::lowest() <= Dst(0) ||
+    return RangeCheck(DstLimits::lowest() <= Dst(0) ||
                           static_cast<Promotion>(value) >=
-                              static_cast<Promotion>(DstLimits::lowest()));
+                              static_cast<Promotion>(DstLimits::lowest()),
+                      static_cast<Promotion>(value) <=
+                          static_cast<Promotion>(DstLimits::max()));
   }
 };
 
 // Signed to unsigned: The upper boundary may be exceeded for a narrower Dst,
 // and any negative value exceeds the lower boundary for standard limits.
 template <typename Dst, typename Src, template <typename> class Bounds>
 struct DstRangeRelationToSrcRangeImpl<Dst,
                                       Src,
                                       Bounds,
                                       INTEGER_REPRESENTATION_UNSIGNED,
                                       INTEGER_REPRESENTATION_SIGNED,
                                       NUMERIC_RANGE_NOT_CONTAINED> {
   static constexpr RangeCheck Check(Src value) {
     using SrcLimits = std::numeric_limits<Src>;
     using DstLimits = NarrowingRange<Dst, Src, Bounds>;
     using Promotion = decltype(Src() + Dst());
     return RangeCheck(
+        value >= Src(0) && (DstLimits::lowest() == 0 ||
+                            static_cast<Dst>(value) >= DstLimits::lowest()),
         static_cast<Promotion>(SrcLimits::max()) <=
                 static_cast<Promotion>(DstLimits::max()) ||
             static_cast<Promotion>(value) <=
-                static_cast<Promotion>(DstLimits::max()),
-        value >= Src(0) && (DstLimits::lowest() == 0 ||
-                            static_cast<Dst>(value) >= DstLimits::lowest()));
+                static_cast<Promotion>(DstLimits::max()));
   }
 };
 
 template <typename Dst,
           template <typename> class Bounds = std::numeric_limits,
           typename Src>
 constexpr RangeCheck DstRangeRelationToSrcRange(Src value) {
   static_assert(std::is_arithmetic<Src>::value, "Argument must be numeric.");
   static_assert(std::is_arithmetic<Dst>::value, "Result must be numeric.");
   static_assert(Bounds<Dst>::lowest() < Bounds<Dst>::max(), "");
@@ skipping 252 matching lines @@
   static const bool value =
       UnderlyingType<L>::is_numeric && UnderlyingType<R>::is_numeric &&
       (UnderlyingType<L>::is_strict || UnderlyingType<R>::is_strict);
 };
 
 template <typename L, typename R>
 constexpr bool IsLessImpl(const L lhs,
                           const R rhs,
                           const RangeCheck l_range,
                           const RangeCheck r_range) {
-  return l_range == RANGE_UNDERFLOW || r_range == RANGE_OVERFLOW ||
+  return l_range.IsUnderflow() || r_range.IsOverflow() ||
          (l_range == r_range &&
           static_cast<decltype(lhs + rhs)>(lhs) <
               static_cast<decltype(lhs + rhs)>(rhs));
 }
 
 template <typename L, typename R>
 struct IsLess {
   static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
                 "Types must be numeric.");
   static constexpr bool Test(const L lhs, const R rhs) {
     return IsLessImpl(lhs, rhs, DstRangeRelationToSrcRange<R>(lhs),
                       DstRangeRelationToSrcRange<L>(rhs));
   }
 };
 
 template <typename L, typename R>
 constexpr bool IsLessOrEqualImpl(const L lhs,
                                  const R rhs,
                                  const RangeCheck l_range,
                                  const RangeCheck r_range) {
-  return l_range == RANGE_UNDERFLOW || r_range == RANGE_OVERFLOW ||
+  return l_range.IsUnderflow() || r_range.IsOverflow() ||
          (l_range == r_range &&
           static_cast<decltype(lhs + rhs)>(lhs) <=
               static_cast<decltype(lhs + rhs)>(rhs));
 }
 
 template <typename L, typename R>
 struct IsLessOrEqual {
   static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
                 "Types must be numeric.");
   static constexpr bool Test(const L lhs, const R rhs) {
     return IsLessOrEqualImpl(lhs, rhs, DstRangeRelationToSrcRange<R>(lhs),
                              DstRangeRelationToSrcRange<L>(rhs));
   }
 };
 
 template <typename L, typename R>
 constexpr bool IsGreaterImpl(const L lhs,
                              const R rhs,
                              const RangeCheck l_range,
                              const RangeCheck r_range) {
-  return l_range == RANGE_OVERFLOW || r_range == RANGE_UNDERFLOW ||
+  return l_range.IsOverflow() || r_range.IsUnderflow() ||
          (l_range == r_range &&
           static_cast<decltype(lhs + rhs)>(lhs) >
               static_cast<decltype(lhs + rhs)>(rhs));
 }
 
 template <typename L, typename R>
 struct IsGreater {
   static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
                 "Types must be numeric.");
   static constexpr bool Test(const L lhs, const R rhs) {
     return IsGreaterImpl(lhs, rhs, DstRangeRelationToSrcRange<R>(lhs),
                          DstRangeRelationToSrcRange<L>(rhs));
   }
 };
 
 template <typename L, typename R>
 constexpr bool IsGreaterOrEqualImpl(const L lhs,
                                     const R rhs,
                                     const RangeCheck l_range,
                                     const RangeCheck r_range) {
-  return l_range == RANGE_OVERFLOW || r_range == RANGE_UNDERFLOW ||
+  return l_range.IsOverflow() || r_range.IsUnderflow() ||
          (l_range == r_range &&
           static_cast<decltype(lhs + rhs)>(lhs) >=
               static_cast<decltype(lhs + rhs)>(rhs));
 }
 
 template <typename L, typename R>
 struct IsGreaterOrEqual {
   static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
                 "Types must be numeric.");
   static constexpr bool Test(const L lhs, const R rhs) {
@@ skipping 40 matching lines @@
                    static_cast<BigType>(static_cast<L>(lhs)),
                    static_cast<BigType>(static_cast<R>(rhs)))
              // Let the template functions figure it out for mixed types.
              : C<L, R>::Test(lhs, rhs);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_