1 use std::fmt;
2 use std::task::{Context, Poll};
3 use tower_layer::Layer;
4 use tower_service::Service;
5 
6 /// Service returned by the [`MapRequest`] combinator.
7 ///
8 /// [`MapRequest`]: crate::util::ServiceExt::map_request
9 #[derive(Clone)]
10 pub struct MapRequest<S, F> {
11     inner: S,
12     f: F,
13 }
14 
15 impl<S, F> fmt::Debug for MapRequest<S, F>
16 where
17     S: fmt::Debug,
18 {
fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result19     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
20         f.debug_struct("MapRequest")
21             .field("inner", &self.inner)
22             .field("f", &format_args!("{}", std::any::type_name::<F>()))
23             .finish()
24     }
25 }
26 
27 impl<S, F> MapRequest<S, F> {
28     /// Creates a new [`MapRequest`] service.
new(inner: S, f: F) -> Self29     pub fn new(inner: S, f: F) -> Self {
30         MapRequest { inner, f }
31     }
32 
33     /// Returns a new [`Layer`] that produces [`MapRequest`] services.
34     ///
35     /// This is a convenience function that simply calls [`MapRequestLayer::new`].
36     ///
37     /// [`Layer`]: tower_layer::Layer
layer(f: F) -> MapRequestLayer<F>38     pub fn layer(f: F) -> MapRequestLayer<F> {
39         MapRequestLayer { f }
40     }
41 }
42 
43 impl<S, F, R1, R2> Service<R1> for MapRequest<S, F>
44 where
45     S: Service<R2>,
46     F: FnMut(R1) -> R2,
47 {
48     type Response = S::Response;
49     type Error = S::Error;
50     type Future = S::Future;
51 
52     #[inline]
poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), S::Error>>53     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
54         self.inner.poll_ready(cx)
55     }
56 
57     #[inline]
call(&mut self, request: R1) -> S::Future58     fn call(&mut self, request: R1) -> S::Future {
59         self.inner.call((self.f)(request))
60     }
61 }
62 
63 /// A [`Layer`] that produces [`MapRequest`] services.
64 ///
65 /// [`Layer`]: tower_layer::Layer
66 #[derive(Clone, Debug)]
67 pub struct MapRequestLayer<F> {
68     f: F,
69 }
70 
71 impl<F> MapRequestLayer<F> {
72     /// Creates a new [`MapRequestLayer`].
new(f: F) -> Self73     pub fn new(f: F) -> Self {
74         MapRequestLayer { f }
75     }
76 }
77 
78 impl<S, F> Layer<S> for MapRequestLayer<F>
79 where
80     F: Clone,
81 {
82     type Service = MapRequest<S, F>;
83 
layer(&self, inner: S) -> Self::Service84     fn layer(&self, inner: S) -> Self::Service {
85         MapRequest {
86             f: self.f.clone(),
87             inner,
88         }
89     }
90 }
91