Support overriding the CheckedNumeric value extraction functions

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 82 matching lines @@
   }
 
   // This is not an explicit constructor because we want a seamless conversion
   // from StrictNumeric types.
   template <typename Src>
   constexpr CheckedNumeric(
       StrictNumeric<Src> value)  // NOLINT(runtime/explicit)
       : state_(static_cast<Src>(value)) {}
 
   // IsValid() is the public API to test if a CheckedNumeric is currently valid.
-  constexpr bool IsValid() const { return state_.is_valid(); }
+  // A range checked destination type can be supplied using the Dst template
+  // parameter, which will trigger a CHECK if the value is not in bounds for
+  // the destination.
+  template <typename Dst = T>
+  constexpr bool IsValid() const {
+    return state_.is_valid() &&
+           IsValueInRangeForNumericType<Dst>(state_.value());
+  }
 
   // ValueOrDie() The primary accessor for the underlying value. If the current
   // state is not valid it will CHECK and crash.
-  constexpr T ValueOrDie() const {
-    return IsValid() ? state_.value() : CheckOnFailure::HandleFailure<T>();
+  // A range checked destination type can be supplied using the Dst template
+  // parameter, which will trigger a CHECK if the value is not in bounds for
+  // the destination.
+  // The CHECK behavior can be overridden by supplying a handler as a
+  // template parameter, for test code, etc. However, the handler cannot access
+  // the underlying value, and it is not available through other means.
+  template <typename Dst = T, class CheckHandler = CheckOnFailure>
+  constexpr Dst ValueOrDie() const {
+    return IsValid<Dst>() ? state_.value()
+                          : CheckHandler::template HandleFailure<Dst>();
   }
 
   // ValueOrDefault(T default_value) A convenience method that returns the
   // current value if the state is valid, and the supplied default_value for
   // any other state.
-  constexpr T ValueOrDefault(T default_value) const {
-    return IsValid() ? state_.value() : default_value;
+  // A range checked destination type can be supplied using the Dst template
+  // parameter. WARNING: This function may fail to compile or CHECK at runtime
+  // if the supplied default_value is not within range of the destination type.
+  template <typename Dst = T, typename Src>
+  constexpr Dst ValueOrDefault(const Src default_value) const {
+    return IsValid<Dst>() ? state_.value() : checked_cast<Dst>(default_value);
   }
 
   // ValueFloating() - Since floating point values include their validity state,
   // we provide an easy method for extracting them directly, without a risk of
   // crashing on a CHECK.
-  constexpr T ValueFloating() const {
-    static_assert(std::numeric_limits<T>::is_iec559, "Argument must be float.");
-    return state_.value();
+  // A range checked destination type can be supplied using the Dst template
+  // parameter.
+  template <typename Dst = T>
+  constexpr Dst ValueFloating() const {
+    static_assert(std::numeric_limits<T>::is_iec559,
+                  "Type must be floating point.");
+    static_assert(std::numeric_limits<Dst>::is_iec559,
+                  "Type must be floating point.");
+    return static_cast<Dst>(state_.value());
   }
 
   // Returns a checked numeric of the specified type, cast from the current
   // CheckedNumeric. If the current state is invalid or the destination cannot
   // represent the result then the returned CheckedNumeric will be invalid.
   template <typename Dst>
   constexpr CheckedNumeric<typename UnderlyingType<Dst>::type> Cast() const {
     return *this;
   }
 
@@ skipping 233 matching lines @@
 using internal::CheckMod;
 using internal::CheckLsh;
 using internal::CheckRsh;
 using internal::CheckAnd;
 using internal::CheckOr;
 using internal::CheckXor;
 
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_MATH_H_