Trait ffi_helpers::Split

pub trait Split<Args, Ret> {
    type Trampoline;
    fn trampoline() -> Self::Trampoline;
}

A helper trait used by split_closure() to get a trampoline function which will invoke the closure.

This trait is automatically implemented for any FnMut() callable, you shouldn't implement it yourself.

Associated Types

type Trampoline

Loading content...

Required methods

fn trampoline() -> Self::Trampoline

Loading content...

Implementors

impl<Func, Ret> Split<(), Ret> for Func where
    Func: FnMut() -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A> Split<(A,), Ret> for Func where
    Func: FnMut(A) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A, B> Split<(A, B), Ret> for Func where
    Func: FnMut(A, B) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A, _: B) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A, B, C> Split<(A, B, C), Ret> for Func where
    Func: FnMut(A, B, C) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A, _: B, _: C) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A, B, C, D> Split<(A, B, C, D), Ret> for Func where
    Func: FnMut(A, B, C, D) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A, _: B, _: C, _: D) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A, B, C, D, E> Split<(A, B, C, D, E), Ret> for Func where
    Func: FnMut(A, B, C, D, E) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A, _: B, _: C, _: D, _: E) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A, B, C, D, E, F> Split<(A, B, C, D, E, F), Ret> for Func where
    Func: FnMut(A, B, C, D, E, F) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A, _: B, _: C, _: D, _: E, _: F) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A, B, C, D, E, F, G> Split<(A, B, C, D, E, F, G), Ret> for Func where
    Func: FnMut(A, B, C, D, E, F, G) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A, B, C, D, E, F, G, H> Split<(A, B, C, D, E, F, G, H), Ret> for Func where
    Func: FnMut(A, B, C, D, E, F, G, H) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A, B, C, D, E, F, G, H, I> Split<(A, B, C, D, E, F, G, H, I), Ret> for Func where
    Func: FnMut(A, B, C, D, E, F, G, H, I) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A, B, C, D, E, F, G, H, I, K> Split<(A, B, C, D, E, F, G, H, I, K), Ret> for Func where
    Func: FnMut(A, B, C, D, E, F, G, H, I, K) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: K) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A, B, C, D, E, F, G, H, I, K, L> Split<(A, B, C, D, E, F, G, H, I, K, L), Ret> for Func where
    Func: FnMut(A, B, C, D, E, F, G, H, I, K, L) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: K, _: L) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A, B, C, D, E, F, G, H, I, K, L, M> Split<(A, B, C, D, E, F, G, H, I, K, L, M), Ret> for Func where
    Func: FnMut(A, B, C, D, E, F, G, H, I, K, L, M) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: K, _: L, _: M) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A, B, C, D, E, F, G, H, I, K, L, M, N> Split<(A, B, C, D, E, F, G, H, I, K, L, M, N), Ret> for Func where
    Func: FnMut(A, B, C, D, E, F, G, H, I, K, L, M, N) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: K, _: L, _: M, _: N) -> Ret

fn trampoline() -> Self::Trampoline

impl<Func, Ret, A, B, C, D, E, F, G, H, I, K, L, M, N, O> Split<(A, B, C, D, E, F, G, H, I, K, L, M, N, O), Ret> for Func where
    Func: FnMut(A, B, C, D, E, F, G, H, I, K, L, M, N, O) -> Ret, 

type Trampoline = unsafe extern "C" fn(_: *mut c_void, _: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: K, _: L, _: M, _: N, _: O) -> Ret

fn trampoline() -> Self::Trampoline

Loading content...