protovalidate 0.1.0.beta1

data/ext/protovalidate/sys/third_party/cel-cpp/runtime/function_adapter.h

@@ -0,0 +1,830 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Definitions for template helpers to wrap C++ functions as CEL extension
+// function implementations.
+
+#ifndef THIRD_PARTY_CEL_CPP_RUNTIME_FUNCTION_ADAPTER_H_
+#define THIRD_PARTY_CEL_CPP_RUNTIME_FUNCTION_ADAPTER_H_
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/base/nullability.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "common/function_descriptor.h"
+#include "common/value.h"
+#include "internal/status_macros.h"
+#include "runtime/function.h"
+#include "runtime/internal/function_adapter.h"
+#include "runtime/register_function_helper.h"
+#include "google/protobuf/arena.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/message.h"
+
+namespace cel {
+
+namespace runtime_internal {
+
+template <typename T>
+struct AdaptedTypeTraits {
+  using AssignableType = T;
+
+  static T ToArg(AssignableType v) { return v; }
+};
+
+// Specialization for cref parameters without forcing a temporary copy of the
+// underlying handle argument.
+template <>
+struct AdaptedTypeTraits<const Value&> {
+  using AssignableType = const Value*;
+
+  static std::reference_wrapper<const Value> ToArg(AssignableType v) {
+    return *v;
+  }
+};
+
+template <>
+struct AdaptedTypeTraits<const StringValue&> {
+  using AssignableType = const StringValue*;
+
+  static std::reference_wrapper<const StringValue> ToArg(AssignableType v) {
+    return *v;
+  }
+};
+
+template <>
+struct AdaptedTypeTraits<const BytesValue&> {
+  using AssignableType = const BytesValue*;
+
+  static std::reference_wrapper<const BytesValue> ToArg(AssignableType v) {
+    return *v;
+  }
+};
+
+// Partial specialization for other cases.
+//
+// These types aren't referenceable since they aren't actually
+// represented as alternatives in the underlying variant.
+//
+// This still requires an implicit copy and corresponding ref-count increase.
+template <typename T>
+struct AdaptedTypeTraits<const T&> {
+  using AssignableType = T;
+
+  static T ToArg(AssignableType v) { return v; }
+};
+
+template <size_t I, typename... Args>
+struct AdaptHelperImpl {
+  template <typename T>
+  static absl::Status Apply(absl::Span<const Value> input, T& output) {
+    static_assert(sizeof...(Args) > 0);
+    static_assert(std::tuple_size_v<T> == sizeof...(Args));
+    CEL_RETURN_IF_ERROR(ValueToAdaptedVisitor{input[I]}(&std::get<I>(output)));
+    if constexpr (I == sizeof...(Args) - 1) {
+      return absl::OkStatus();
+    } else {
+      CEL_RETURN_IF_ERROR(
+          (AdaptHelperImpl<I + 1, Args...>::template Apply<T>(input, output)));
+    }
+    return absl::OkStatus();
+  }
+};
+
+template <typename... Args>
+struct AdaptHelper {
+  template <typename T>
+  static absl::Status Apply(absl::Span<const Value> input, T& output) {
+    return AdaptHelperImpl<0, Args...>::template Apply<T>(input, output);
+  }
+};
+
+template <typename... Args>
+struct ToArgsImpl {
+  template <int I, typename T>
+  struct El {
+    using type = T;
+    constexpr static size_t index = I;
+  };
+
+  template <typename... Es>
+  struct ZipHolder {
+    template <typename ResultType, typename TupleType, typename Op>
+    static ResultType ToArgs(Op&& op, const TupleType& argbuffer,
+                             const Function::InvokeContext& context) {
+      return std::forward<Op>(op)(
+          runtime_internal::AdaptedTypeTraits<typename Es::type>::ToArg(
+              std::get<Es::index>(argbuffer))...,
+          context);
+    }
+  };
+
+  template <size_t... Is>
+  static ZipHolder<El<Is, Args>...> MakeZip(const std::index_sequence<Is...>&) {
+    return ZipHolder<El<Is, Args>...>{};
+  }
+};
+
+template <typename... Args>
+struct ToArgsHelper {
+  template <typename ResultType, typename TupleType, typename Op>
+  static ResultType Apply(Op&& op, const TupleType& argbuffer,
+                          const Function::InvokeContext& context) {
+    using Impl = ToArgsImpl<Args...>;
+    using Zip = decltype(Impl::MakeZip(std::index_sequence_for<Args...>{}));
+    return Zip::template ToArgs<ResultType>(std::forward<Op>(op), argbuffer,
+                                            context);
+  }
+};
+
+}  // namespace runtime_internal
+
+// Adapter class for generating CEL extension functions from a one argument
+// function.
+//
+// See documentation for Binary Function adapter for general recommendations.
+//
+// Example Usage:
+//  double Invert(ValueManager&, double x) {
+//   return 1 / x;
+//  }
+//
+//  {
+//    std::unique_ptr<CelExpressionBuilder> builder;
+//
+//    CEL_RETURN_IF_ERROR(
+//      builder->GetRegistry()->Register(
+//        UnaryFunctionAdapter<double, double>::CreateDescriptor("inv",
+//        /*receiver_style=*/false),
+//         UnaryFunctionAdapter<double, double>::WrapFunction(&Invert)));
+//  }
+//  // example CEL expression
+//  inv(4) == 1/4 [true]
+template <typename T>
+class NullaryFunctionAdapter
+    : public RegisterHelper<NullaryFunctionAdapter<T>> {
+ public:
+  using FunctionType =
+      absl::AnyInvocable<T(const Function::InvokeContext&) const>;
+
+  static std::unique_ptr<cel::Function> WrapFunction(FunctionType fn) {
+    return std::make_unique<UnaryFunctionImpl>(std::move(fn));
+  }
+
+  template <typename F>
+  static std::enable_if_t<
+      std::is_invocable_v<F, const google::protobuf::DescriptorPool* absl_nonnull,
+                          google::protobuf::MessageFactory* absl_nonnull,
+                          google::protobuf::Arena* absl_nonnull>,
+      std::unique_ptr<cel::Function>>
+  WrapFunction(F&& function) {
+    return WrapFunction([function = std::forward<F>(function)](
+                            const Function::InvokeContext& context) -> T {
+      return function(context.descriptor_pool(), context.message_factory(),
+                      context.arena());
+    });
+  }
+
+  template <typename F>
+  static std::enable_if_t<std::is_invocable_v<F>,
+                          std::unique_ptr<cel::Function>>
+  WrapFunction(F&& function) {
+    return WrapFunction([function = std::forward<F>(function)](
+                            const Function::InvokeContext& context) -> T {
+      return function();
+    });
+  }
+
+  static FunctionDescriptor CreateDescriptor(absl::string_view name,
+                                             bool receiver_style,
+                                             bool is_strict) {
+    return CreateDescriptor(name, receiver_style,
+                            {is_strict, /*is_contextual=*/false});
+  }
+
+  static FunctionDescriptor CreateDescriptor(
+      absl::string_view name, bool receiver_style,
+      FunctionDescriptorOptions options = {}) {
+    return FunctionDescriptor(name, receiver_style, {}, options);
+  }
+
+ private:
+  class UnaryFunctionImpl : public Function {
+   public:
+    explicit UnaryFunctionImpl(FunctionType fn) : fn_(std::move(fn)) {}
+    absl::StatusOr<Value> Invoke(
+        absl::Span<const Value> args,
+        const Function::InvokeContext& context) const final {
+      if (args.size() != 0) {
+        return absl::InvalidArgumentError(
+            "unexpected number of arguments for nullary function");
+      }
+
+      if constexpr (std::is_same_v<T, Value> ||
+                    std::is_same_v<T, absl::StatusOr<Value>>) {
+        return fn_(context);
+      } else {
+        T result = fn_(context);
+
+        return runtime_internal::AdaptedToValueVisitor{}(std::move(result));
+      }
+    }
+
+   private:
+    FunctionType fn_;
+  };
+};
+
+// Adapter class for generating CEL extension functions from a one argument
+// function.
+//
+// See documentation for Binary Function adapter for general recommendations.
+//
+// Example Usage:
+//  double Invert(ValueManager&, double x) {
+//   return 1 / x;
+//  }
+//
+//  {
+//    std::unique_ptr<CelExpressionBuilder> builder;
+//
+//    CEL_RETURN_IF_ERROR(
+//      builder->GetRegistry()->Register(
+//        UnaryFunctionAdapter<double, double>::CreateDescriptor("inv",
+//        /*receiver_style=*/false),
+//         UnaryFunctionAdapter<double, double>::WrapFunction(&Invert)));
+//  }
+//  // example CEL expression
+//  inv(4) == 1/4 [true]
+template <typename T, typename U>
+class UnaryFunctionAdapter : public RegisterHelper<UnaryFunctionAdapter<T, U>> {
+ public:
+  using FunctionType =
+      absl::AnyInvocable<T(U, const Function::InvokeContext&) const>;
+
+  static std::unique_ptr<cel::Function> WrapFunction(FunctionType fn) {
+    return std::make_unique<UnaryFunctionImpl>(std::move(fn));
+  }
+
+  template <typename F>
+  static std::enable_if_t<
+      std::is_invocable_v<F, U, const google::protobuf::DescriptorPool* absl_nonnull,
+                          google::protobuf::MessageFactory* absl_nonnull,
+                          google::protobuf::Arena* absl_nonnull>,
+      std::unique_ptr<cel::Function>>
+  WrapFunction(F&& function) {
+    return WrapFunction(
+        [function = std::forward<F>(function)](
+            U arg1, const Function::InvokeContext& context) -> T {
+          return function(arg1, context.descriptor_pool(),
+                          context.message_factory(), context.arena());
+        });
+  }
+
+  template <typename F>
+  static std::enable_if_t<std::is_invocable_v<F, U>,
+                          std::unique_ptr<cel::Function>>
+  WrapFunction(F&& function) {
+    return WrapFunction(
+        [function = std::forward<F>(function)](
+            U arg1, const Function::InvokeContext& context) -> T {
+          return function(arg1);
+        });
+  }
+
+  static FunctionDescriptor CreateDescriptor(absl::string_view name,
+                                             bool receiver_style,
+                                             bool is_strict) {
+    return CreateDescriptor(
+        name, receiver_style,
+        FunctionDescriptorOptions{is_strict, /*is_contextual=*/false});
+  }
+
+  static FunctionDescriptor CreateDescriptor(
+      absl::string_view name, bool receiver_style,
+      FunctionDescriptorOptions options = {}) {
+    return FunctionDescriptor(name, receiver_style,
+                              {runtime_internal::AdaptedKind<U>()}, options);
+  }
+
+ private:
+  class UnaryFunctionImpl : public Function {
+   public:
+    explicit UnaryFunctionImpl(FunctionType fn) : fn_(std::move(fn)) {}
+    absl::StatusOr<Value> Invoke(
+        absl::Span<const Value> args,
+        const Function::InvokeContext& context) const final {
+      using ArgTraits = runtime_internal::AdaptedTypeTraits<U>;
+      if (args.size() != 1) {
+        return absl::InvalidArgumentError(
+            "unexpected number of arguments for unary function");
+      }
+      typename ArgTraits::AssignableType arg1;
+
+      CEL_RETURN_IF_ERROR(
+          runtime_internal::ValueToAdaptedVisitor{args[0]}(&arg1));
+      if constexpr (std::is_same_v<T, Value> ||
+                    std::is_same_v<T, absl::StatusOr<Value>>) {
+        return fn_(ArgTraits::ToArg(arg1), context);
+      } else {
+        T result = fn_(ArgTraits::ToArg(arg1), context);
+
+        return runtime_internal::AdaptedToValueVisitor{}(std::move(result));
+      }
+    }
+
+   private:
+    FunctionType fn_;
+  };
+};
+
+// Adapter class for generating CEL extension functions from a two argument
+// function. Generates an implementation of the cel::Function interface that
+// calls the function to wrap.
+//
+// Extension functions must distinguish between recoverable errors (error that
+// should participate in CEL's error pruning) and unrecoverable errors (a non-ok
+// absl::Status that stops evaluation). The function to wrap may return
+// StatusOr<T> to propagate a Status, or return a Value with an Error
+// value to introduce a CEL error.
+//
+// To introduce an extension function that may accept any kind of CEL value as
+// an argument, the wrapped function should use a Value<Handle> parameter and
+// check the type of the argument at evaluation time.
+//
+// Supported CEL to C++ type mappings:
+// bool -> bool
+// double -> double
+// uint -> uint64_t
+// int -> int64_t
+// timestamp -> absl::Time
+// duration -> absl::Duration
+//
+// Complex types may be referred to by cref or value.
+// To return these, users should return a Value.
+// any/dyn -> Value, const Value&
+// string -> StringValue | const StringValue&
+// bytes -> BytesValue | const BytesValue&
+// list -> ListValue | const ListValue&
+// map -> MapValue | const MapValue&
+// struct -> StructValue | const StructValue&
+// null -> NullValue | const NullValue&
+//
+// To intercept error and unknown arguments, users must use a non-strict
+// overload with all arguments typed as any and check the kind of the
+// Value argument.
+//
+// Example Usage:
+//  double SquareDifference(ValueManager&, double x, double y) {
+//    return x * x - y * y;
+//  }
+//
+//  {
+//    RuntimeBuilder builder;
+//    // Initialize Expression builder with built-ins as needed.
+//
+//    CEL_RETURN_IF_ERROR(
+//      builder.function_registry().Register(
+//        BinaryFunctionAdapter<double, double, double>::CreateDescriptor(
+//          "sq_diff", /*receiver_style=*/false),
+//        BinaryFunctionAdapter<double, double, double>::WrapFunction(
+//          &SquareDifference)));
+//
+//
+//    // Alternative shorthand
+//    // See RegisterHelper (template base class) for details.
+//    // runtime/register_function_helper.h
+//    auto status = BinaryFunctionAdapter<double, double, double>::
+//        RegisterGlobalOverload(
+//            "sq_diff",
+//            &SquareDifference,
+//            builder.function_registry());
+//    CEL_RETURN_IF_ERROR(status);
+//  }
+//
+// example CEL expression:
+//  sq_diff(4, 3) == 7 [true]
+//
+template <typename T, typename U, typename V>
+class BinaryFunctionAdapter
+    : public RegisterHelper<BinaryFunctionAdapter<T, U, V>> {
+ public:
+  using FunctionType =
+      absl::AnyInvocable<T(U, V, const Function::InvokeContext&) const>;
+
+  static std::unique_ptr<cel::Function> WrapFunction(FunctionType fn) {
+    return std::make_unique<BinaryFunctionImpl>(std::move(fn));
+  }
+
+  template <typename F>
+  static std::enable_if_t<
+      std::is_invocable_v<F, U, V, const google::protobuf::DescriptorPool* absl_nonnull,
+                          google::protobuf::MessageFactory* absl_nonnull,
+                          google::protobuf::Arena* absl_nonnull>,
+      std::unique_ptr<cel::Function>>
+  WrapFunction(F&& function) {
+    return WrapFunction(
+        [function = std::forward<F>(function)](
+            U arg1, V arg2, const Function::InvokeContext& context) -> T {
+          return function(arg1, arg2, context.descriptor_pool(),
+                          context.message_factory(), context.arena());
+        });
+  }
+
+  template <typename F>
+  static std::enable_if_t<std::is_invocable_v<F, U, V>,
+                          std::unique_ptr<cel::Function>>
+  WrapFunction(F&& function) {
+    return WrapFunction(
+        [function = std::forward<F>(function)](
+            U arg1, V arg2, const Function::InvokeContext& context) -> T {
+          return function(arg1, arg2);
+        });
+  }
+
+  static FunctionDescriptor CreateDescriptor(absl::string_view name,
+                                             bool receiver_style,
+                                             bool is_strict) {
+    return CreateDescriptor(name, receiver_style,
+                            {is_strict, /*is_contextual=*/false});
+  }
+
+  static FunctionDescriptor CreateDescriptor(
+      absl::string_view name, bool receiver_style,
+      FunctionDescriptorOptions options = {}) {
+    return FunctionDescriptor(name, receiver_style,
+                              {runtime_internal::AdaptedKind<U>(),
+                               runtime_internal::AdaptedKind<V>()},
+                              options);
+  }
+
+ private:
+  class BinaryFunctionImpl : public Function {
+   public:
+    explicit BinaryFunctionImpl(FunctionType fn) : fn_(std::move(fn)) {}
+    absl::StatusOr<Value> Invoke(
+        absl::Span<const Value> args,
+        const Function::InvokeContext& context) const final {
+      using Arg1Traits = runtime_internal::AdaptedTypeTraits<U>;
+      using Arg2Traits = runtime_internal::AdaptedTypeTraits<V>;
+      if (args.size() != 2) {
+        return absl::InvalidArgumentError(
+            "unexpected number of arguments for binary function");
+      }
+      typename Arg1Traits::AssignableType arg1;
+      typename Arg2Traits::AssignableType arg2;
+      CEL_RETURN_IF_ERROR(
+          runtime_internal::ValueToAdaptedVisitor{args[0]}(&arg1));
+      CEL_RETURN_IF_ERROR(
+          runtime_internal::ValueToAdaptedVisitor{args[1]}(&arg2));
+
+      if constexpr (std::is_same_v<T, Value> ||
+                    std::is_same_v<T, absl::StatusOr<Value>>) {
+        return fn_(Arg1Traits::ToArg(arg1), Arg2Traits::ToArg(arg2), context);
+      } else {
+        T result =
+            fn_(Arg1Traits::ToArg(arg1), Arg2Traits::ToArg(arg2), context);
+
+        return runtime_internal::AdaptedToValueVisitor{}(std::move(result));
+      }
+    }
+
+   private:
+    BinaryFunctionAdapter::FunctionType fn_;
+  };
+};
+
+template <typename T, typename U, typename V, typename W>
+class TernaryFunctionAdapter
+    : public RegisterHelper<TernaryFunctionAdapter<T, U, V, W>> {
+ public:
+  using FunctionType =
+      absl::AnyInvocable<T(U, V, W, const Function::InvokeContext&) const>;
+
+  static std::unique_ptr<cel::Function> WrapFunction(FunctionType fn) {
+    return std::make_unique<TernaryFunctionImpl>(std::move(fn));
+  }
+
+  template <typename F>
+  static std::enable_if_t<
+      std::is_invocable_v<
+          F, U, V, W, const google::protobuf::DescriptorPool* absl_nonnull,
+          google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull>,
+      std::unique_ptr<cel::Function>>
+  WrapFunction(F&& function) {
+    return WrapFunction([function = std::forward<F>(function)](
+                            U arg1, V arg2, W arg3,
+                            const Function::InvokeContext& context) -> T {
+      return function(arg1, arg2, arg3, context.descriptor_pool(),
+                      context.message_factory(), context.arena());
+    });
+  }
+
+  template <typename F>
+  static std::enable_if_t<std::is_invocable_v<F, U, V, W>,
+                          std::unique_ptr<cel::Function>>
+  WrapFunction(F&& function) {
+    return WrapFunction([function = std::forward<F>(function)](
+                            U arg1, V arg2, W arg3,
+                            const Function::InvokeContext& context) -> T {
+      return function(arg1, arg2, arg3);
+    });
+  }
+
+  static FunctionDescriptor CreateDescriptor(absl::string_view name,
+                                             bool receiver_style,
+                                             bool is_strict) {
+    return CreateDescriptor(
+        name, receiver_style,
+        FunctionDescriptorOptions{is_strict, /*is_contextual=*/false});
+  }
+
+  static FunctionDescriptor CreateDescriptor(
+      absl::string_view name, bool receiver_style,
+      FunctionDescriptorOptions options = {}) {
+    return FunctionDescriptor(
+        name, receiver_style,
+        {runtime_internal::AdaptedKind<U>(), runtime_internal::AdaptedKind<V>(),
+         runtime_internal::AdaptedKind<W>()},
+        options);
+  }
+
+ private:
+  class TernaryFunctionImpl : public Function {
+   public:
+    explicit TernaryFunctionImpl(FunctionType fn) : fn_(std::move(fn)) {}
+    absl::StatusOr<Value> Invoke(
+        absl::Span<const Value> args,
+        const Function::InvokeContext& context) const final {
+      using Arg1Traits = runtime_internal::AdaptedTypeTraits<U>;
+      using Arg2Traits = runtime_internal::AdaptedTypeTraits<V>;
+      using Arg3Traits = runtime_internal::AdaptedTypeTraits<W>;
+      if (args.size() != 3) {
+        return absl::InvalidArgumentError(
+            "unexpected number of arguments for ternary function");
+      }
+      typename Arg1Traits::AssignableType arg1;
+      typename Arg2Traits::AssignableType arg2;
+      typename Arg3Traits::AssignableType arg3;
+      CEL_RETURN_IF_ERROR(
+          runtime_internal::ValueToAdaptedVisitor{args[0]}(&arg1));
+      CEL_RETURN_IF_ERROR(
+          runtime_internal::ValueToAdaptedVisitor{args[1]}(&arg2));
+      CEL_RETURN_IF_ERROR(
+          runtime_internal::ValueToAdaptedVisitor{args[2]}(&arg3));
+
+      if constexpr (std::is_same_v<T, Value> ||
+                    std::is_same_v<T, absl::StatusOr<Value>>) {
+        return fn_(Arg1Traits::ToArg(arg1), Arg2Traits::ToArg(arg2),
+                   Arg3Traits::ToArg(arg3), context);
+      } else {
+        T result = fn_(Arg1Traits::ToArg(arg1), Arg2Traits::ToArg(arg2),
+                       Arg3Traits::ToArg(arg3), context);
+
+        return runtime_internal::AdaptedToValueVisitor{}(std::move(result));
+      }
+    }
+
+   private:
+    TernaryFunctionAdapter::FunctionType fn_;
+  };
+};
+
+template <typename T, typename U, typename V, typename W, typename X>
+class QuaternaryFunctionAdapter
+    : public RegisterHelper<QuaternaryFunctionAdapter<T, U, V, W, X>> {
+ public:
+  using FunctionType =
+      absl::AnyInvocable<T(U, V, W, X, const Function::InvokeContext&) const>;
+
+  static std::unique_ptr<cel::Function> WrapFunction(FunctionType fn) {
+    return std::make_unique<QuaternaryFunctionImpl>(std::move(fn));
+  }
+
+  template <typename F>
+  static std::enable_if_t<
+      std::is_invocable_v<
+          F, U, V, W, X, const google::protobuf::DescriptorPool* absl_nonnull,
+          google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull>,
+      std::unique_ptr<cel::Function>>
+  WrapFunction(F&& function) {
+    return WrapFunction([function = std::forward<F>(function)](
+                            U arg1, V arg2, W arg3, X arg4,
+                            const Function::InvokeContext& context) -> T {
+      return function(arg1, arg2, arg3, arg4, context.descriptor_pool(),
+                      context.message_factory(), context.arena());
+    });
+  }
+
+  template <typename F>
+  static std::enable_if_t<std::is_invocable_v<F, U, V, W, X>,
+                          std::unique_ptr<cel::Function>>
+  WrapFunction(F&& function) {
+    return WrapFunction([function = std::forward<F>(function)](
+                            U arg1, V arg2, W arg3, X arg4,
+                            const Function::InvokeContext& context) -> T {
+      return function(arg1, arg2, arg3, arg4);
+    });
+  }
+
+  static FunctionDescriptor CreateDescriptor(absl::string_view name,
+                                             bool receiver_style,
+                                             bool is_strict) {
+    return CreateDescriptor(name, receiver_style,
+                            {is_strict, /*is_contextual=*/false});
+  }
+
+  static FunctionDescriptor CreateDescriptor(
+      absl::string_view name, bool receiver_style,
+      FunctionDescriptorOptions options = {}) {
+    return FunctionDescriptor(
+        name, receiver_style,
+        {runtime_internal::AdaptedKind<U>(), runtime_internal::AdaptedKind<V>(),
+         runtime_internal::AdaptedKind<W>(),
+         runtime_internal::AdaptedKind<X>()},
+        options);
+  }
+
+ private:
+  class QuaternaryFunctionImpl : public Function {
+   public:
+    explicit QuaternaryFunctionImpl(FunctionType fn) : fn_(std::move(fn)) {}
+    absl::StatusOr<Value> Invoke(
+        absl::Span<const Value> args,
+        const Function::InvokeContext& context) const final {
+      using Arg1Traits = runtime_internal::AdaptedTypeTraits<U>;
+      using Arg2Traits = runtime_internal::AdaptedTypeTraits<V>;
+      using Arg3Traits = runtime_internal::AdaptedTypeTraits<W>;
+      using Arg4Traits = runtime_internal::AdaptedTypeTraits<X>;
+      if (args.size() != 4) {
+        return absl::InvalidArgumentError(
+            "unexpected number of arguments for quaternary function");
+      }
+      typename Arg1Traits::AssignableType arg1;
+      typename Arg2Traits::AssignableType arg2;
+      typename Arg3Traits::AssignableType arg3;
+      typename Arg4Traits::AssignableType arg4;
+      CEL_RETURN_IF_ERROR(
+          runtime_internal::ValueToAdaptedVisitor{args[0]}(&arg1));
+      CEL_RETURN_IF_ERROR(
+          runtime_internal::ValueToAdaptedVisitor{args[1]}(&arg2));
+      CEL_RETURN_IF_ERROR(
+          runtime_internal::ValueToAdaptedVisitor{args[2]}(&arg3));
+      CEL_RETURN_IF_ERROR(
+          runtime_internal::ValueToAdaptedVisitor{args[3]}(&arg4));
+
+      if constexpr (std::is_same_v<T, Value> ||
+                    std::is_same_v<T, absl::StatusOr<Value>>) {
+        return fn_(Arg1Traits::ToArg(arg1), Arg2Traits::ToArg(arg2),
+                   Arg3Traits::ToArg(arg3), Arg4Traits::ToArg(arg4), context);
+      } else {
+        T result =
+            fn_(Arg1Traits::ToArg(arg1), Arg2Traits::ToArg(arg2),
+                Arg3Traits::ToArg(arg3), Arg4Traits::ToArg(arg4), context);
+
+        return runtime_internal::AdaptedToValueVisitor{}(std::move(result));
+      }
+    }
+
+   private:
+    QuaternaryFunctionAdapter::FunctionType fn_;
+  };
+};
+
+// Primary template for n-ary adapter.
+template <typename T, typename... Args>
+class NaryFunctionAdapter;
+
+template <typename T>
+class NaryFunctionAdapter<T> : public NullaryFunctionAdapter<T> {};
+
+template <typename T, typename U>
+class NaryFunctionAdapter<T, U> : public UnaryFunctionAdapter<T, U> {};
+
+template <typename T, typename U, typename V>
+class NaryFunctionAdapter<T, U, V> : public BinaryFunctionAdapter<T, U, V> {};
+
+template <typename T, typename U, typename V, typename W>
+class NaryFunctionAdapter<T, U, V, W>
+    : public TernaryFunctionAdapter<T, U, V, W> {};
+
+template <typename T, typename U, typename V, typename W, typename X>
+class NaryFunctionAdapter<T, U, V, W, X>
+    : public QuaternaryFunctionAdapter<T, U, V, W, X> {};
+
+// N-ary function adapter.
+//
+// Prefer using one of the specific count adapters above for readability and
+// better error messages.
+template <typename T, typename... Args>
+class NaryFunctionAdapter
+    : public RegisterHelper<NaryFunctionAdapter<T, Args...>> {
+ public:
+  using FunctionType =
+      absl::AnyInvocable<T(Args..., const Function::InvokeContext&) const>;
+
+  static FunctionDescriptor CreateDescriptor(absl::string_view name,
+                                             bool receiver_style,
+                                             bool is_strict) {
+    return CreateDescriptor(name, receiver_style,
+                            {is_strict, /*is_contextual=*/false});
+  }
+
+  static FunctionDescriptor CreateDescriptor(
+      absl::string_view name, bool receiver_style,
+      FunctionDescriptorOptions options = {}) {
+    return FunctionDescriptor(name, receiver_style,
+                              {runtime_internal::AdaptedKind<Args>()...},
+                              options);
+  }
+
+  static std::unique_ptr<cel::Function> WrapFunction(FunctionType fn) {
+    return std::make_unique<NaryFunctionImpl>(std::move(fn));
+  }
+
+  template <typename F>
+  static std::enable_if_t<
+      std::is_invocable_v<
+          F, Args..., const google::protobuf::DescriptorPool* absl_nonnull,
+          google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull>,
+      std::unique_ptr<cel::Function>>
+  WrapFunction(F&& function) {
+    return WrapFunction(
+        [function = std::forward<F>(function)](
+            Args... args, const Function::InvokeContext& context) -> T {
+          return function(args..., context.descriptor_pool(),
+                          context.message_factory(), context.arena());
+        });
+  }
+
+  template <typename F>
+  static std::enable_if_t<std::is_invocable_v<F, Args...>,
+                          std::unique_ptr<cel::Function>>
+  WrapFunction(F&& function) {
+    return WrapFunction(
+        [function = std::forward<F>(function)](
+            Args... args, const Function::InvokeContext& context) -> T {
+          return function(args...);
+        });
+  }
+
+ private:
+  class NaryFunctionImpl : public Function {
+   private:
+    using ArgBuffer = std::tuple<
+        typename runtime_internal::AdaptedTypeTraits<Args>::AssignableType...>;
+
+   public:
+    explicit NaryFunctionImpl(FunctionType fn) : fn_(std::move(fn)) {}
+    absl::StatusOr<Value> Invoke(
+        absl::Span<const Value> args,
+        const Function::InvokeContext& context) const final {
+      if (args.size() != sizeof...(Args)) {
+        return absl::InvalidArgumentError(
+            absl::StrCat("unexpected number of arguments for ", sizeof...(Args),
+                         "-ary function"));
+      }
+      ArgBuffer arg_buffer;
+      CEL_RETURN_IF_ERROR(
+          runtime_internal::AdaptHelper<Args...>::Apply(args, arg_buffer));
+      if constexpr (std::is_same_v<T, Value> ||
+                    std::is_same_v<T, absl::StatusOr<Value>>) {
+        return runtime_internal::ToArgsHelper<Args...>::template Apply<T>(
+            fn_, arg_buffer, context);
+      } else {
+        T result = runtime_internal::ToArgsHelper<Args...>::template Apply<T>(
+            fn_, arg_buffer, context);
+        return runtime_internal::AdaptedToValueVisitor{}(std::move(result));
+      }
+    }
+
+   private:
+    FunctionType fn_;
+  };
+};
+
+}  // namespace cel
+
+#endif  // THIRD_PARTY_CEL_CPP_RUNTIME_FUNCTION_ADAPTER_H_