Class Function

include/tvm/ffi/function.h:320–719

! * \brief ffi::Function is a type-erased function. * The arguments are passed by "packed format" via AnyView */

 *  The arguments are passed by "packed format" via AnyView
 */
class Function : public ObjectRef {
 public:
  /*! \brief Constructor from null */
  Function(std::nullptr_t) : ObjectRef(nullptr) {}  // NOLINT(*)
  /*!
   * \brief Constructing a packed function from a callable type
   *        whose signature is consistent with `ffi::Function`
   * \param packed_call The packed function signature
   * \note legacy purpose, should change to Function::FromPacked for mostfuture use.
   */
  template <typename TCallable,
            typename = std::enable_if_t<!std::is_same_v<std::decay_t<TCallable>, Function>>>
  explicit Function(TCallable&& packed_call) {
    *this = FromPacked(std::forward<TCallable>(packed_call));
  }
  /*!
   * \brief Constructing a packed function from a callable type
   *        whose signature is consistent with `ffi::Function`
   * \param packed_call The packed function signature
   */
  template <typename TCallable>
  static Function FromPacked(TCallable&& packed_call) {
    static_assert(
        std::is_convertible_v<TCallable, std::function<void(const AnyView*, int32_t, Any*)>> ||
            std::is_convertible_v<TCallable, std::function<void(PackedArgs args, Any*)>>,
        "tvm::ffi::Function::FromPacked requires input function signature to match packed func "
        "format");
    if constexpr (std::is_convertible_v<TCallable, std::function<void(PackedArgs args, Any*)>>) {
      return FromPackedInternal(
          [packed_call = std::forward<TCallable>(packed_call)](
              const AnyView* args, int32_t num_args, Any* rv) mutable -> void {
            packed_call(PackedArgs{args, num_args}, rv);
          });
    } else {
      return FromPackedInternal(std::forward<TCallable>(packed_call));
    }
  }

  /*!
   * \brief Constructing a packed function from a callable type
   *        whose signature is consistent with `ffi::Function`.
   *        It will create the Callable object with the given arguments,
   *        and return the inplace constructed Function along with
   *        the pointer to the callable object. The lifetime of the callable
   *        object is managed by the returned Function.
   * \param args The arguments to construct TCallable
   * \return A tuple of (Function, TCallable*)
   */
  template <typename TCallable, typename... Args>
  static auto FromPackedInplace(Args&&... args) {
    // We must ensure TCallable is a value type (decay_t) that can hold the callable object
    static_assert(std::is_same_v<TCallable, std::decay_t<TCallable>>);
    static_assert(std::is_invocable_v<TCallable, const AnyView*, int32_t, Any*>);
    using ObjType = details::FunctionObjImpl<TCallable>;
    Function func;
    auto obj_ptr = make_object<ObjType>(std::forward<Args>(args)...);
    auto* call_ptr = obj_ptr->GetCallable();
    func.data_ = std::move(obj_ptr);