iframe-proxy | Sunbelt Computer Software

830 lines (741 loc) · 29 KB
// 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,
}  // 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>> {
  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);
  class UnaryFunctionImpl : public Function {
    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>> {
  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);
  class UnaryFunctionImpl : public Function {
    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>> {
  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);
  class BinaryFunctionImpl : public Function {
    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>> {
  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);
  class TernaryFunctionImpl : public Function {
    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>> {
  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);
  class QuaternaryFunctionImpl : public Function {
    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...>> {
  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...);
        });
  class NaryFunctionImpl : public Function {
   private:
    using ArgBuffer = std::tuple<
        typename runtime_internal::AdaptedTypeTraits<Args>::AssignableType...>;
    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_
Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

FilesExpand file tree

function_adapter.h

Latest commit

History

function_adapter.h

File metadata and controls
