Convert simple CheckedNumeric functions to constexpr

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 55 matching lines @@
 };
 
 template <typename T>
 class CheckedNumeric {
   static_assert(std::is_arithmetic<T>::value,
                 "CheckedNumeric<T>: T must be a numeric type.");
 
  public:
   typedef T type;
 
-  CheckedNumeric() {}
+  constexpr CheckedNumeric() {}
 
   // Copy constructor.
   template <typename Src>
-  CheckedNumeric(const CheckedNumeric<Src>& rhs)
+  constexpr CheckedNumeric(const CheckedNumeric<Src>& rhs)
       : state_(rhs.state_.value(), rhs.IsValid()) {}
 
   template <typename Src>
   friend class CheckedNumeric;
 
   // This is not an explicit constructor because we implicitly upgrade regular
   // numerics to CheckedNumerics to make them easier to use.
   template <typename Src>
-  CheckedNumeric(Src value)  // NOLINT(runtime/explicit)
+  constexpr CheckedNumeric(Src value)  // NOLINT(runtime/explicit)
       : state_(value) {
     static_assert(std::numeric_limits<Src>::is_specialized,
                   "Argument must be numeric.");
   }
 
   // This is not an explicit constructor because we want a seamless conversion
   // from StrictNumeric types.
   template <typename Src>
-  CheckedNumeric(StrictNumeric<Src> value)  // NOLINT(runtime/explicit)
-      : state_(static_cast<Src>(value)) {
-  }
+  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.
-  bool IsValid() const { return state_.is_valid(); }
+  constexpr bool IsValid() const { return state_.is_valid(); }
 
   // ValueOrDie() The primary accessor for the underlying value. If the current
   // state is not valid it will CHECK and crash.
-  T ValueOrDie() const {
-    CHECK(IsValid());
-    return state_.value();
+  constexpr T ValueOrDie() const {
+    return IsValid() ? state_.value() : CheckOnFailure::HandleFailure<T>();
   }
 
   // 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.
-  T ValueOrDefault(T default_value) const {
+  constexpr T ValueOrDefault(T default_value) const {
     return IsValid() ? state_.value() : 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.
-  T ValueFloating() const {
+  constexpr T ValueFloating() const {
     static_assert(std::numeric_limits<T>::is_iec559, "Argument must be float.");
     return state_.value();
   }
 
   // This friend method is available solely for providing more detailed logging
   // in the the tests. Do not implement it in production code, because the
   // underlying values may change at any time.
   template <typename U>
   friend U GetNumericValueForTest(const CheckedNumeric<U>& src);
 
@@ skipping 25 matching lines @@
     // Absolute value is always valid for floating point.
     T value = 0;
     bool is_valid = (std::numeric_limits<T>::is_iec559 || IsValid()) &&
                     CheckedAbs(state_.value(), &value);
     return CheckedNumeric<T>(value, is_valid);
   }
 
   // This function is available only for integral types. It returns an unsigned
   // integer of the same width as the source type, containing the absolute value
   // of the source, and properly handling signed min.
-  CheckedNumeric<typename UnsignedOrFloatForSize<T>::type> UnsignedAbs() const {
+  constexpr CheckedNumeric<typename UnsignedOrFloatForSize<T>::type>
+  UnsignedAbs() const {
     return CheckedNumeric<typename UnsignedOrFloatForSize<T>::type>(
         SafeUnsignedAbs(state_.value()), state_.is_valid());
   }
 
   CheckedNumeric& operator++() {
     *this += 1;
     return *this;
   }
 
   CheckedNumeric operator++(int) {
@@ skipping 36 matching lines @@
     bool is_valid = state_.is_valid() && Wrapper<R>::is_valid(rhs) &&
                     Math::Op(state_.value(), Wrapper<R>::value(rhs), &result);
     *this = CheckedNumeric<T>(result, is_valid);
     return *this;
   };
 
  private:
   CheckedNumericState<T> state_;
 
   template <typename Src>
-  CheckedNumeric(Src value, bool is_valid) : state_(value, is_valid) {}
+  constexpr CheckedNumeric(Src value, bool is_valid)
+      : state_(value, is_valid) {}
 
   // These wrappers allow us to handle state the same way for both
   // CheckedNumeric and POD arithmetic types.
   template <typename Src>
   struct Wrapper {
-    static bool is_valid(Src) { return true; }
-    static Src value(Src value) { return value; }
+    static constexpr bool is_valid(Src) { return true; }
+    static constexpr Src value(Src value) { return value; }
   };
 
   template <typename Src>
   struct Wrapper<CheckedNumeric<Src>> {
-    static bool is_valid(const CheckedNumeric<Src>& v) { return v.IsValid(); }
-    static Src value(const CheckedNumeric<Src>& v) { return v.state_.value(); }
+    static constexpr bool is_valid(const CheckedNumeric<Src>& v) {
+      return v.IsValid();
+    }
+    static constexpr Src value(const CheckedNumeric<Src>& v) {
+      return v.state_.value();
+    }
   };
 };
 
 // This is just boilerplate for the standard arithmetic operator overloads.
 // A macro isn't the nicest solution, but it beats rewriting these repeatedly.
 #define BASE_NUMERIC_ARITHMETIC_OPERATORS(NAME, OP, COMPOUND_OP)              \
   /* Binary arithmetic operator for all CheckedNumeric operations. */         \
   template <typename L, typename R,                                           \
             typename std::enable_if<UnderlyingType<L>::is_numeric &&          \
                                     UnderlyingType<R>::is_numeric &&          \
@@ skipping 23 matching lines @@
 
 #undef BASE_NUMERIC_ARITHMETIC_OPERATORS
 
 }  // namespace internal
 
 using internal::CheckedNumeric;
 
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_MATH_H_