Deserialization and builders for well known types

PiperOrigin-RevId: 594296131
google · Dec 28, 2023 · 4dce3f7 · 4dce3f7
1 parent 750c731
commit 4dce3f7
Show file tree

Hide file tree

Showing 16 changed files with 1,522 additions and 33 deletions.
diff --git a/common/BUILD b/common/BUILD
@@ -393,7 +393,9 @@ cc_library(
         ":value_kind",
         "//common/internal:data_interface",
         "//common/internal:shared_byte_string",
+        "//internal:deserialize",
         "//internal:no_destructor",
+        "//internal:overflow",
         "//internal:overloaded",
         "//internal:serialize",
         "//internal:status_macros",

diff --git a/common/any.h b/common/any.h
@@ -42,12 +42,24 @@ class Any final {
     return type_url_;
   }
 
+  std::string release_type_url() {
+    std::string type_url;
+    type_url.swap(type_url_);
+    return type_url;
+  }
+
   void set_value(absl::Cord value) { value_ = std::move(value); }
 
   const absl::Cord& value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return value_;
   }
 
+  absl::Cord release_value() {
+    absl::Cord value;
+    value.swap(value_);
+    return value;
+  }
+
   std::string DebugString() const;
 
  private:

diff --git a/common/value.h b/common/value.h
@@ -102,6 +102,24 @@ class Value final {
     return *this;
   }
 
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  Value(const StructValue& value)
+      : Value(CompositionTraits<StructValue>::Get<Value>(value)) {}
+
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  Value(StructValue&& value)
+      : Value(CompositionTraits<StructValue>::Get<Value>(std::move(value))) {}
+
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  Value& operator=(const StructValue& value) {
+    return *this = CompositionTraits<StructValue>::Get<Value>(value);
+  }
+
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  Value& operator=(StructValue&& value) {
+    return *this = CompositionTraits<StructValue>::Get<Value>(std::move(value));
+  }
+
   explicit Value(ValueView other);
 
   Value& operator=(ValueView other);
@@ -447,6 +465,15 @@ struct CompositionTraits<Value> final {
     }
   }
 
+  template <typename U>
+  static std::enable_if_t<std::is_same_v<StructValue, U>, bool> HasA(
+      const Value& value) {
+    value.AssertIsValid();
+    return absl::holds_alternative<common_internal::LegacyStructValue>(
+               value.variant_) ||
+           absl::holds_alternative<ParsedStructValue>(value.variant_);
+  }
+
   template <typename U>
   static std::enable_if_t<common_internal::IsValueAlternativeV<U>, const U&>
   Get(const Value& value) {
@@ -494,6 +521,50 @@ struct CompositionTraits<Value> final {
       return Cast<U>(absl::get<Base>(std::move(value.variant_)));
     }
   }
+
+  template <typename U>
+  static std::enable_if_t<std::is_same_v<StructValue, U>, U> Get(
+      const Value& value) {
+    value.AssertIsValid();
+    if (absl::holds_alternative<common_internal::LegacyStructValue>(
+            value.variant_)) {
+      return U{absl::get<common_internal::LegacyStructValue>(value.variant_)};
+    }
+    return U{absl::get<ParsedStructValue>(value.variant_)};
+  }
+
+  template <typename U>
+  static std::enable_if_t<std::is_same_v<StructValue, U>, U> Get(Value& value) {
+    value.AssertIsValid();
+    if (absl::holds_alternative<common_internal::LegacyStructValue>(
+            value.variant_)) {
+      return U{absl::get<common_internal::LegacyStructValue>(value.variant_)};
+    }
+    return U{absl::get<ParsedStructValue>(value.variant_)};
+  }
+
+  template <typename U>
+  static std::enable_if_t<std::is_same_v<StructValue, U>, U> Get(
+      const Value&& value) {
+    value.AssertIsValid();
+    if (absl::holds_alternative<common_internal::LegacyStructValue>(
+            value.variant_)) {
+      return U{absl::get<common_internal::LegacyStructValue>(value.variant_)};
+    }
+    return U{absl::get<ParsedStructValue>(value.variant_)};
+  }
+
+  template <typename U>
+  static std::enable_if_t<std::is_same_v<StructValue, U>, U> Get(
+      Value&& value) {
+    value.AssertIsValid();
+    if (absl::holds_alternative<common_internal::LegacyStructValue>(
+            value.variant_)) {
+      return U{absl::get<common_internal::LegacyStructValue>(
+          std::move(value.variant_))};
+    }
+    return U{absl::get<ParsedStructValue>(std::move(value.variant_))};
+  }
 };
 
 template <typename To, typename From>
@@ -873,6 +944,15 @@ struct CompositionTraits<ValueView> final {
     }
   }
 
+  template <typename U>
+  static std::enable_if_t<std::is_same_v<StructValueView, U>, bool> HasA(
+      ValueView value) {
+    value.AssertIsValid();
+    return absl::holds_alternative<common_internal::LegacyStructValueView>(
+               value.variant_) ||
+           absl::holds_alternative<ParsedStructValueView>(value.variant_);
+  }
+
   template <typename U>
   static std::enable_if_t<common_internal::IsValueViewAlternativeV<U>, U> Get(
       ValueView value) {
@@ -884,6 +964,18 @@ struct CompositionTraits<ValueView> final {
       return Cast<U>(absl::get<Base>(value.variant_));
     }
   }
+
+  template <typename U>
+  static std::enable_if_t<std::is_same_v<StructValueView, U>, U> Get(
+      ValueView value) {
+    value.AssertIsValid();
+    if (absl::holds_alternative<common_internal::LegacyStructValueView>(
+            value.variant_)) {
+      return U{
+          absl::get<common_internal::LegacyStructValueView>(value.variant_)};
+    }
+    return U{absl::get<ParsedStructValueView>(value.variant_)};
+  }
 };
 
 template <typename To, typename From>

diff --git a/common/value_manager.h b/common/value_manager.h
@@ -17,6 +17,7 @@
 
 #include "absl/base/attributes.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/cord.h"
 #include "absl/strings/string_view.h"
 #include "common/memory.h"
 #include "common/type.h"
@@ -59,6 +60,12 @@ class ValueManager : public virtual ValueFactory, public virtual TypeManager {
     return GetValueProvider().FindValue(*this, name, scratch);
   }
 
+  // See `ValueProvider::DeserializeValue`.
+  absl::StatusOr<Value> DeserializeValue(absl::string_view type_url,
+                                         const absl::Cord& value) {
+    return GetValueProvider().DeserializeValue(*this, type_url, value);
+  }
+
  protected:
   virtual ValueProvider& GetValueProvider() const = 0;
 };