tower/util/
map_future.rs

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

tower/util/
map_future.rs
