use http::{Request, Response};
use std::{
fmt,
task::{Context, Poll},
};
use tower_layer::Layer;
use tower_service::Service;
#[derive(Clone)]
pub struct MapRequestBodyLayer<F> {
f: F,
}
impl<F> MapRequestBodyLayer<F> {
pub fn new(f: F) -> Self {
Self { f }
}
}
impl<S, F> Layer<S> for MapRequestBodyLayer<F>
where
F: Clone,
{
type Service = MapRequestBody<S, F>;
fn layer(&self, inner: S) -> Self::Service {
MapRequestBody::new(inner, self.f.clone())
}
}
impl<F> fmt::Debug for MapRequestBodyLayer<F> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("MapRequestBodyLayer")
.field("f", &std::any::type_name::<F>())
.finish()
}
}
#[derive(Clone)]
pub struct MapRequestBody<S, F> {
inner: S,
f: F,
}
impl<S, F> MapRequestBody<S, F> {
pub fn new(service: S, f: F) -> Self {
Self { inner: service, f }
}
pub fn layer(f: F) -> MapRequestBodyLayer<F> {
MapRequestBodyLayer::new(f)
}
define_inner_service_accessors!();
}
impl<F, S, ReqBody, ResBody, NewReqBody> Service<Request<ReqBody>> for MapRequestBody<S, F>
where
S: Service<Request<NewReqBody>, Response = Response<ResBody>>,
F: FnMut(ReqBody) -> NewReqBody,
{
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.inner.poll_ready(cx)
}
fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
let req = req.map(&mut self.f);
self.inner.call(req)
}
}
impl<S, F> fmt::Debug for MapRequestBody<S, F>
where
S: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("MapRequestBody")
.field("inner", &self.inner)
.field("f", &std::any::type_name::<F>())
.finish()
}
}