Struct xitca_http::util::middleware::context::ContextBuilder

pub struct ContextBuilder<CF> { /* private fields */ }

ServiceFactory type for constructing compile time checked stateful service.

State is roughly doing the same thing as move || style closure capture. The difference comes down to:

• The captured state is constructed lazily when Service::call method is called.

• State can be referenced in nested types and beyond closures.

Example:

 // function service.
 async fn state_handler(req: Context<'_, String, String>) -> Result<String, Infallible> {
    let (parent_req, state) = req.into_parts();
    assert_eq!(state, "string_state");
    Ok(String::from("string_response"))
 }

 // Construct Stateful service builder with closure.
 let service = fn_service(state_handler)
     // Stateful service builder would construct given service builder and pass (&State, Req) to it's
     // Service::call method.
     .enclosed(ContextBuilder::new(|| async { Ok::<_, Infallible>(String::from("string_state")) }))
     .call(())
     .await
     .unwrap();

 let req = String::default();
 let res = service.call(req).await.unwrap();
 assert_eq!(res, "string_response");

Implementations

impl<CF, Fut, C, CErr> ContextBuilder<CF>

where CF: Fn() -> Fut, Fut: Future<Output = Result<C, CErr>>,

pub fn new(builder: CF) -> Self

Make a stateful service factory with given future.

Trait Implementations

impl<CF, Fut, C, CErr, S, E> Service<Result<S, E>> for ContextBuilder<CF>

where CF: Fn() -> Fut, Fut: Future<Output = Result<C, CErr>>, C: 'static, CErr: Debug + 'static, E: Debug + 'static,

type Response = ContextService<C, S>

The Ok part of output future.

type Error = Box<dyn Debug>

The Err part of output future.

async fn call(&self, res: Result<S, E>) -> Result<Self::Response, Self::Error>