Add variadic helper functions for CheckedNumeric math operations

base/numerics/safe_math_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_MATH_IMPL_H_
 #define BASE_NUMERICS_SAFE_MATH_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 244 matching lines @@
   // Addition is valid if the sign of (x + y) is equal to either that of x or
   // that of y.
   return (std::numeric_limits<T>::is_signed)
              ? HasSignBit(BinaryComplement(
                    static_cast<UnsignedDst>((uresult ^ ux) & (uresult ^ uy))))
              : (BinaryComplement(x) >=
                 y);  // Unsigned is either valid or underflow.
 }
 
 template <typename T, typename U, class Enable = void>
-struct CheckedAdd {};
+struct CheckedAddOp {};
 
 template <typename T, typename U>
-struct CheckedAdd<
+struct CheckedAddOp<
     T,
     U,
     typename std::enable_if<std::numeric_limits<T>::is_integer &&
                             std::numeric_limits<U>::is_integer>::type> {
   using result_type =
       typename ArithmeticPromotion<MAX_EXPONENT_PROMOTION, T, U>::type;
   template <typename V>
-  static bool Op(T x, U y, V* result) {
+  static bool Do(T x, U y, V* result) {
 #if USE_OVERFLOW_BUILTINS
     return !__builtin_add_overflow(x, y, result);
 #else
     using Promotion =
         typename ArithmeticPromotion<BIG_ENOUGH_PROMOTION, T, U>::type;
     Promotion presult;
     // Fail if either operand is out of range for the promoted type.
     // TODO(jschuh): This could be made to work for a broader range of values.
     bool is_valid = IsValueInRangeForNumericType<Promotion>(x) &&
                     IsValueInRangeForNumericType<Promotion>(y);
@@ skipping 22 matching lines @@
   *result = static_cast<T>(uresult);
   // Subtraction is valid if either x and y have same sign, or (x-y) and x have
   // the same sign.
   return (std::numeric_limits<T>::is_signed)
              ? HasSignBit(BinaryComplement(
                    static_cast<UnsignedDst>((uresult ^ ux) & (ux ^ uy))))
              : (x >= y);
 }
 
 template <typename T, typename U, class Enable = void>
-struct CheckedSub {};
+struct CheckedSubOp {};
 
 template <typename T, typename U>
-struct CheckedSub<
+struct CheckedSubOp<
     T,
     U,
     typename std::enable_if<std::numeric_limits<T>::is_integer &&
                             std::numeric_limits<U>::is_integer>::type> {
   using result_type =
       typename ArithmeticPromotion<MAX_EXPONENT_PROMOTION, T, U>::type;
   template <typename V>
-  static bool Op(T x, U y, V* result) {
+  static bool Do(T x, U y, V* result) {
 #if USE_OVERFLOW_BUILTINS
     return !__builtin_sub_overflow(x, y, result);
 #else
     using Promotion =
         typename ArithmeticPromotion<BIG_ENOUGH_PROMOTION, T, U>::type;
     Promotion presult;
     // Fail if either operand is out of range for the promoted type.
     // TODO(jschuh): This could be made to work for a broader range of values.
     bool is_valid = IsValueInRangeForNumericType<Promotion>(x) &&
                     IsValueInRangeForNumericType<Promotion>(y);
@@ skipping 59 matching lines @@
 typename std::enable_if<std::numeric_limits<T>::is_integer &&
                             !std::numeric_limits<T>::is_signed &&
                             (sizeof(T) * 2 > sizeof(uintmax_t)),
                         bool>::type
 CheckedMulImpl(T x, T y, T* result) {
   *result = x * y;
   return (y == 0 || x <= std::numeric_limits<T>::max() / y);
 }
 
 template <typename T, typename U, class Enable = void>
-struct CheckedMul {};
+struct CheckedMulOp {};
 
 template <typename T, typename U>
-struct CheckedMul<
+struct CheckedMulOp<
     T,
     U,
     typename std::enable_if<std::numeric_limits<T>::is_integer &&
                             std::numeric_limits<U>::is_integer>::type> {
   using result_type =
       typename ArithmeticPromotion<MAX_EXPONENT_PROMOTION, T, U>::type;
   template <typename V>
-  static bool Op(T x, U y, V* result) {
+  static bool Do(T x, U y, V* result) {
 #if USE_OVERFLOW_BUILTINS
 #if defined(__clang__)
     // TODO(jschuh): Get the Clang runtime library issues sorted out so we can
     // support full-width, mixed-sign multiply builtins.
     // https://crbug.com/613003
     static const bool kUseMaxInt =
         sizeof(__typeof__(x * y)) < sizeof(intptr_t) ||
         (sizeof(__typeof__(x * y)) == sizeof(intptr_t) &&
          std::is_signed<T>::value == std::is_signed<U>::value);
 #else
@@ skipping 31 matching lines @@
 CheckedDivImpl(T x, T y, T* result) {
   if (y && (!std::numeric_limits<T>::is_signed ||
             x != std::numeric_limits<T>::min() || y != static_cast<T>(-1))) {
     *result = x / y;
     return true;
   }
   return false;
 }
 
 template <typename T, typename U, class Enable = void>
-struct CheckedDiv {};
+struct CheckedDivOp {};
 
 template <typename T, typename U>
-struct CheckedDiv<
+struct CheckedDivOp<
     T,
     U,
     typename std::enable_if<std::numeric_limits<T>::is_integer &&
                             std::numeric_limits<U>::is_integer>::type> {
   using result_type =
       typename ArithmeticPromotion<MAX_EXPONENT_PROMOTION, T, U>::type;
   template <typename V>
-  static bool Op(T x, U y, V* result) {
+  static bool Do(T x, U y, V* result) {
     using Promotion =
         typename ArithmeticPromotion<BIG_ENOUGH_PROMOTION, T, U>::type;
     Promotion presult;
     // Fail if either operand is out of range for the promoted type.
     // TODO(jschuh): This could be made to work for a broader range of values.
     bool is_valid = IsValueInRangeForNumericType<Promotion>(x) &&
                     IsValueInRangeForNumericType<Promotion>(y);
     is_valid &= CheckedDivImpl(static_cast<Promotion>(x),
                                static_cast<Promotion>(y), &presult);
     *result = static_cast<V>(presult);
@@ skipping 19 matching lines @@
                         bool>::type
 CheckedModImpl(T x, T y, T* result) {
   if (y != 0) {
     *result = static_cast<T>(x % y);
     return true;
   }
   return false;
 }
 
 template <typename T, typename U, class Enable = void>
-struct CheckedMod {};
+struct CheckedModOp {};
 
 template <typename T, typename U>
-struct CheckedMod<
+struct CheckedModOp<
     T,
     U,
     typename std::enable_if<std::numeric_limits<T>::is_integer &&
                             std::numeric_limits<U>::is_integer>::type> {
   using result_type =
       typename ArithmeticPromotion<MAX_EXPONENT_PROMOTION, T, U>::type;
   template <typename V>
-  static bool Op(T x, U y, V* result) {
+  static bool Do(T x, U y, V* result) {
     using Promotion =
         typename ArithmeticPromotion<BIG_ENOUGH_PROMOTION, T, U>::type;
     Promotion presult;
     bool is_valid = CheckedModImpl(static_cast<Promotion>(x),
                                    static_cast<Promotion>(y), &presult);
     *result = static_cast<V>(presult);
     return is_valid && IsValueInRangeForNumericType<V>(presult);
   }
 };
 
 template <typename T, typename U, class Enable = void>
-struct CheckedLeftShift {};
+struct CheckedLshOp {};
 
 // Left shift. Shifts less than 0 or greater than or equal to the number
 // of bits in the promoted type are undefined. Shifts of negative values
 // are undefined. Otherwise it is defined when the result fits.
 template <typename T, typename U>
-struct CheckedLeftShift<
+struct CheckedLshOp<
     T,
     U,
     typename std::enable_if<std::numeric_limits<T>::is_integer &&
                             std::numeric_limits<U>::is_integer>::type> {
   using result_type = T;
   template <typename V>
-  static bool Op(T x, U shift, V* result) {
+  static bool Do(T x, U shift, V* result) {
     using ShiftType = typename UnsignedIntegerForSize<T>::type;
     static const ShiftType kBitWidth = CHAR_BIT * sizeof(T);
     const ShiftType real_shift = static_cast<ShiftType>(shift);
     // Signed shift is not legal on negative values.
     if (!IsValueNegative(x) && real_shift < kBitWidth) {
       // Just use a multiplication because it's easy.
       // TODO(jschuh): This could probably be made more efficient.
       if (!std::is_signed<T>::value || real_shift != kBitWidth - 1)
-        return CheckedMul<T, T>::Op(x, static_cast<T>(1) << shift, result);
+        return CheckedMulOp<T, T>::Do(x, static_cast<T>(1) << shift, result);
       return !x;  // Special case zero for a full width signed shift.
     }
     return false;
   }
 };
 
 template <typename T, typename U, class Enable = void>
-struct CheckedRightShift {};
+struct CheckedRshOp {};
 
 // Right shift. Shifts less than 0 or greater than or equal to the number
 // of bits in the promoted type are undefined. Otherwise, it is always defined,
 // but a right shift of a negative value is implementation-dependent.
 template <typename T, typename U>
-struct CheckedRightShift<
+struct CheckedRshOp<
     T,
     U,
     typename std::enable_if<std::numeric_limits<T>::is_integer &&
                             std::numeric_limits<U>::is_integer>::type> {
   using result_type = T;
   template <typename V = result_type>
-  static bool Op(T x, U shift, V* result) {
+  static bool Do(T x, U shift, V* result) {
     // Use the type conversion push negative values out of range.
     using ShiftType = typename UnsignedIntegerForSize<T>::type;
     if (static_cast<ShiftType>(shift) < (CHAR_BIT * sizeof(T))) {
       T tmp = x >> shift;
       *result = static_cast<V>(tmp);
       return IsValueInRangeForNumericType<V>(tmp);
     }
     return false;
   }
 };
@@ skipping 61 matching lines @@
 constexpr typename std::enable_if<std::numeric_limits<T>::is_integer &&
                                       !std::numeric_limits<T>::is_signed,
                                   T>::type
 SafeUnsignedAbs(T value) {
   // T is unsigned, so |value| must already be positive.
   return static_cast<T>(value);
 }
 
 // This is just boilerplate that wraps the standard floating point arithmetic.
 // A macro isn't the nicest solution, but it beats rewriting these repeatedly.
-#define BASE_FLOAT_ARITHMETIC_OPS(NAME, OP)                                  \
-  template <typename T, typename U>                                          \
-  struct Checked##NAME<T, U, typename std::enable_if<                        \
-                                 std::numeric_limits<T>::is_iec559 ||        \
-                                 std::numeric_limits<U>::is_iec559>::type> { \
-    using result_type =                                                      \
-        typename ArithmeticPromotion<MAX_EXPONENT_PROMOTION, T, U>::type;    \
-    template <typename V>                                                    \
-    static bool Op(T x, U y, V* result) {                                    \
-      using Promotion =                                                      \
-          typename ArithmeticPromotion<MAX_EXPONENT_PROMOTION, T, U>::type;  \
-      Promotion presult = x OP y;                                            \
-      *result = static_cast<V>(presult);                                     \
-      return IsValueInRangeForNumericType<V>(presult);                       \
-    }                                                                        \
+#define BASE_FLOAT_ARITHMETIC_OPS(NAME, OP)                                 \
+  template <typename T, typename U>                                         \
+  struct Checked##NAME##Op<                                                 \
+      T, U,                                                                 \
+      typename std::enable_if<std::numeric_limits<T>::is_iec559 ||          \
+                              std::numeric_limits<U>::is_iec559>::type> {   \
+    using result_type =                                                     \
+        typename ArithmeticPromotion<MAX_EXPONENT_PROMOTION, T, U>::type;   \
+    template <typename V>                                                   \
+    static bool Do(T x, U y, V* result) {                                   \
+      using Promotion =                                                     \
+          typename ArithmeticPromotion<MAX_EXPONENT_PROMOTION, T, U>::type; \
+      Promotion presult = x OP y;                                           \
+      *result = static_cast<V>(presult);                                    \
+      return IsValueInRangeForNumericType<V>(presult);                      \
+    }                                                                       \
   };
 
 BASE_FLOAT_ARITHMETIC_OPS(Add, +)
 BASE_FLOAT_ARITHMETIC_OPS(Sub, -)
 BASE_FLOAT_ARITHMETIC_OPS(Mul, *)
 BASE_FLOAT_ARITHMETIC_OPS(Div, /)
 
 #undef BASE_FLOAT_ARITHMETIC_OPS
 
 template <typename T>
@@ skipping 101 matching lines @@
 
   // Copy constructor.
   template <typename Src>
   constexpr CheckedNumericState(const CheckedNumericState<Src>& rhs)
       : value_(static_cast<T>(rhs.value())) {}
 
   constexpr bool is_valid() const { return std::isfinite(value_); }
   constexpr T value() const { return value_; }
 };
 
+// The following are helper templates used in the CheckedNumeric class.
+template <typename T>
+class CheckedNumeric;
+
+// Used to treat CheckedNumeric and arithmetic underlying types the same.
+template <typename T>
+struct UnderlyingType {
+  using type = T;
+  static const bool is_numeric = std::is_arithmetic<T>::value;
+  static const bool is_checked = false;
+};
+
+template <typename T>
+struct UnderlyingType<CheckedNumeric<T>> {
+  using type = T;
+  static const bool is_numeric = true;
+  static const bool is_checked = true;
+};
+
+template <typename L, typename R>
+struct IsCheckedOp {
+  static const bool value =
+      UnderlyingType<L>::is_numeric && UnderlyingType<R>::is_numeric &&
+      (UnderlyingType<L>::is_checked || UnderlyingType<R>::is_checked);
+};
+
+template <template <typename, typename, typename> class M,
+          typename L,
+          typename R>
+struct MathWrapper {
+  using math = M<typename UnderlyingType<L>::type,
+                 typename UnderlyingType<R>::type,
+                 void>;
+  using type = typename math::result_type;
+};
+
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_MATH_IMPL_H_