Struct swagger::drop_context::DropContext

pub struct DropContext<T, C> { /* fields omitted */ }

Middleware wrapper service that trops 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 AddContext service.

Example Usage

In the following example SwaggerService implements hyper::server::NewService 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 = CompositeNewService::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", DropContext::new(plain_service)));

Methods

impl<T, C> DropContext<T, C>

pub fn new(inner: T) -> Self

Create a new DropContext struct wrapping a value

Trait Implementations

impl<T: Debug, C: Debug> Debug for DropContext<T, C>

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

Formats the value using the given formatter.

impl<T, C> NewService for DropContext<T, C> where     T: NewService<Request = Request, Response = Response, Error = Error>,

type Request = (Request, C)

Requests handled by the service

type Response = Response

Responses given by the service

type Error = Error

Errors produced by the service

type Instance = DropContext<T::Instance, C>

The Service value created by this factory

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

Create and return a new service value.

impl<T, C> Service for DropContext<T, C> where     T: Service<Request = Request, Response = Response, Error = Error>,

type Request = (Request, C)

Requests handled by the service.

type Response = Response

Responses given by the service.

type Error = Error

Errors produced by the service.

type Future = T::Future

The future response value.

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

Process the request and return the response asynchronously.