Add dispatch table support for OpaqueValue

PiperOrigin-RevId: 736555181

Author: jcking

common/value_testing.cc

@@ -152,7 +152,7 @@ class OptionalValueMatcherImpl
       return false;
     }
     const auto& optional_value = v.GetOptional();
-    if (!optional_value->HasValue()) {
+    if (!optional_value.HasValue()) {
       *listener << "OptionalValue is not engaged";
       return false;
     }
@@ -177,7 +177,7 @@ MATCHER(OptionalValueIsEmptyImpl, "is empty OptionalValue") {
   }
   const auto& optional_value = v.GetOptional();
   *result_listener << (optional_value.HasValue() ? "is not empty" : "is empty");
-  return !optional_value->HasValue();
+  return !optional_value.HasValue();
 }
 
 }  // namespace

common/values/opaque_value.cc

@@ -12,18 +12,25 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <string>
 #include <type_traits>
 #include <utility>
 
 #include "absl/base/nullability.h"
 #include "absl/base/optimization.h"
 #include "absl/log/absl_check.h"
+#include "absl/status/status.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-#include "common/memory.h"
 #include "common/native_type.h"
 #include "common/optional_ref.h"
+#include "common/type.h"
 #include "common/value.h"
 #include "google/protobuf/arena.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/message.h"
 
 namespace cel {
 
@@ -36,18 +43,128 @@ OpaqueValue OpaqueValue::Clone(absl::Nonnull<google::protobuf::Arena*> arena) co
   ABSL_DCHECK(arena != nullptr);
   ABSL_DCHECK(*this);
 
-  if (ABSL_PREDICT_FALSE(!interface_)) {
-    return OpaqueValue();
+  if (ABSL_PREDICT_FALSE(dispatcher_ == nullptr)) {
+    OpaqueValueInterface::Content content =
+        content_.To<OpaqueValueInterface::Content>();
+    if (content.interface == nullptr) {
+      return *this;
+    }
+    if (content.arena != arena) {
+      return content.interface->Clone(arena);
+    }
+    return *this;
   }
-  if (interface_.arena() != arena) {
-    return interface_->Clone(arena);
+  if (dispatcher_->get_arena(dispatcher_, content_) != arena) {
+    return dispatcher_->clone(dispatcher_, content_, arena);
   }
   return *this;
 }
 
+OpaqueType OpaqueValue::GetRuntimeType() const {
+  ABSL_DCHECK(*this);
+
+  if (ABSL_PREDICT_FALSE(dispatcher_ == nullptr)) {
+    OpaqueValueInterface::Content content =
+        content_.To<OpaqueValueInterface::Content>();
+    ABSL_DCHECK(content.interface != nullptr);
+    return content.interface->GetRuntimeType();
+  }
+  return dispatcher_->get_runtime_type(dispatcher_, content_);
+}
+
+absl::string_view OpaqueValue::GetTypeName() const {
+  ABSL_DCHECK(*this);
+
+  if (ABSL_PREDICT_FALSE(dispatcher_ == nullptr)) {
+    OpaqueValueInterface::Content content =
+        content_.To<OpaqueValueInterface::Content>();
+    ABSL_DCHECK(content.interface != nullptr);
+    return content.interface->GetTypeName();
+  }
+  return dispatcher_->get_type_name(dispatcher_, content_);
+}
+
+std::string OpaqueValue::DebugString() const {
+  ABSL_DCHECK(*this);
+
+  if (ABSL_PREDICT_FALSE(dispatcher_ == nullptr)) {
+    OpaqueValueInterface::Content content =
+        content_.To<OpaqueValueInterface::Content>();
+    ABSL_DCHECK(content.interface != nullptr);
+    return content.interface->DebugString();
+  }
+  return dispatcher_->debug_string(dispatcher_, content_);
+}
+
+// See Value::SerializeTo().
+absl::Status OpaqueValue::SerializeTo(
+    absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
+    absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
+    absl::Nonnull<absl::Cord*> value) const {
+  ABSL_DCHECK(descriptor_pool != nullptr);
+  ABSL_DCHECK(message_factory != nullptr);
+  ABSL_DCHECK(value != nullptr);
+
+  return absl::FailedPreconditionError(
+      absl::StrCat(GetTypeName(), "is unserializable"));
+}
+
+// See Value::ConvertToJson().
+absl::Status OpaqueValue::ConvertToJson(
+    absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
+    absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
+    absl::Nonnull<google::protobuf::Message*> json) const {
+  ABSL_DCHECK(descriptor_pool != nullptr);
+  ABSL_DCHECK(message_factory != nullptr);
+  ABSL_DCHECK(json != nullptr);
+
+  return absl::FailedPreconditionError(
+      absl::StrCat(GetTypeName(), " is not convertable to JSON"));
+}
+
+absl::Status OpaqueValue::Equal(
+    const Value& other,
+    absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
+    absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
+    absl::Nonnull<google::protobuf::Arena*> arena, absl::Nonnull<Value*> result) const {
+  ABSL_DCHECK(descriptor_pool != nullptr);
+  ABSL_DCHECK(message_factory != nullptr);
+  ABSL_DCHECK(arena != nullptr);
+  ABSL_DCHECK(result != nullptr);
+
+  if (auto other_opaque = other.AsOpaque(); other_opaque) {
+    if (ABSL_PREDICT_FALSE(dispatcher_ == nullptr)) {
+      OpaqueValueInterface::Content content =
+          content_.To<OpaqueValueInterface::Content>();
+      ABSL_DCHECK(content.interface != nullptr);
+      return content.interface->Equal(*other_opaque, descriptor_pool,
+                                      message_factory, arena, result);
+    }
+    return dispatcher_->equal(dispatcher_, content_, *other_opaque,
+                              descriptor_pool, message_factory, arena, result);
+  }
+  *result = FalseValue();
+  return absl::OkStatus();
+}
+
+NativeTypeId OpaqueValue::GetTypeId() const {
+  ABSL_DCHECK(*this);
+
+  if (ABSL_PREDICT_FALSE(dispatcher_ == nullptr)) {
+    OpaqueValueInterface::Content content =
+        content_.To<OpaqueValueInterface::Content>();
+    if (content.interface == nullptr) {
+      return NativeTypeId();
+    }
+    return NativeTypeId::Of(*content.interface);
+  }
+  return dispatcher_->get_type_id(dispatcher_, content_);
+}
+
 bool OpaqueValue::IsOptional() const {
-  return NativeTypeId::Of(*interface_) ==
-         NativeTypeId::For<OptionalValueInterface>();
+  return dispatcher_ != nullptr &&
+         dispatcher_->get_type_id(dispatcher_, content_) ==
+             NativeTypeId::For<OptionalValue>();
 }
 
 optional_ref<const OptionalValue> OpaqueValue::AsOptional() const& {