#
actix_service/
ext.rs

    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
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124

    use crate::{
        and_then::{AndThenService, AndThenServiceFactory},
        map::Map,
        map_err::MapErr,
        transform_err::TransformMapInitErr,
        IntoService, IntoServiceFactory, Service, ServiceFactory, Transform,
    };

    /// An extension trait for [`Service`]s that provides a variety of convenient adapters.
    pub trait ServiceExt<Req>: Service<Req> {
        /// Map this service's output to a different type, returning a new service
        /// of the resulting type.
        ///
        /// This function is similar to the `Option::map` or `Iterator::map` where
        /// it will change the type of the underlying service.
        ///
        /// Note that this function consumes the receiving service and returns a
        /// wrapped version of it, similar to the existing `map` methods in the
        /// standard library.
        fn map<F, R>(self, f: F) -> Map<Self, F, Req, R>
        where
            Self: Sized,
            F: FnMut(Self::Response) -> R,
        {
            Map::new(self, f)
        }

        /// Map this service's error to a different error, returning a new service.
        ///
        /// This function is similar to the `Result::map_err` where it will change
        /// the error type of the underlying service. For example, this can be useful to
        /// ensure that services have the same error type.
        ///
        /// Note that this function consumes the receiving service and returns a
        /// wrapped version of it.
        fn map_err<F, E>(self, f: F) -> MapErr<Self, Req, F, E>
        where
            Self: Sized,
            F: Fn(Self::Error) -> E,
        {
            MapErr::new(self, f)
        }

        /// Call another service after call to this one has resolved successfully.
        ///
        /// This function can be used to chain two services together and ensure that the second service
        /// isn't called until call to the first service have finished. Result of the call to the first
        /// service is used as an input parameter for the second service's call.
        ///
        /// Note that this function consumes the receiving service and returns a wrapped version of it.
        fn and_then<I, S1>(self, service: I) -> AndThenService<Self, S1, Req>
        where
            Self: Sized,
            I: IntoService<S1, Self::Response>,
            S1: Service<Self::Response, Error = Self::Error>,
        {
            AndThenService::new(self, service.into_service())
        }
    }

    impl<S, Req> ServiceExt<Req> for S where S: Service<Req> {}

    /// An extension trait for [`ServiceFactory`]s that provides a variety of convenient adapters.
    pub trait ServiceFactoryExt<Req>: ServiceFactory<Req> {
        /// Map this service's output to a different type, returning a new service
        /// of the resulting type.
        fn map<F, R>(self, f: F) -> crate::map::MapServiceFactory<Self, F, Req, R>
        where
            Self: Sized,
            F: FnMut(Self::Response) -> R + Clone,
        {
            crate::map::MapServiceFactory::new(self, f)
        }

        /// Map this service's error to a different error, returning a new service.
        fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, Req, F, E>
        where
            Self: Sized,
            F: Fn(Self::Error) -> E + Clone,
        {
            crate::map_err::MapErrServiceFactory::new(self, f)
        }

        /// Map this factory's init error to a different error, returning a new service.
        fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, F, Req, E>
        where
            Self: Sized,
            F: Fn(Self::InitError) -> E + Clone,
        {
            crate::map_init_err::MapInitErr::new(self, f)
        }

        /// Call another service after call to this one has resolved successfully.
        fn and_then<I, SF1>(self, factory: I) -> AndThenServiceFactory<Self, SF1, Req>
        where
            Self: Sized,
            Self::Config: Clone,
            I: IntoServiceFactory<SF1, Self::Response>,
            SF1: ServiceFactory<
                Self::Response,
                Config = Self::Config,
                Error = Self::Error,
                InitError = Self::InitError,
            >,
        {
            AndThenServiceFactory::new(self, factory.into_factory())
        }
    }

    impl<SF, Req> ServiceFactoryExt<Req> for SF where SF: ServiceFactory<Req> {}

    /// An extension trait for [`Transform`]s that provides a variety of convenient adapters.
    pub trait TransformExt<S, Req>: Transform<S, Req> {
        /// Return a new `Transform` whose init error is mapped to to a different type.
        fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, Req, F, E>
        where
            Self: Sized,
            F: Fn(Self::InitError) -> E + Clone,
        {
            TransformMapInitErr::new(self, f)
        }
    }

    impl<T, Req> TransformExt<T, Req> for T where T: Transform<T, Req> {}