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