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 88 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

[scottmg, 2016/11/24 20:23:37]

This comment is misleading since there's an override.

Are you sure you want to overload this to actually be ValueOrDieMostOfTheTime()?
How about adding ValueOrLog()? Alternatively, if it's just for tests, maybe
using a death test?

[jschuh, 2016/11/25 14:56:39]

I've tweaked the comment, and I'm okay with the override because if you prevent
the CHECK then you can't get the value out. So, it really still is ValueOrDie.

+  // the destination.
+  // The CHECK behavior can be overridden by supplying a handler as a
+  // template parameter, however the value cannot be extracted by the handler.
+  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, which will trigger a CHECK if the value is not in bounds for
+  // the destination.
+  template <typename Dst = T, typename Src>
+  constexpr Dst ValueOrDefault(const Src default_value) const {

[scottmg, 2016/11/24 20:23:37]

Similar for the other ones, ValueOrDefault() and ValueOrDefaultAsTargetType<T>()
or whatever you want to call them might be clearer.

[jschuh, 2016/11/25 14:56:39]

This comment was actually wrong, so I fixed it.

+    return IsValueInRangeForNumericType<Dst>(default_value) && IsValid<Dst>()
+               ? state_.value()
+               : static_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, which will trigger a CHECK if the value is not in bounds for
+  // the destination.
+  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 214 matching lines @@
 using internal::CheckSub;
 using internal::CheckMul;
 using internal::CheckDiv;
 using internal::CheckMod;
 using internal::CheckLsh;
 using internal::CheckRsh;
 
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_MATH_H_