Struct AppMethod 

pub struct AppMethod<App, F, EP: ?Sized> {
    app: Rc<App>,
    f: F,
    phantom: PhantomData<EP>,
}

An App together with a method on it. Used to pass Apps to actix_web::Handlers as first argument. See api::EndpointDetails::add_to.

Fields

app: Rc<App>

f: F

phantom: PhantomData<EP>

Implementations

impl<App, F, EP: ?Sized> AppMethod<App, F, EP>

pub fn new(app: &Rc<App>, f: F) -> Self

Creates a new AppMethod, cloning App.

Trait Implementations

impl<App, F: Clone, EP> Clone for AppMethod<App, F, EP>

Implement Clone manually so we don’t have to require EP to implement Clone.

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Func, Fut, App, EP> Handler<()> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call(&self, (): ()) -> Self::Future

impl<Func, Fut, App, EP, A> Handler<(A,)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call(&self, (A): (A,)) -> Self::Future

impl<Func, Fut, App, EP, A, B> Handler<(A, B)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call(&self, (A, B): (A, B)) -> Self::Future

impl<Func, Fut, App, EP, A, B, C> Handler<(A, B, C)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call(&self, (A, B, C): (A, B, C)) -> Self::Future

impl<Func, Fut, App, EP, A, B, C, D> Handler<(A, B, C, D)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C, D) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call(&self, (A, B, C, D): (A, B, C, D)) -> Self::Future

impl<Func, Fut, App, EP, A, B, C, D, E> Handler<(A, B, C, D, E)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C, D, E) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call(&self, (A, B, C, D, E): (A, B, C, D, E)) -> Self::Future

impl<Func, Fut, App, EP, A, B, C, D, E, F> Handler<(A, B, C, D, E, F)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C, D, E, F) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call(&self, (A, B, C, D, E, F): (A, B, C, D, E, F)) -> Self::Future

impl<Func, Fut, App, EP, A, B, C, D, E, F, G> Handler<(A, B, C, D, E, F, G)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C, D, E, F, G) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call(&self, (A, B, C, D, E, F, G): (A, B, C, D, E, F, G)) -> Self::Future

impl<Func, Fut, App, EP, A, B, C, D, E, F, G, H> Handler<(A, B, C, D, E, F, G, H)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C, D, E, F, G, H) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call( &self, (A, B, C, D, E, F, G, H): (A, B, C, D, E, F, G, H), ) -> Self::Future

impl<Func, Fut, App, EP, A, B, C, D, E, F, G, H, I> Handler<(A, B, C, D, E, F, G, H, I)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C, D, E, F, G, H, I) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call( &self, (A, B, C, D, E, F, G, H, I): (A, B, C, D, E, F, G, H, I), ) -> Self::Future

impl<Func, Fut, App, EP, A, B, C, D, E, F, G, H, I, J> Handler<(A, B, C, D, E, F, G, H, I, J)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C, D, E, F, G, H, I, J) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call( &self, (A, B, C, D, E, F, G, H, I, J): (A, B, C, D, E, F, G, H, I, J), ) -> Self::Future

impl<Func, Fut, App, EP, A, B, C, D, E, F, G, H, I, J, K> Handler<(A, B, C, D, E, F, G, H, I, J, K)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C, D, E, F, G, H, I, J, K) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call( &self, (A, B, C, D, E, F, G, H, I, J, K): (A, B, C, D, E, F, G, H, I, J, K), ) -> Self::Future

impl<Func, Fut, App, EP, A, B, C, D, E, F, G, H, I, J, K, L> Handler<(A, B, C, D, E, F, G, H, I, J, K, L)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C, D, E, F, G, H, I, J, K, L) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call( &self, (A, B, C, D, E, F, G, H, I, J, K, L): (A, B, C, D, E, F, G, H, I, J, K, L), ) -> Self::Future

impl<Func, Fut, App, EP, A, B, C, D, E, F, G, H, I, J, K, L, M> Handler<(A, B, C, D, E, F, G, H, I, J, K, L, M)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C, D, E, F, G, H, I, J, K, L, M) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call( &self, (A, B, C, D, E, F, G, H, I, J, K, L, M): (A, B, C, D, E, F, G, H, I, J, K, L, M), ) -> Self::Future

impl<Func, Fut, App, EP, A, B, C, D, E, F, G, H, I, J, K, L, M, N> Handler<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call( &self, (A, B, C, D, E, F, G, H, I, J, K, L, M, N): (A, B, C, D, E, F, G, H, I, J, K, L, M, N), ) -> Self::Future

impl<Func, Fut, App, EP, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Handler<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call( &self, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), ) -> Self::Future

impl<Func, Fut, App, EP, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Handler<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> for AppMethod<App, Func, EP>

where Func: Fn(Rc<App>, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Fut + Clone + 'static, Fut: Future, App: 'static, EP: EndpointDetails + 'static, Fut::Output: Into<EP::ResponseType>,

type Output = Responder<EP>

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Responder<EP>>

fn call( &self, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), ) -> Self::Future