Struct gotham::handler::NewHandlerService

pub struct NewHandlerService<T> where
    T: NewHandler + 'static,  { /* fields omitted */ }

Wraps a NewHandler to provide a hyper::server::NewService implementation for Gotham handlers.

Methods

impl<T> NewHandlerService<T> where
    T: NewHandler + 'static, 

fn new(t: T) -> NewHandlerService<T>

Creates a NewHandlerService for the given NewHandler.

Examples

Using a closure which is a NewHandler:

fn handler(state: State, _req: Request) -> (State, Response) {
    let res = create_response(&state, StatusCode::Accepted, None);
    (state, res)
}

NewHandlerService::new(|| Ok(handler));

Using a Router:

fn handler(state: State, _req: Request) -> (State, Response) {
    let res = create_response(&state, StatusCode::Accepted, None);
    (state, res)
}

let mut tree_builder = TreeBuilder::new();
let pipeline_set = finalize_pipeline_set(new_pipeline_set());
let finalizer = ResponseFinalizerBuilder::new().finalize();

let matcher = MethodOnlyRouteMatcher::new(vec![Method::Get]);
let dispatcher = DispatcherImpl::new(|| Ok(handler), (), pipeline_set);
let extractors: Extractors<NoopPathExtractor, NoopQueryStringExtractor> = Extractors::new();
let route = RouteImpl::new(matcher, Box::new(dispatcher), extractors, Delegation::Internal);

tree_builder.add_route(Box::new(route));
let tree = tree_builder.finalize();
let router = Router::new(tree, finalizer);

NewHandlerService::new(router);

Trait Implementations

impl<T> Clone for NewHandlerService<T> where
    T: NewHandler + 'static, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> NewService for NewHandlerService<T> where
    T: NewHandler + 'static, 

type Request = Request

Requests handled by the service

type Response = Response

Responses given by the service

type Error = Error

Errors produced by the service

type Instance = Self

The Service value created by this factory

fn new_service(&self) -> Result<Self::Instance>

Create and return a new service value.

impl<T> Service for NewHandlerService<T> where
    T: NewHandler, 

type Request = Request

Requests handled by the service.

type Response = Response

Responses given by the service.

type Error = Error

Errors produced by the service.

type Future = CpuFuture<Self::Response, Self::Error>

The future response value.

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

Process the request and return the response asynchronously.