rama_core/layer/
map_err.rs

1use crate::{Context, Layer, Service};
2use rama_utils::macros::define_inner_service_accessors;
3use std::fmt;
4
5/// Maps this service's error value to a different value.
6///
7/// This method can be used to change the [`Error`] type of the service
8/// into a different type. It is similar to the [`Result::map_err`] method.
9///
10/// [`Error`]: crate::error::BoxError
11#[derive(Clone)]
12pub struct MapErr<S, F> {
13    inner: S,
14    f: F,
15}
16
17impl<S, F> fmt::Debug for MapErr<S, F>
18where
19    S: fmt::Debug,
20{
21    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
22        f.debug_struct("MapErr")
23            .field("inner", &self.inner)
24            .field("f", &format_args!("{}", std::any::type_name::<F>()))
25            .finish()
26    }
27}
28
29/// A [`Layer`] that produces [`MapErr`] services.
30///
31/// [`Layer`]: crate::Layer
32#[derive(Clone)]
33pub struct MapErrLayer<F> {
34    f: F,
35}
36
37impl<F> std::fmt::Debug for MapErrLayer<F> {
38    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
39        f.debug_struct("MapErrLayer")
40            .field("f", &format_args!("{}", std::any::type_name::<F>()))
41            .finish()
42    }
43}
44
45impl<S, F> MapErr<S, F> {
46    /// Creates a new [`MapErr`] service.
47    pub const fn new(inner: S, f: F) -> Self {
48        MapErr { f, inner }
49    }
50
51    define_inner_service_accessors!();
52}
53
54impl<S, F, State, Request, Error> Service<State, Request> for MapErr<S, F>
55where
56    S: Service<State, Request>,
57    F: FnOnce(S::Error) -> Error + Clone + Send + Sync + 'static,
58    State: Clone + Send + Sync + 'static,
59    Request: Send + 'static,
60    Error: Send + 'static,
61{
62    type Response = S::Response;
63    type Error = Error;
64
65    async fn serve(
66        &self,
67        ctx: Context<State>,
68        req: Request,
69    ) -> Result<Self::Response, Self::Error> {
70        match self.inner.serve(ctx, req).await {
71            Ok(resp) => Ok(resp),
72            Err(err) => Err((self.f.clone())(err)),
73        }
74    }
75}
76
77impl<F> MapErrLayer<F> {
78    /// Creates a new [`MapErrLayer`].
79    pub const fn new(f: F) -> Self {
80        MapErrLayer { f }
81    }
82}
83
84impl<S, F> Layer<S> for MapErrLayer<F>
85where
86    F: Clone,
87{
88    type Service = MapErr<S, F>;
89
90    fn layer(&self, inner: S) -> Self::Service {
91        MapErr {
92            f: self.f.clone(),
93            inner,
94        }
95    }
96
97    fn into_layer(self, inner: S) -> Self::Service {
98        MapErr { f: self.f, inner }
99    }
100}
rama_core/layer/map_err.rs

rama_core/layer/
map_err.rs
