clang-format all code

third_party/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 SAFE_MATH_IMPL_H_
 #define SAFE_MATH_IMPL_H_
 
 #include <stdint.h>
 
 #include <cmath>
@@ skipping 155 matching lines @@
     T>::type
 CheckedMul(T x, T y, RangeConstraint* validity) {
   typedef typename TwiceWiderInteger<T>::type IntermediateType;
   IntermediateType tmp =
       static_cast<IntermediateType>(x) * static_cast<IntermediateType>(y);
   *validity = DstRangeRelationToSrcRange<T>(tmp);
   return static_cast<T>(tmp);
 }
 
 template <typename T>
-typename enable_if<std::numeric_limits<T>::is_integer&& std::numeric_limits<
-                       T>::is_signed&&(sizeof(T) * 2 > sizeof(uintmax_t)),
-                   T>::type
+typename enable_if<
+    std::numeric_limits<T>::is_integer &&
+        std::numeric_limits<T>::is_signed&&(sizeof(T) * 2 > sizeof(uintmax_t)),
+    T>::type
 CheckedMul(T x, T y, RangeConstraint* validity) {
   // if either side is zero then the result will be zero.
   if (!(x || y)) {
     return RANGE_VALID;
 
   } else if (x > 0) {
     if (y > 0)
       *validity =
           x <= std::numeric_limits<T>::max() / y ? RANGE_VALID : RANGE_OVERFLOW;
     else
@@ skipping 36 matching lines @@
     *validity = RANGE_OVERFLOW;
     return std::numeric_limits<T>::min();
   }
 
   *validity = RANGE_VALID;
   return x / y;
 }
 
 template <typename T>
 typename enable_if<
-    std::numeric_limits<T>::is_integer&& std::numeric_limits<T>::is_signed,
+    std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_signed,
     T>::type
 CheckedMod(T x, T y, RangeConstraint* validity) {
   *validity = y > 0 ? RANGE_VALID : RANGE_INVALID;
   return x % y;
 }
 
 template <typename T>
 typename enable_if<
     std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed,
     T>::type
 CheckedMod(T x, T y, RangeConstraint* validity) {
   *validity = RANGE_VALID;
   return x % y;
 }
 
 template <typename T>
 typename enable_if<
-    std::numeric_limits<T>::is_integer&& std::numeric_limits<T>::is_signed,
+    std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_signed,
     T>::type
 CheckedNeg(T value, RangeConstraint* validity) {
   *validity =
       value != std::numeric_limits<T>::min() ? RANGE_VALID : RANGE_OVERFLOW;
   // The negation of signed min is min, so catch that one.
   return -value;
 }
 
 template <typename T>
 typename enable_if<
     std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed,
     T>::type
 CheckedNeg(T value, RangeConstraint* validity) {
   // The only legal unsigned negation is zero.
   *validity = value ? RANGE_UNDERFLOW : RANGE_VALID;
   return static_cast<T>(
       -static_cast<typename SignedIntegerForSize<T>::type>(value));
 }
 
 template <typename T>
 typename enable_if<
-    std::numeric_limits<T>::is_integer&& std::numeric_limits<T>::is_signed,
+    std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_signed,
     T>::type
 CheckedAbs(T value, RangeConstraint* validity) {
   *validity =
       value != std::numeric_limits<T>::min() ? RANGE_VALID : RANGE_OVERFLOW;
   return std::abs(value);
 }
 
 template <typename T>
 typename enable_if<
     std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed,
     T>::type
 CheckedAbs(T value, RangeConstraint* validity) {
   // Absolute value of a positive is just its identiy.
   *validity = RANGE_VALID;
   return value;
 }
 
 // These are the floating point stubs that the compiler needs to see. Only the
 // negation operation is ever called.
 #define BASE_FLOAT_ARITHMETIC_STUBS(NAME)                        \
   template <typename T>                                          \
   typename enable_if<std::numeric_limits<T>::is_iec559, T>::type \
-  Checked##NAME(T, T, RangeConstraint*) {                        \
+      Checked##NAME(T, T, RangeConstraint*) {                    \
     NOTREACHED();                                                \
     return 0;                                                    \
   }
 
 BASE_FLOAT_ARITHMETIC_STUBS(Add)
 BASE_FLOAT_ARITHMETIC_STUBS(Sub)
 BASE_FLOAT_ARITHMETIC_STUBS(Mul)
 BASE_FLOAT_ARITHMETIC_STUBS(Div)
 BASE_FLOAT_ARITHMETIC_STUBS(Mod)
 
@@ skipping 24 matching lines @@
 
 template <typename NumericType>
 struct GetNumericRepresentation {
   static const NumericRepresentation value =
       std::numeric_limits<NumericType>::is_integer
           ? NUMERIC_INTEGER
           : (std::numeric_limits<NumericType>::is_iec559 ? NUMERIC_FLOATING
                                                          : NUMERIC_UNKNOWN);
 };
 
-template <typename T, NumericRepresentation type =
-                          GetNumericRepresentation<T>::value>
+template <typename T,
+          NumericRepresentation type = GetNumericRepresentation<T>::value>
 class CheckedNumericState {};
 
 // Integrals require quite a bit of additional housekeeping to manage state.
 template <typename T>
 class CheckedNumericState<T, NUMERIC_INTEGER> {
  private:
   T value_;
   RangeConstraint validity_;
 
  public:
@@ skipping 101 matching lines @@
 
 template <typename Lhs,
           typename Rhs = Lhs,
           ArithmeticPromotionCategory Promotion =
               (MaxExponent<Lhs>::value > MaxExponent<Rhs>::value)
                   ? (MaxExponent<Lhs>::value > MaxExponent<int>::value
                          ? LEFT_PROMOTION
                          : DEFAULT_PROMOTION)
                   : (MaxExponent<Rhs>::value > MaxExponent<int>::value
                          ? RIGHT_PROMOTION
-                         : DEFAULT_PROMOTION) >
-struct ArithmeticPromotion;
+                         : DEFAULT_PROMOTION) > struct ArithmeticPromotion;
 
 template <typename Lhs, typename Rhs>
 struct ArithmeticPromotion<Lhs, Rhs, LEFT_PROMOTION> {
   typedef Lhs type;
 };
 
 template <typename Lhs, typename Rhs>
 struct ArithmeticPromotion<Lhs, Rhs, RIGHT_PROMOTION> {
   typedef Rhs type;
 };
@@ skipping 15 matching lines @@
                             sizeof(T) >= (2 * sizeof(Lhs)) &&
                             StaticDstRangeRelationToSrcRange<T, Rhs>::value !=
                                 NUMERIC_RANGE_CONTAINED &&
                             sizeof(T) >= (2 * sizeof(Rhs));
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // SAFE_MATH_IMPL_H_