Struct swagger::composites::CompositeMakeService

pub struct CompositeMakeService<C, U, V, W>(_)
 where
    V: NotFound<V> + 'static,
    W: 'static;

Wraps a vector of pairs, each consisting of a base path as a &'static str and a MakeService instance. Implements Deref<Vec> and DerefMut<Vec> so these can be manipulated using standard Vec methods.

The Service returned by calling make_service() will pass an incoming request to the first Service in the list for which the associated base path is a prefix of the request path.

Example Usage

let my_make_service1 = MakeService1::new();
let my_make_service2 = MakeService2::new();

let mut composite_make_service = CompositeMakeService::new();
composite_make_service.push(("/base/path/1", my_make_service1));
composite_make_service.push(("/base/path/2", my_make_service2));

// use as you would any `MakeService` instance

Methods

impl<C, U, V: NotFound<V>, W> CompositeMakeService<C, U, V, W>

pub fn new() -> Self

create an empty CompositeMakeService

Trait Implementations

impl<C, U, V, W> Debug for CompositeMakeService<C, U, V, W> where
    V: NotFound<V> + 'static,
    W: 'static, 

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

Formats the value using the given formatter.

impl<C: Default, U: Default, V: Default, W: Default> Default for CompositeMakeService<C, U, V, W> where
    V: NotFound<V> + 'static,
    W: 'static, 

fn default() -> CompositeMakeService<C, U, V, W>

Returns the "default value" for a type.

impl<C, U, V, W> Deref for CompositeMakeService<C, U, V, W> where
    V: NotFound<V> + 'static,
    W: 'static, 

type Target = Vec<(&'static str, Box<dyn BoxedMakeService<C, U, V, W>>)>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<C, U, V, W> DerefMut for CompositeMakeService<C, U, V, W> where
    V: NotFound<V> + 'static,
    W: 'static, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, C, U, V, W> MakeService<&'a C> for CompositeMakeService<&'a C, U, V, W> where
    U: Payload,
    V: NotFound<V> + 'static + Payload,
    W: Error + Send + Sync + 'static, 

type ReqBody = U

The Payload body of the http::Request.

type ResBody = V

The Payload body of the http::Response.

type Error = W

The error type that can be returned by Services.

type Service = CompositeService<U, V, W>

The resolved Service from new_service().

type MakeError = Error

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

type Future = FutureResult<Self::Service, Error>

The future returned from new_service of a Service.

fn make_service(
    &mut self,
    _service_ctx: &'a C
) -> FutureResult<Self::Service, Error>

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.