Simplify CheckedNumeric macros

base/numerics/safe_math.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_H_
 #define BASE_NUMERICS_SAFE_MATH_H_
 
 #include <stddef.h>
 
 #include <limits>
@@ skipping 167 matching lines @@
   template <typename Src>
   static CheckedNumeric<T> cast(
       const CheckedNumeric<Src>& u,
       typename std::enable_if<!std::is_same<Src, T>::value, int>::type = 0) {
     return u;
   }
 
   static const CheckedNumeric<T>& cast(const CheckedNumeric<T>& u) { return u; }
 
  private:
-  template <typename NumericType>
-  struct UnderlyingType {
-    using type = NumericType;
-  };
-
-  template <typename NumericType>
-  struct UnderlyingType<CheckedNumeric<NumericType>> {
-    using type = NumericType;
-  };
-
   CheckedNumericState<T> state_;
 };
 
 // This is the boilerplate for the standard arithmetic operator overloads. A
 // macro isn't the prettiest solution, but it beats rewriting these five times.
 // Some details worth noting are:
 //  * We apply the standard arithmetic promotions.
 //  * We skip range checks for floating points.
 //  * We skip range checks for destination integers with sufficient range.
 // TODO(jschuh): extract these out into templates.
-#define BASE_NUMERIC_ARITHMETIC_OPERATORS(NAME, OP, COMPOUND_OP)               \
-  /* Binary arithmetic operator for CheckedNumerics of the same type. */       \
-  template <typename T>                                                        \
-  CheckedNumeric<typename ArithmeticPromotion<T>::type> operator OP(           \
-      const CheckedNumeric<T>& lhs, const CheckedNumeric<T>& rhs) {            \
-    typedef typename ArithmeticPromotion<T>::type Promotion;                   \
-    /* Floating point always takes the fast path */                            \
-    if (std::numeric_limits<T>::is_iec559)                                     \
-      return CheckedNumeric<T>(lhs.ValueUnsafe() OP rhs.ValueUnsafe());        \
-    if (!rhs.IsValid() || !lhs.IsValid())                                      \
-      return CheckedNumeric<Promotion>(0, false);                              \
-    if (IsIntegerArithmeticSafe<Promotion, T, T>::value)                       \
-      return CheckedNumeric<Promotion>(lhs.ValueUnsafe()                       \
-                                       OP rhs.ValueUnsafe());                  \
-    Promotion result = 0;                                                      \
-    bool is_valid =                                                            \
-        Checked##NAME(static_cast<Promotion>(lhs.ValueUnsafe()),               \
-                      static_cast<Promotion>(rhs.ValueUnsafe()), &result);     \
-    return CheckedNumeric<Promotion>(result, is_valid);                        \
-  }                                                                            \
-  /* Assignment arithmetic operator implementation from CheckedNumeric. */     \
-  template <typename T>                                                        \
-  template <typename Src>                                                      \
-  CheckedNumeric<T>& CheckedNumeric<T>::operator COMPOUND_OP(Src rhs) {        \
-    *this = CheckedNumeric<T>::cast(*this)                                     \
-        OP CheckedNumeric<typename UnderlyingType<Src>::type>::cast(rhs);      \
-    return *this;                                                              \
-  }                                                                            \
-  /* Binary arithmetic operator for CheckedNumeric of different type. */       \
-  template <typename T, typename Src>                                          \
-  CheckedNumeric<typename ArithmeticPromotion<T, Src>::type> operator OP(      \
-      const CheckedNumeric<Src>& lhs, const CheckedNumeric<T>& rhs) {          \
-    typedef typename ArithmeticPromotion<T, Src>::type Promotion;              \
-    if (!rhs.IsValid() || !lhs.IsValid())                                      \
-      return CheckedNumeric<Promotion>(0, false);                              \
-    if (IsIntegerArithmeticSafe<Promotion, T, Src>::value)                     \
-      return CheckedNumeric<Promotion>(lhs.ValueUnsafe() OP rhs.ValueUnsafe());\
-    return CheckedNumeric<Promotion>::cast(lhs)                                \
-        OP CheckedNumeric<Promotion>::cast(rhs);                               \
-  }                                                                            \
-  /* Binary arithmetic operator for left CheckedNumeric and right numeric. */  \
-  template <typename T, typename Src,                                          \
-            typename std::enable_if<std::is_arithmetic<Src>::value>::type* =   \
-                nullptr>                                                       \
-  CheckedNumeric<typename ArithmeticPromotion<T, Src>::type> operator OP(      \
-      const CheckedNumeric<T>& lhs, Src rhs) {                                 \
-    typedef typename ArithmeticPromotion<T, Src>::type Promotion;              \
-    if (IsIntegerArithmeticSafe<Promotion, T, Src>::value)                     \
-      return CheckedNumeric<Promotion>(lhs.ValueUnsafe() OP rhs,               \
-                                       lhs.IsValid());                         \
-    return CheckedNumeric<Promotion>::cast(lhs)                                \
-        OP CheckedNumeric<Promotion>::cast(rhs);                               \
-  }                                                                            \
-  /* Binary arithmetic operator for left numeric and right CheckedNumeric. */  \
-  template <typename T, typename Src,                                          \
-            typename std::enable_if<std::is_arithmetic<Src>::value>::type* =   \
-                nullptr>                                                       \
-  CheckedNumeric<typename ArithmeticPromotion<T, Src>::type> operator OP(      \
-      Src lhs, const CheckedNumeric<T>& rhs) {                                 \
-    typedef typename ArithmeticPromotion<T, Src>::type Promotion;              \
-    if (IsIntegerArithmeticSafe<Promotion, T, Src>::value)                     \
-      return CheckedNumeric<Promotion>(lhs OP rhs.ValueUnsafe(),               \
-                                       rhs.IsValid());                         \
-    return CheckedNumeric<Promotion>::cast(lhs)                                \
-        OP CheckedNumeric<Promotion>::cast(rhs);                               \
+#define BASE_NUMERIC_ARITHMETIC_OPERATORS(NAME, OP, COMPOUND_OP)              \
+  /* Binary arithmetic operator for CheckedNumerics of the same type. */      \
+  template <typename L, typename R>                                           \
+  CheckedNumeric<typename ArithmeticPromotion<L, R>::type> operator OP(       \
+      const CheckedNumeric<L>& lhs, const CheckedNumeric<R>& rhs) {           \
+    using P = typename ArithmeticPromotion<L, R>::type;                       \
+    if (!rhs.IsValid() || !lhs.IsValid())                                     \
+      return CheckedNumeric<P>(0, false);                                     \
+    /* Floating point always takes the fast path */                           \
+    if (std::is_floating_point<L>::value || std::is_floating_point<R>::value) \
+      return CheckedNumeric<P>(lhs.ValueUnsafe() OP rhs.ValueUnsafe());       \
+    P result = 0;                                                             \
+    bool is_valid =                                                           \
+        Checked##NAME(lhs.ValueUnsafe(), rhs.ValueUnsafe(), &result);         \
+    return CheckedNumeric<P>(result, is_valid);                               \
+  }                                                                           \
+  /* Assignment arithmetic operator implementation from CheckedNumeric. */    \
+  template <typename L>                                                       \
+  template <typename R>                                                       \
+  CheckedNumeric<L>& CheckedNumeric<L>::operator COMPOUND_OP(R rhs) {         \
+    *this = *this OP rhs;                                                     \
+    return *this;                                                             \
+  }                                                                           \
+  /* Binary arithmetic operator for left CheckedNumeric and right numeric. */ \
+  template <typename L, typename R,                                           \
+            typename std::enable_if<std::is_arithmetic<R>::value>::type* =    \
+                nullptr>                                                      \
+  CheckedNumeric<typename ArithmeticPromotion<L, R>::type> operator OP(       \
+      const CheckedNumeric<L>& lhs, R rhs) {                                  \
+    return lhs OP CheckedNumeric<R>(rhs);                                     \
+  }                                                                           \
+  /* Binary arithmetic operator for left numeric and right CheckedNumeric. */ \
+  template <typename L, typename R,                                           \
+            typename std::enable_if<std::is_arithmetic<L>::value>::type* =    \
+                nullptr>                                                      \
+  CheckedNumeric<typename ArithmeticPromotion<L, R>::type> operator OP(       \
+      L lhs, const CheckedNumeric<R>& rhs) {                                  \
+    return CheckedNumeric<L>(lhs) OP rhs;                                     \
   }
 
 BASE_NUMERIC_ARITHMETIC_OPERATORS(Add, +, += )
 BASE_NUMERIC_ARITHMETIC_OPERATORS(Sub, -, -= )
 BASE_NUMERIC_ARITHMETIC_OPERATORS(Mul, *, *= )
 BASE_NUMERIC_ARITHMETIC_OPERATORS(Div, /, /= )
 BASE_NUMERIC_ARITHMETIC_OPERATORS(Mod, %, %= )
 
 #undef BASE_NUMERIC_ARITHMETIC_OPERATORS
 
 }  // namespace internal
 
 using internal::CheckedNumeric;
 
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_MATH_H_