Class Number

internal/number.h:213–295

Utility class for CEL number operations. In CEL expressions, comparisons between different numeric types are treated as all happening on the same continuous number line. This generally means that integers and doubles in convertible range are compared after converting to doubles (tolerating some loss of precision). This extends to key lookups -- {1: 'abc'}[1.0f] is expected to work since 1.0 == 1

// This extends to key lookups -- {1: 'abc'}[1.0f] is expected to work since
// 1.0 == 1 in CEL.
class Number {
 public:
  // Factories to resolve ambiguous overload resolution against literals.
  static constexpr Number FromInt64(int64_t value) { return Number(value); }
  static constexpr Number FromUint64(uint64_t value) { return Number(value); }
  static constexpr Number FromDouble(double value) { return Number(value); }

  constexpr explicit Number(double double_value) : value_(double_value) {}
  constexpr explicit Number(int64_t int_value) : value_(int_value) {}
  constexpr explicit Number(uint64_t uint_value) : value_(uint_value) {}

  // Return a double representation of the value.
  CEL_ABSL_VISIT_CONSTEXPR double AsDouble() const {
    return absl::visit(internal::ConversionVisitor<double>(), value_);
  }

  // Return signed int64 representation for the value.
  // Caller must guarantee the underlying value is representatble as an
  // int.
  CEL_ABSL_VISIT_CONSTEXPR int64_t AsInt() const {
    return absl::visit(internal::ConversionVisitor<int64_t>(), value_);
  }

  // Return unsigned int64 representation for the value.
  // Caller must guarantee the underlying value is representable as an
  // uint.
  CEL_ABSL_VISIT_CONSTEXPR uint64_t AsUint() const {
    return absl::visit(internal::ConversionVisitor<uint64_t>(), value_);
  }

  // For key lookups, check if the conversion to signed int is lossless.
  CEL_ABSL_VISIT_CONSTEXPR bool LosslessConvertibleToInt() const {
    return absl::visit(internal::LosslessConvertibleToIntVisitor(), value_);
  }

  // For key lookups, check if the conversion to unsigned int is lossless.
  CEL_ABSL_VISIT_CONSTEXPR bool LosslessConvertibleToUint() const {
    return absl::visit(internal::LosslessConvertibleToUintVisitor(), value_);
  }

  CEL_ABSL_VISIT_CONSTEXPR bool operator<(Number other) const {
    return Compare(other) == internal::ComparisonResult::kLesser;
  }

  CEL_ABSL_VISIT_CONSTEXPR bool operator<=(Number other) const {
    internal::ComparisonResult cmp = Compare(other);
    return cmp != internal::ComparisonResult::kGreater &&
           cmp != internal::ComparisonResult::kNanInequal;
  }

  CEL_ABSL_VISIT_CONSTEXPR bool operator>(Number other) const {
    return Compare(other) == internal::ComparisonResult::kGreater;
  }

  CEL_ABSL_VISIT_CONSTEXPR bool operator>=(Number other) const {
    internal::ComparisonResult cmp = Compare(other);
    return cmp != internal::ComparisonResult::kLesser &&
           cmp != internal::ComparisonResult::kNanInequal;