Trait tvm::function::ToFunction

pub trait ToFunction<I, O> {
    type Handle;
    fn into_raw(self) -> *mut Self::Handle;
    fn call(
        handle: *mut Self::Handle, 
        args: Vec<ArgValue<'a>, Global>
    ) -> Result<RetValue, Error>
    where
        Self: Typed<I, O>;
    fn drop(handle: *mut Self::Handle);

    fn to_function(self) -> Function
    where
        Self: Typed<I, O>,
    { ... }
    unsafe extern "C" fn tvm_callback(
        args: *mut TVMValue, 
        type_codes: *mut i32, 
        num_args: i32, 
        ret: *mut c_void, 
        resource_handle: *mut c_void
    ) -> i32
    where
        Self: Typed<I, O>,
    { ... }
    unsafe extern "C" fn tvm_finalizer(fhandle: *mut c_void) { ... }
}

Associated Types

type Handle

Required methods

fn into_raw(self) -> *mut Self::Handle

fn call(
    handle: *mut Self::Handle,
    args: Vec<ArgValue<'a>, Global>
) -> Result<RetValue, Error> where
    Self: Typed<I, O>, 

fn drop(handle: *mut Self::Handle)

Provided methods

fn to_function(self) -> Function where
    Self: Typed<I, O>, 

unsafe extern "C" fn tvm_callback(
    args: *mut TVMValue,
    type_codes: *mut i32,
    num_args: i32,
    ret: *mut c_void,
    resource_handle: *mut c_void
) -> i32 where
    Self: Typed<I, O>, 

The callback function which is wrapped converted by TVM into a packed function stored in fhandle.

unsafe extern "C" fn tvm_finalizer(fhandle: *mut c_void)

The finalizer which is invoked when the packed function’s reference count is zero.

Implementations on Foreign Types

impl ToFunction<RawArgs, RetValue> for fn(Vec<ArgValue<'arg>, Global>) -> Result<RetValue, Error>

type Handle = fn(Vec<ArgValue<'arg>, Global>) -> Result<RetValue, Error>

pub fn into_raw(
    self
) -> *mut <fn(Vec<ArgValue<'arg>, Global>) -> Result<RetValue, Error> as ToFunction<RawArgs, RetValue>>::Handle

pub fn call(
    handle: *mut <fn(Vec<ArgValue<'arg>, Global>) -> Result<RetValue, Error> as ToFunction<RawArgs, RetValue>>::Handle,
    args: Vec<ArgValue<'arg>, Global>
) -> Result<RetValue, Error>

pub fn drop(
    *mut <fn(Vec<ArgValue<'arg>, Global>) -> Result<RetValue, Error> as ToFunction<RawArgs, RetValue>>::Handle
)

Implementors

impl<Fun, A, B, C, D, E, F, G, H, Out> ToFunction<(A, B, C, D, E, F, G, H), Out> for Fun where
    Fun: 'static + Fn(A, B, C, D, E, F, G, H) -> Out, 

type Handle = Box<dyn Fn(A, B, C, D, E, F, G, H) + 'static, Global>

impl<Fun, A, B, C, D, E, F, G, Out> ToFunction<(A, B, C, D, E, F, G), Out> for Fun where
    Fun: 'static + Fn(A, B, C, D, E, F, G) -> Out, 

type Handle = Box<dyn Fn(A, B, C, D, E, F, G) + 'static, Global>

impl<Fun, A, B, C, D, E, F, Out> ToFunction<(A, B, C, D, E, F), Out> for Fun where
    Fun: 'static + Fn(A, B, C, D, E, F) -> Out, 

type Handle = Box<dyn Fn(A, B, C, D, E, F) + 'static, Global>

impl<Fun, A, B, C, D, E, Out> ToFunction<(A, B, C, D, E), Out> for Fun where
    Fun: 'static + Fn(A, B, C, D, E) -> Out, 

type Handle = Box<dyn Fn(A, B, C, D, E) + 'static, Global>

impl<Fun, A, B, C, D, Out> ToFunction<(A, B, C, D), Out> for Fun where
    Fun: 'static + Fn(A, B, C, D) -> Out, 

type Handle = Box<dyn Fn(A, B, C, D) + 'static, Global>

impl<Fun, A, B, C, Out> ToFunction<(A, B, C), Out> for Fun where
    Fun: 'static + Fn(A, B, C) -> Out, 

type Handle = Box<dyn Fn(A, B, C) + 'static, Global>

impl<Fun, A, B, Out> ToFunction<(A, B), Out> for Fun where
    Fun: 'static + Fn(A, B) -> Out, 

type Handle = Box<dyn Fn(A, B) + 'static, Global>

impl<Fun, A, Out> ToFunction<(A,), Out> for Fun where
    Fun: 'static + Fn(A) -> Out, 

type Handle = Box<dyn Fn(A) + 'static, Global>

impl<Fun, Out> ToFunction<(), Out> for Fun where
    Fun: 'static + Fn() -> Out, 

type Handle = Box<dyn Fn() + 'static, Global>