Trait arma_rs::Factory

pub trait Factory<A, R> {
    unsafe fn call(
        &self, 
        context: Context, 
        output: *mut c_char, 
        size: size_t, 
        args: Option<*mut *mut i8>, 
        count: Option<c_int>
    ) -> c_int;
}

Required methods

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
) -> c_int

Safety

This function is unsafe because it interacts with the C API.

Trait Implementations

impl<O> Executor for dyn Factory<(), O> where
    O: 'static, 

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, O> Executor for dyn Factory<(A,), O> where
    O: 'static,
    A: FromArma + 'static, 

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, O> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J), O> where
    O: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static, 

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, O> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K), O> where
    O: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static, 

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, J, K, L, O> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I, J, K, L), O> where
    O: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static,
    J: FromArma + 'static,
    K: FromArma + 'static,
    L: FromArma + 'static, 

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, O> Executor for dyn Factory<(A, B), O> where
    O: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static, 

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, O> Executor for dyn Factory<(A, B, C), O> where
    O: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static, 

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, O> Executor for dyn Factory<(A, B, C, D), O> where
    O: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static, 

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, O> Executor for dyn Factory<(A, B, C, D, E), O> where
    O: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static, 

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, O> Executor for dyn Factory<(A, B, C, D, E, F), O> where
    O: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static, 

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, O> Executor for dyn Factory<(A, B, C, D, E, F, G), O> where
    O: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static, 

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, O> Executor for dyn Factory<(A, B, C, D, E, F, G, H), O> where
    O: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static, 

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

impl<A, B, C, D, E, F, G, H, I, O> Executor for dyn Factory<(A, B, C, D, E, F, G, H, I), O> where
    O: 'static,
    A: FromArma + 'static,
    B: FromArma + 'static,
    C: FromArma + 'static,
    D: FromArma + 'static,
    E: FromArma + 'static,
    F: FromArma + 'static,
    G: FromArma + 'static,
    H: FromArma + 'static,
    I: FromArma + 'static, 

unsafe fn call(
    &self,
    context: Context,
    output: *mut c_char,
    size: size_t,
    args: Option<*mut *mut i8>,
    count: Option<c_int>
)

Safety

Implementors

impl<Func> Factory<(Context,), ()> for Func where
    Func: Fn(Context), 

impl<Func> Factory<(), ()> for Func where
    Func: Fn(), 

impl<Func, A> Factory<(Context, A), ()> for Func where
    Func: Fn(Context, A),
    A: FromArma, 

impl<Func, A> Factory<(A,), ()> for Func where
    Func: Fn(A),
    A: FromArma, 

impl<Func, A, B> Factory<(Context, A, B), ()> for Func where
    Func: Fn(Context, A, B),
    A: FromArma,
    B: FromArma, 

impl<Func, A, B> Factory<(A, B), ()> for Func where
    Func: Fn(A, B),
    A: FromArma,
    B: FromArma, 

impl<Func, A, B, C> Factory<(Context, A, B, C), ()> for Func where
    Func: Fn(Context, A, B, C),
    A: FromArma,
    B: FromArma,
    C: FromArma, 

impl<Func, A, B, C> Factory<(A, B, C), ()> for Func where
    Func: Fn(A, B, C),
    A: FromArma,
    B: FromArma,
    C: FromArma, 

impl<Func, A, B, C, D> Factory<(Context, A, B, C, D), ()> for Func where
    Func: Fn(Context, A, B, C, D),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma, 

impl<Func, A, B, C, D> Factory<(A, B, C, D), ()> for Func where
    Func: Fn(A, B, C, D),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma, 

impl<Func, A, B, C, D, E> Factory<(Context, A, B, C, D, E), ()> for Func where
    Func: Fn(Context, A, B, C, D, E),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma, 

impl<Func, A, B, C, D, E> Factory<(A, B, C, D, E), ()> for Func where
    Func: Fn(A, B, C, D, E),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma, 

impl<Func, A, B, C, D, E, F> Factory<(Context, A, B, C, D, E, F), ()> for Func where
    Func: Fn(Context, A, B, C, D, E, F),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma, 

impl<Func, A, B, C, D, E, F> Factory<(A, B, C, D, E, F), ()> for Func where
    Func: Fn(A, B, C, D, E, F),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma, 

impl<Func, A, B, C, D, E, F, G> Factory<(Context, A, B, C, D, E, F, G), ()> for Func where
    Func: Fn(Context, A, B, C, D, E, F, G),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma, 

impl<Func, A, B, C, D, E, F, G> Factory<(A, B, C, D, E, F, G), ()> for Func where
    Func: Fn(A, B, C, D, E, F, G),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma, 

impl<Func, A, B, C, D, E, F, G, H> Factory<(Context, A, B, C, D, E, F, G, H), ()> for Func where
    Func: Fn(Context, A, B, C, D, E, F, G, H),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma, 

impl<Func, A, B, C, D, E, F, G, H> Factory<(A, B, C, D, E, F, G, H), ()> for Func where
    Func: Fn(A, B, C, D, E, F, G, H),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I> Factory<(Context, A, B, C, D, E, F, G, H, I), ()> for Func where
    Func: Fn(Context, A, B, C, D, E, F, G, H, I),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I> Factory<(A, B, C, D, E, F, G, H, I), ()> for Func where
    Func: Fn(A, B, C, D, E, F, G, H, I),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, J> Factory<(Context, A, B, C, D, E, F, G, H, I, J), ()> for Func where
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, J> Factory<(A, B, C, D, E, F, G, H, I, J), ()> for Func where
    Func: Fn(A, B, C, D, E, F, G, H, I, J),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, J, K> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K), ()> for Func where
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, J, K> Factory<(A, B, C, D, E, F, G, H, I, J, K), ()> for Func where
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L), ()> for Func where
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L> Factory<(A, B, C, D, E, F, G, H, I, J, K, L), ()> for Func where
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L),
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, R> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K, L), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K, L) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, J, K, L, R> Factory<(A, B, C, D, E, F, G, H, I, J, K, L), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma,
    L: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, J, K, R> Factory<(Context, A, B, C, D, E, F, G, H, I, J, K), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J, K) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, J, K, R> Factory<(A, B, C, D, E, F, G, H, I, J, K), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma,
    K: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, J, R> Factory<(Context, A, B, C, D, E, F, G, H, I, J), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I, J) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, J, R> Factory<(A, B, C, D, E, F, G, H, I, J), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I, J) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma,
    J: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, R> Factory<(Context, A, B, C, D, E, F, G, H, I), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H, I) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, I, R> Factory<(A, B, C, D, E, F, G, H, I), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(A, B, C, D, E, F, G, H, I) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma,
    I: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, R> Factory<(Context, A, B, C, D, E, F, G, H), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G, H) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma, 

impl<Func, A, B, C, D, E, F, G, H, R> Factory<(A, B, C, D, E, F, G, H), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(A, B, C, D, E, F, G, H) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma,
    H: FromArma, 

impl<Func, A, B, C, D, E, F, G, R> Factory<(Context, A, B, C, D, E, F, G), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(Context, A, B, C, D, E, F, G) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma, 

impl<Func, A, B, C, D, E, F, G, R> Factory<(A, B, C, D, E, F, G), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(A, B, C, D, E, F, G) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma,
    G: FromArma, 

impl<Func, A, B, C, D, E, F, R> Factory<(Context, A, B, C, D, E, F), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(Context, A, B, C, D, E, F) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma, 

impl<Func, A, B, C, D, E, F, R> Factory<(A, B, C, D, E, F), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(A, B, C, D, E, F) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma,
    F: FromArma, 

impl<Func, A, B, C, D, E, R> Factory<(Context, A, B, C, D, E), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(Context, A, B, C, D, E) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma, 

impl<Func, A, B, C, D, E, R> Factory<(A, B, C, D, E), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(A, B, C, D, E) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma,
    E: FromArma, 

impl<Func, A, B, C, D, R> Factory<(Context, A, B, C, D), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(Context, A, B, C, D) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma, 

impl<Func, A, B, C, D, R> Factory<(A, B, C, D), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(A, B, C, D) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma,
    D: FromArma, 

impl<Func, A, B, C, R> Factory<(Context, A, B, C), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(Context, A, B, C) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma, 

impl<Func, A, B, C, R> Factory<(A, B, C), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(A, B, C) -> R,
    A: FromArma,
    B: FromArma,
    C: FromArma, 

impl<Func, A, B, R> Factory<(Context, A, B), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(Context, A, B) -> R,
    A: FromArma,
    B: FromArma, 

impl<Func, A, B, R> Factory<(A, B), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(A, B) -> R,
    A: FromArma,
    B: FromArma, 

impl<Func, A, R> Factory<(Context, A), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(Context, A) -> R,
    A: FromArma, 

impl<Func, A, R> Factory<(A,), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(A) -> R,
    A: FromArma, 

impl<Func, R> Factory<(Context,), R> for Func where
    R: IntoArma + 'static,
    Func: Fn(Context) -> R, 

impl<Func, R> Factory<(), R> for Func where
    R: IntoArma + 'static,
    Func: Fn() -> R,