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

Required methods

fn trampoline() -> Self::Trampoline

Implementors

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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