Trait moq::AsyncFunc

pub trait AsyncFunc<Args, Ret> {
    fn call<'a, 'async_trait>(
        &'a self, 
        args: Args
    ) -> Pin<Box<dyn Future<Output = Ret> + Send + 'async_trait>>
    where
        Args: 'a,
        Ret: 'a,
        'a: 'async_trait,
        Self: 'async_trait;
}

Required Methods

fn call<'a, 'async_trait>(
    &'a self,
    args: Args
) -> Pin<Box<dyn Future<Output = Ret> + Send + 'async_trait>> where
    Args: 'a,
    Ret: 'a,
    'a: 'async_trait,
    Self: 'async_trait, 

Implementors

impl<Function, A, B, C, D, E, F, G, H, I, J, K, L, Ret, Fut> AsyncFunc<(A, B, C, D, E, F, G, H, I, J, K, L), Ret> for Function where
    Function: Fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Fut + Sync + 'static,
    Fut: Future<Output = Ret> + Send + 'static,
    A: Send,
    B: Send,
    C: Send,
    D: Send,
    E: Send,
    F: Send,
    G: Send,
    H: Send,
    I: Send,
    J: Send,
    K: Send,
    L: Send, 

impl<Function, A, B, C, D, E, F, G, H, I, J, K, Ret, Fut> AsyncFunc<(A, B, C, D, E, F, G, H, I, J, K), Ret> for Function where
    Function: Fn(A, B, C, D, E, F, G, H, I, J, K) -> Fut + Sync + 'static,
    Fut: Future<Output = Ret> + Send + 'static,
    A: Send,
    B: Send,
    C: Send,
    D: Send,
    E: Send,
    F: Send,
    G: Send,
    H: Send,
    I: Send,
    J: Send,
    K: Send, 

impl<Function, A, B, C, D, E, F, G, H, I, J, Ret, Fut> AsyncFunc<(A, B, C, D, E, F, G, H, I, J), Ret> for Function where
    Function: Fn(A, B, C, D, E, F, G, H, I, J) -> Fut + Sync + 'static,
    Fut: Future<Output = Ret> + Send + 'static,
    A: Send,
    B: Send,
    C: Send,
    D: Send,
    E: Send,
    F: Send,
    G: Send,
    H: Send,
    I: Send,
    J: Send, 

impl<Function, A, B, C, D, E, F, G, H, I, Ret, Fut> AsyncFunc<(A, B, C, D, E, F, G, H, I), Ret> for Function where
    Function: Fn(A, B, C, D, E, F, G, H, I) -> Fut + Sync + 'static,
    Fut: Future<Output = Ret> + Send + 'static,
    A: Send,
    B: Send,
    C: Send,
    D: Send,
    E: Send,
    F: Send,
    G: Send,
    H: Send,
    I: Send, 

impl<Function, A, B, C, D, E, F, G, H, Ret, Fut> AsyncFunc<(A, B, C, D, E, F, G, H), Ret> for Function where
    Function: Fn(A, B, C, D, E, F, G, H) -> Fut + Sync + 'static,
    Fut: Future<Output = Ret> + Send + 'static,
    A: Send,
    B: Send,
    C: Send,
    D: Send,
    E: Send,
    F: Send,
    G: Send,
    H: Send, 

impl<Function, A, B, C, D, E, F, G, Ret, Fut> AsyncFunc<(A, B, C, D, E, F, G), Ret> for Function where
    Function: Fn(A, B, C, D, E, F, G) -> Fut + Sync + 'static,
    Fut: Future<Output = Ret> + Send + 'static,
    A: Send,
    B: Send,
    C: Send,
    D: Send,
    E: Send,
    F: Send,
    G: Send, 

impl<Function, A, B, C, D, E, F, Ret, Fut> AsyncFunc<(A, B, C, D, E, F), Ret> for Function where
    Function: Fn(A, B, C, D, E, F) -> Fut + Sync + 'static,
    Fut: Future<Output = Ret> + Send + 'static,
    A: Send,
    B: Send,
    C: Send,
    D: Send,
    E: Send,
    F: Send, 

impl<Function, A, B, C, D, E, Ret, Fut> AsyncFunc<(A, B, C, D, E), Ret> for Function where
    Function: Fn(A, B, C, D, E) -> Fut + Sync + 'static,
    Fut: Future<Output = Ret> + Send + 'static,
    A: Send,
    B: Send,
    C: Send,
    D: Send,
    E: Send, 

impl<Function, A, B, C, D, Ret, Fut> AsyncFunc<(A, B, C, D), Ret> for Function where
    Function: Fn(A, B, C, D) -> Fut + Sync + 'static,
    Fut: Future<Output = Ret> + Send + 'static,
    A: Send,
    B: Send,
    C: Send,
    D: Send, 

impl<Function, A, B, C, Ret, Fut> AsyncFunc<(A, B, C), Ret> for Function where
    Function: Fn(A, B, C) -> Fut + Sync + 'static,
    Fut: Future<Output = Ret> + Send + 'static,
    A: Send,
    B: Send,
    C: Send, 

impl<Function, A, B, Ret, Fut> AsyncFunc<(A, B), Ret> for Function where
    Function: Fn(A, B) -> Fut + Sync + 'static,
    Fut: Future<Output = Ret> + Send + 'static,
    A: Send,
    B: Send, 

impl<Function, A, Ret, Fut> AsyncFunc<(A,), Ret> for Function where
    Function: Fn(A) -> Fut + Sync + 'static,
    Fut: Future<Output = Ret> + Send + 'static,
    A: Send, 

impl<Function, Ret, Fut> AsyncFunc<(), Ret> for Function where
    Function: Fn() -> Fut + Sync + 'static,
    Fut: Future<Output = Ret> + Send + 'static,