Struct swagger::drop_context::DropContextMakeService

pub struct DropContextMakeService<T, C> where
    C: Send + 'static,  { /* fields omitted */ }

Middleware wrapper service that drops the context from the incoming request and passes the plain hyper::Request to the wrapped service.

This service can be used to to include services that take a plain hyper::Request in a CompositeService wrapped in an AddContextService.

Example Usage

In the following example SwaggerService implements hyper::service::MakeService with Request = (hyper::Request, SomeContext), and PlainService implements it with Request = hyper::Request

let swagger_service_one = SwaggerService::new();
let swagger_service_two = SwaggerService::new();
let plain_service = PlainService::new();

let mut composite_new_service = CompositeMakeService::new();
composite_new_service.push(("/base/path/1", swagger_service_one));
composite_new_service.push(("/base/path/2", swagger_service_two));
composite_new_service.push(("/base/path/3", DropContextMakeService::new(plain_service)));

Methods

impl<T, C> DropContextMakeService<T, C> where
    C: Send + 'static, 

pub fn new(inner: T) -> Self

Create a new DropContextMakeService struct wrapping a value

Trait Implementations

impl<T: Debug, C: Debug> Debug for DropContextMakeService<T, C> where
    C: Send + 'static, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a, SC, RC, T, S, F> MakeService<&'a SC> for DropContextMakeService<T, RC> where
    RC: Send + 'static,
    T: MakeService<&'a SC, ReqBody = Body, ResBody = Body, Error = Error, MakeError = Error, Service = S, Future = F>,
    T::Future: 'static,
    S: Service<ReqBody = Body, ResBody = Body, Error = Error> + 'static,
    F: Future<Item = S, Error = Error>, 

type ReqBody = ContextualPayload<Body, RC>

The Payload body of the http::Request.

type ResBody = Body

The Payload body of the http::Response.

type Error = Error

The error type that can be returned by Services.

type MakeError = Error

The error type that can be returned when creating a new Service.

type Future = Box<dyn Future<Item = Self::Service, Error = Error>>

The future returned from new_service of a Service.

type Service = DropContextService<S, RC>

The resolved Service from new_service().

fn make_service(&mut self, service_ctx: &'a SC) -> Self::Future

Create a new Service.

fn poll_ready(&mut self) -> Result<Async<()>, Self::MakeError>

Returns Ready when the constructor is ready to create a new Service.