Struct ntex_service::dev::ServiceChain
source · pub struct ServiceChain<Svc, Req> { /* private fields */ }
Expand description
Chain builder - chain allows to compose multiple service into one service.
Implementations§
source§impl<Svc: Service<Req>, Req> ServiceChain<Svc, Req>
impl<Svc: Service<Req>, Req> ServiceChain<Svc, Req>
sourcepub fn and_then<Next, F>(
self,
service: F
) -> ServiceChain<AndThen<Svc, Next>, Req>
pub fn and_then<Next, F>( self, service: F ) -> ServiceChain<AndThen<Svc, Next>, Req>
Call another service after call to this one has resolved successfully.
This function can be used to chain two services together and ensure that the second service isn’t called until call to the fist service have finished. Result of the call to the first service is used as an input parameter for the second service’s call.
Note that this function consumes the receiving service and returns a wrapped version of it.
sourcepub fn then<Next, F>(self, service: F) -> ServiceChain<Then<Svc, Next>, Req>
pub fn then<Next, F>(self, service: F) -> ServiceChain<Then<Svc, Next>, Req>
Chain on a computation for when a call to the service finished,
passing the result of the call to the next service U
.
Note that this function consumes the receiving pipeline and returns a wrapped version of it.
sourcepub fn map<F, Res>(self, f: F) -> ServiceChain<Map<Svc, F, Req, Res>, Req>
pub fn map<F, Res>(self, f: F) -> ServiceChain<Map<Svc, F, Req, Res>, Req>
Map this service’s output to a different type, returning a new service of the resulting type.
This function is similar to the Option::map
or Iterator::map
where
it will change the type of the underlying service.
Note that this function consumes the receiving service and returns a
wrapped version of it, similar to the existing map
methods in the
standard library.
sourcepub fn map_err<F, Err>(self, f: F) -> ServiceChain<MapErr<Svc, F, Err>, Req>
pub fn map_err<F, Err>(self, f: F) -> ServiceChain<MapErr<Svc, F, Err>, Req>
Map this service’s error to a different error, returning a new service.
This function is similar to the Result::map_err
where it will change
the error type of the underlying service. This is useful for example to
ensure that services have the same error type.
Note that this function consumes the receiving service and returns a wrapped version of it.
sourcepub fn apply_fn<F, R, In, Out, Err>(
self,
f: F
) -> ServiceChain<Apply<Svc, Req, F, R, In, Out, Err>, In>
pub fn apply_fn<F, R, In, Out, Err>( self, f: F ) -> ServiceChain<Apply<Svc, Req, F, R, In, Out, Err>, In>
Use function as middleware for current service.
Short version of apply_fn(chain(...), fn)
sourcepub fn into_pipeline(self) -> Pipeline<Svc>
pub fn into_pipeline(self) -> Pipeline<Svc>
Create service pipeline
Trait Implementations§
source§impl<Svc, Req> Clone for ServiceChain<Svc, Req>where
Svc: Clone,
impl<Svc, Req> Clone for ServiceChain<Svc, Req>where
Svc: Clone,
source§impl<Svc, Req> Debug for ServiceChain<Svc, Req>where
Svc: Debug,
impl<Svc, Req> Debug for ServiceChain<Svc, Req>where
Svc: Debug,
source§impl<Svc: Service<Req>, Req> Service<Req> for ServiceChain<Svc, Req>
impl<Svc: Service<Req>, Req> Service<Req> for ServiceChain<Svc, Req>
§type Error = <Svc as Service<Req>>::Error
type Error = <Svc as Service<Req>>::Error
source§async fn ready(&self, ctx: ServiceCtx<'_, Self>) -> Result<(), Self::Error>
async fn ready(&self, ctx: ServiceCtx<'_, Self>) -> Result<(), Self::Error>
source§async fn call(
&self,
req: Req,
ctx: ServiceCtx<'_, Self>
) -> Result<Self::Response, Self::Error>
async fn call( &self, req: Req, ctx: ServiceCtx<'_, Self> ) -> Result<Self::Response, Self::Error>
Auto Trait Implementations§
impl<Svc, Req> Freeze for ServiceChain<Svc, Req>where
Svc: Freeze,
impl<Svc, Req> RefUnwindSafe for ServiceChain<Svc, Req>where
Svc: RefUnwindSafe,
Req: RefUnwindSafe,
impl<Svc, Req> Send for ServiceChain<Svc, Req>
impl<Svc, Req> Sync for ServiceChain<Svc, Req>
impl<Svc, Req> Unpin for ServiceChain<Svc, Req>
impl<Svc, Req> UnwindSafe for ServiceChain<Svc, Req>where
Svc: UnwindSafe,
Req: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<Svc, Req> IntoService<Svc, Req> for Svcwhere
Svc: Service<Req>,
impl<Svc, Req> IntoService<Svc, Req> for Svcwhere
Svc: Service<Req>,
source§fn into_service(self) -> Svc
fn into_service(self) -> Svc
Service