use std::fmt; use std::task::{Context, Poll}; use tower_layer::Layer; use tower_service::Service; /// Service returned by the [`MapRequest`] combinator. /// /// [`MapRequest`]: crate::util::ServiceExt::map_request #[derive(Clone)] pub struct MapRequest { inner: S, f: F, } impl fmt::Debug for MapRequest where S: fmt::Debug, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("MapRequest") .field("inner", &self.inner) .field("f", &format_args!("{}", std::any::type_name::())) .finish() } } impl MapRequest { /// Creates a new [`MapRequest`] service. pub fn new(inner: S, f: F) -> Self { MapRequest { inner, f } } /// Returns a new [`Layer`] that produces [`MapRequest`] services. /// /// This is a convenience function that simply calls [`MapRequestLayer::new`]. /// /// [`Layer`]: tower_layer::Layer pub fn layer(f: F) -> MapRequestLayer { MapRequestLayer { f } } } impl Service for MapRequest where S: Service, F: FnMut(R1) -> R2, { type Response = S::Response; type Error = S::Error; type Future = S::Future; #[inline] fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { self.inner.poll_ready(cx) } #[inline] fn call(&mut self, request: R1) -> S::Future { self.inner.call((self.f)(request)) } } /// A [`Layer`] that produces [`MapRequest`] services. /// /// [`Layer`]: tower_layer::Layer #[derive(Clone, Debug)] pub struct MapRequestLayer { f: F, } impl MapRequestLayer { /// Creates a new [`MapRequestLayer`]. pub fn new(f: F) -> Self { MapRequestLayer { f } } } impl Layer for MapRequestLayer where F: Clone, { type Service = MapRequest; fn layer(&self, inner: S) -> Self::Service { MapRequest { f: self.f.clone(), inner, } } }