Struct swagger::drop_context::DropContextService

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

Swagger Middleware that wraps a hyper::service::Service or a swagger::client::Service, and drops any contextual information on the request. Servers will normally want to use DropContextMakeService, which will create a DropContextService to handle each connection, while clients can simply wrap a hyper::Client in the middleware.

Client Usage

let client = hyper::Client::new();
let client = DropContextService::new(client);
let body = ContextualPayload { inner: hyper::Body::empty(), context: "Some Context".to_string() };
let request = hyper::Request::get("http://www.google.com").body(body).unwrap();

let response = client.request(request);

Methods

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

pub fn new(inner: T) -> Self

Create a new DropContextService struct wrapping a value

Trait Implementations

impl<T: Clone, C: Clone> Clone for DropContextService<T, C> where
    C: Send + 'static, 

fn clone(&self) -> DropContextService<T, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<T, C> Service for DropContextService<T, C> where
    C: Send + 'static,
    T: Service<ReqBody = Body>, 

type ReqBody = ContextualPayload<Body, C>

Request body taken by client. Likely either hyper::Body, hyper::Chunk or swagger::ContextualPayload.

type Future = T::Future

Future response from client service. Likely: Future<Item=hyper::Response<hyper::Body>, Error=hyper::Error>

fn request(&self, request: Request<Self::ReqBody>) -> Self::Future

Handle the given request

impl<T, C> Service for DropContextService<T, C> where
    C: Send + 'static,
    T: Service<ReqBody = Body, ResBody = Body, Error = Error>, 

type ReqBody = ContextualPayload<Body, C>

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 occur within this Service.

type Future = T::Future

The Future returned by this Service.

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

Calls this Service with a request, returning a Future of the response.

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

Returns Ready when the service is able to process requests.