tower/util/
then.rs

1use futures_util::{future, FutureExt};
2use std::{
3    fmt,
4    future::Future,
5    task::{Context, Poll},
6};
7use tower_layer::Layer;
8use tower_service::Service;
9
10/// [`Service`] returned by the [`then`] combinator.
11///
12/// [`then`]: crate::util::ServiceExt::then
13#[derive(Clone)]
14pub struct Then<S, F> {
15    inner: S,
16    f: F,
17}
18
19impl<S, F> fmt::Debug for Then<S, F>
20where
21    S: fmt::Debug,
22{
23    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
24        f.debug_struct("Then")
25            .field("inner", &self.inner)
26            .field("f", &format_args!("{}", std::any::type_name::<F>()))
27            .finish()
28    }
29}
30
31/// A [`Layer`] that produces a [`Then`] service.
32///
33/// [`Layer`]: tower_layer::Layer
34#[derive(Debug, Clone)]
35pub struct ThenLayer<F> {
36    f: F,
37}
38
39impl<S, F> Then<S, F> {
40    /// Creates a new `Then` service.
41    pub const fn new(inner: S, f: F) -> Self {
42        Then { f, inner }
43    }
44
45    /// Returns a new [`Layer`] that produces [`Then`] services.
46    ///
47    /// This is a convenience function that simply calls [`ThenLayer::new`].
48    ///
49    /// [`Layer`]: tower_layer::Layer
50    pub fn layer(f: F) -> ThenLayer<F> {
51        ThenLayer { f }
52    }
53}
54
55opaque_future! {
56    /// Response future from [`Then`] services.
57    ///
58    /// [`Then`]: crate::util::Then
59    pub type ThenFuture<F1, F2, N> = future::Then<F1, F2, N>;
60}
61
62impl<S, F, Request, Response, Error, Fut> Service<Request> for Then<S, F>
63where
64    S: Service<Request>,
65    S::Error: Into<Error>,
66    F: FnOnce(Result<S::Response, S::Error>) -> Fut + Clone,
67    Fut: Future<Output = Result<Response, Error>>,
68{
69    type Response = Response;
70    type Error = Error;
71    type Future = ThenFuture<S::Future, Fut, F>;
72
73    #[inline]
74    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
75        self.inner.poll_ready(cx).map_err(Into::into)
76    }
77
78    #[inline]
79    fn call(&mut self, request: Request) -> Self::Future {
80        ThenFuture::new(self.inner.call(request).then(self.f.clone()))
81    }
82}
83
84impl<F> ThenLayer<F> {
85    /// Creates a new [`ThenLayer`] layer.
86    pub const fn new(f: F) -> Self {
87        ThenLayer { f }
88    }
89}
90
91impl<S, F> Layer<S> for ThenLayer<F>
92where
93    F: Clone,
94{
95    type Service = Then<S, F>;
96
97    fn layer(&self, inner: S) -> Self::Service {
98        Then {
99            f: self.f.clone(),
100            inner,
101        }
102    }
103}
tower/util/then.rs

tower/util/
then.rs
