# map_err.rs - source
Source of the Rust file `/home/runner/.cargo/registry/src/github.com-1ecc6299db9ec823/http-body-0.4.1/src/combinators/map_err.rs`.
Keywords: rust, rustlang, rust-lang

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83

    use crate::Body;
    use pin_project_lite::pin_project;
    use std::{
        pin::Pin,
        task::{Context, Poll},
    };

    pin_project! {
        /// Body returned by the [`map_err`] combinator.
        ///
        /// [`map_err`]: crate::util::BodyExt::map_err
        #[derive(Debug, Clone, Copy)]
        pub struct MapErr<B, F> {
            #[pin]
            inner: B,
            f: F
        }
    }

    impl<B, F> MapErr<B, F> {
        #[inline]
        pub(crate) fn new(body: B, f: F) -> Self {
            Self { inner: body, f }
        }

        /// Get a reference to the inner body
        pub fn get_ref(&self) -> &B {
            &self.inner
        }

        /// Get a mutable reference to the inner body
        pub fn get_mut(&mut self) -> &mut B {
            &mut self.inner
        }

        /// Get a pinned mutable reference to the inner body
        pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut B> {
            self.project().inner
        }

        /// Consume `self`, returning the inner body
        pub fn into_inner(self) -> B {
            self.inner
        }
    }

    impl<B, F, E> Body for MapErr<B, F>
    where
        B: Body,
        F: FnMut(B::Error) -> E,
    {
        type Data = B::Data;
        type Error = E;

        fn poll_data(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
        ) -> Poll<Option<Result<Self::Data, Self::Error>>> {
            let this = self.project();
            match this.inner.poll_data(cx) {
                Poll::Pending => Poll::Pending,
                Poll::Ready(None) => Poll::Ready(None),
                Poll::Ready(Some(Ok(data))) => Poll::Ready(Some(Ok(data))),
                Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err((this.f)(err)))),
            }
        }

        fn poll_trailers(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
        ) -> Poll<Result<Option<http::HeaderMap>, Self::Error>> {
            let this = self.project();
            this.inner.poll_trailers(cx).map_err(this.f)
        }

        fn is_end_stream(&self) -> bool {
            self.inner.is_end_stream()
        }

        fn size_hint(&self) -> crate::SizeHint {
            self.inner.size_hint()
        }
    }