Split out code to be shared between CheckedNumeric and ClampedNumeric

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 520 matching lines @@
 struct ArithmeticOrUnderlyingEnum<T, false> {
   using type = T;
   static const bool value = std::is_arithmetic<type>::value;
 };
 
 // The following are helper templates used in the CheckedNumeric class.
 template <typename T>
 class CheckedNumeric;
 
 template <typename T>
+class ClampedNumeric;
+
+template <typename T>
 class StrictNumeric;
 
 // Used to treat CheckedNumeric and arithmetic underlying types the same.
 template <typename T>
 struct UnderlyingType {
   using type = typename ArithmeticOrUnderlyingEnum<T>::type;
   static const bool is_numeric = std::is_arithmetic<type>::value;
   static const bool is_checked = false;
   static const bool is_strict = false;
 };
 
 template <typename T>
 struct UnderlyingType<CheckedNumeric<T>> {
   using type = T;
   static const bool is_numeric = true;
   static const bool is_checked = true;
+  static const bool is_clamped = false;
   static const bool is_strict = false;
 };
 
+template <typename T>
+struct UnderlyingType<ClampedNumeric<T>> {
+  using type = T;
+  static const bool is_numeric = true;
+  static const bool is_checked = false;
+  static const bool is_clamped = true;
+  static const bool is_strict = false;
+};
+
 template <typename T>
 struct UnderlyingType<StrictNumeric<T>> {
   using type = T;
   static const bool is_numeric = true;
   static const bool is_checked = false;
+  static const bool is_clamped = false;
   static const bool is_strict = 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 <typename L, typename R>
+struct IsClampedOp {
+  static const bool value =
+      UnderlyingType<L>::is_numeric && UnderlyingType<R>::is_numeric &&
+      (UnderlyingType<L>::is_clamped || UnderlyingType<R>::is_clamped);
+};
+
+template <typename L, typename R>
 struct IsStrictOp {
   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,
@@ skipping 109 matching lines @@
                 "Types must be numeric.");
   using Promotion = BigEnoughPromotion<L, R>;
   using BigType = typename Promotion::type;
   return Promotion::is_contained
              // Force to a larger type for speed if both are contained.
              ? C<BigType, BigType>::Test(
                    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_