Finalize more parts of the Value API

PiperOrigin-RevId: 732927334

Author: jcking

common/values/duration_value.h

@@ -21,6 +21,7 @@
 #include <ostream>
 #include <string>
 
+#include "absl/base/attributes.h"
 #include "absl/base/nullability.h"
 #include "absl/log/absl_check.h"
 #include "absl/status/status.h"
@@ -91,20 +92,28 @@ class DurationValue final : private common_internal::ValueMixin<DurationValue> {
       absl::Nonnull<google::protobuf::Arena*> arena, absl::Nonnull<Value*> result) const;
   using ValueMixin::Equal;
 
-  bool IsZeroValue() const { return NativeValue() == absl::ZeroDuration(); }
+  bool IsZeroValue() const { return ToDuration() == absl::ZeroDuration(); }
 
+  ABSL_DEPRECATED("Use ToDuration()")
   absl::Duration NativeValue() const {
     return static_cast<absl::Duration>(*this);
   }
 
+  ABSL_DEPRECATED("Use ToDuration()")
   // NOLINTNEXTLINE(google-explicit-constructor)
   operator absl::Duration() const noexcept { return value_; }
 
+  absl::Duration ToDuration() const { return value_; }
+
   friend void swap(DurationValue& lhs, DurationValue& rhs) noexcept {
     using std::swap;
     swap(lhs.value_, rhs.value_);
   }
 
+  friend bool operator==(DurationValue lhs, DurationValue rhs) {
+    return lhs.value_ == rhs.value_;
+  }
+
   friend bool operator<(const DurationValue& lhs, const DurationValue& rhs) {
     return lhs.value_ < rhs.value_;
   }
@@ -122,10 +131,6 @@ inline DurationValue UnsafeDurationValue(absl::Duration value) {
   return DurationValue(absl::in_place, value);
 }
 
-inline bool operator==(DurationValue lhs, DurationValue rhs) {
-  return static_cast<absl::Duration>(lhs) == static_cast<absl::Duration>(rhs);
-}
-
 inline bool operator!=(DurationValue lhs, DurationValue rhs) {
   return !operator==(lhs, rhs);
 }

common/values/error_value.cc

@@ -166,10 +166,10 @@ ErrorValue ErrorValue::Clone(Allocator<> allocator) const {
             }),
         variant_));
   }
-  return ErrorValue(NativeValue());
+  return ErrorValue(ToStatus());
 }
 
-absl::Status ErrorValue::NativeValue() const& {
+absl::Status ErrorValue::ToStatus() const& {
   ABSL_DCHECK(*this);
   return absl::visit(absl::Overload(
                          [](const absl::Status& status) -> const absl::Status& {
@@ -181,7 +181,7 @@ absl::Status ErrorValue::NativeValue() const& {
                      variant_);
 }
 
-absl::Status ErrorValue::NativeValue() && {
+absl::Status ErrorValue::ToStatus() && {
   ABSL_DCHECK(*this);
   return absl::visit(absl::Overload(
                          [](absl::Status&& status) -> absl::Status {

common/values/error_value.h

@@ -24,6 +24,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "absl/base/attributes.h"
 #include "absl/base/nullability.h"
 #include "absl/log/absl_check.h"
 #include "absl/status/status.h"
@@ -98,9 +99,15 @@ class ErrorValue final : private common_internal::ValueMixin<ErrorValue> {
 
   ErrorValue Clone(Allocator<> allocator) const;
 
-  absl::Status NativeValue() const&;
+  absl::Status ToStatus() const&;
 
-  absl::Status NativeValue() &&;
+  absl::Status ToStatus() &&;
+
+  ABSL_DEPRECATED("Use ToStatus()")
+  absl::Status NativeValue() const& { return ToStatus(); }
+
+  ABSL_DEPRECATED("Use ToStatus()")
+  absl::Status NativeValue() && { return std::move(*this).ToStatus(); }
 
   friend void swap(ErrorValue& lhs, ErrorValue& rhs) noexcept;
 

common/values/timestamp_value.h

@@ -21,6 +21,7 @@
 #include <ostream>
 #include <string>
 
+#include "absl/base/attributes.h"
 #include "absl/base/nullability.h"
 #include "absl/log/absl_check.h"
 #include "absl/status/status.h"
@@ -92,18 +93,26 @@ class TimestampValue final
       absl::Nonnull<google::protobuf::Arena*> arena, absl::Nonnull<Value*> result) const;
   using ValueMixin::Equal;
 
-  bool IsZeroValue() const { return NativeValue() == absl::UnixEpoch(); }
+  bool IsZeroValue() const { return ToTime() == absl::UnixEpoch(); }
 
+  ABSL_DEPRECATED("Use ToTime()")
   absl::Time NativeValue() const { return static_cast<absl::Time>(*this); }
 
+  ABSL_DEPRECATED("Use ToTime()")
   // NOLINTNEXTLINE(google-explicit-constructor)
   operator absl::Time() const noexcept { return value_; }
 
+  absl::Time ToTime() const { return value_; }
+
   friend void swap(TimestampValue& lhs, TimestampValue& rhs) noexcept {
     using std::swap;
     swap(lhs.value_, rhs.value_);
   }
 
+  friend bool operator==(TimestampValue lhs, TimestampValue rhs) {
+    return lhs.value_ == rhs.value_;
+  }
+
   friend bool operator<(const TimestampValue& lhs, const TimestampValue& rhs) {
     return lhs.value_ < rhs.value_;
   }
@@ -121,10 +130,6 @@ inline TimestampValue UnsafeTimestampValue(absl::Time value) {
   return TimestampValue(absl::in_place, value);
 }
 
-inline bool operator==(TimestampValue lhs, TimestampValue rhs) {
-  return lhs.NativeValue() == rhs.NativeValue();
-}
-
 inline bool operator!=(TimestampValue lhs, TimestampValue rhs) {
   return !operator==(lhs, rhs);
 }