1use futures_util::{future, TryFutureExt};
2use std::fmt;
3use std::task::{Context, Poll};
4use tower_layer::Layer;
5use tower_service::Service;
6
7/// Service returned by the [`map_err`] combinator.
8///
9/// [`map_err`]: crate::util::ServiceExt::map_err
10#[derive(Clone)]
11pub struct MapErr<S, F> {
12 inner: S,
13 f: F,
14}
15
16impl<S, F> fmt::Debug for MapErr<S, F>
17where
18 S: fmt::Debug,
19{
20 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
21 f&mut DebugStruct<'_, '_>.debug_struct("MapErr")
22 .field("inner", &self.inner)
23 .field(name:"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)]
32pub struct MapErrLayer<F> {
33 f: F,
34}
35
36opaque_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
43impl<S, F> MapErr<S, F> {
44 /// Creates a new [`MapErr`] service.
45 pub const 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
54 pub fn layer(f: F) -> MapErrLayer<F> {
55 MapErrLayer { f }
56 }
57}
58
59impl<S, F, Request, Error> Service<Request> for MapErr<S, F>
60where
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]
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]
74 fn call(&mut self, request: Request) -> Self::Future {
75 MapErrFuture::new(self.inner.call(req:request).map_err(self.f.clone()))
76 }
77}
78
79impl<F> MapErrLayer<F> {
80 /// Creates a new [`MapErrLayer`].
81 pub const fn new(f: F) -> Self {
82 MapErrLayer { f }
83 }
84}
85
86impl<S, F> Layer<S> for MapErrLayer<F>
87where
88 F: Clone,
89{
90 type Service = MapErr<S, F>;
91
92 fn layer(&self, inner: S) -> Self::Service {
93 MapErr {
94 f: self.f.clone(),
95 inner,
96 }
97 }
98}
99