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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

use std::rc::Rc;
use std::sync::Arc;

use futures::{Async, Future, IntoFuture, Poll};

use crate::transform_map_init_err::TransformMapInitErr;
use crate::{NewService, Service};

/// `Transform` service factory.
///
/// Transform factory creates service that wraps other services.
/// `Config` is a service factory configuration type.
pub trait Transform<S> {
    /// Requests handled by the service.
    type Request;

    /// Responses given by the service.
    type Response;

    /// Errors produced by the service.
    type Error;

    /// The `TransformService` value created by this factory
    type Transform: Service<
        Request = Self::Request,
        Response = Self::Response,
        Error = Self::Error,
    >;

    /// Errors produced while building a service.
    type InitError;

    /// The future response value.
    type Future: Future<Item = Self::Transform, Error = Self::InitError>;

    /// Create and return a new service value asynchronously.
    fn new_transform(&self, service: S) -> Self::Future;

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

impl<T, S> Transform<S> for Rc<T>
where
    T: Transform<S>,
{
    type Request = T::Request;
    type Response = T::Response;
    type Error = T::Error;
    type InitError = T::InitError;
    type Transform = T::Transform;
    type Future = T::Future;

    fn new_transform(&self, service: S) -> T::Future {
        self.as_ref().new_transform(service)
    }
}

impl<T, S> Transform<S> for Arc<T>
where
    T: Transform<S>,
{
    type Request = T::Request;
    type Response = T::Response;
    type Error = T::Error;
    type InitError = T::InitError;
    type Transform = T::Transform;
    type Future = T::Future;

    fn new_transform(&self, service: S) -> T::Future {
        self.as_ref().new_transform(service)
    }
}

/// Trait for types that can be converted to a *transform service*
pub trait IntoTransform<T, S>
where
    T: Transform<S>,
{
    /// Convert to a `TransformService`
    fn into_transform(self) -> T;
}

impl<T, S> IntoTransform<T, S> for T
where
    T: Transform<S>,
{
    fn into_transform(self) -> T {
        self
    }
}

/// `Apply` transform new service
#[derive(Clone)]
pub struct ApplyTransform<T, A, C> {
    a: A,
    t: Rc<T>,
    _t: std::marker::PhantomData<C>,
}

impl<T, A, C> ApplyTransform<T, A, C>
where
    A: NewService<C>,
    T: Transform<A::Service, Error = A::Error, InitError = A::InitError>,
{
    /// Create new `ApplyNewService` new service instance
    pub fn new<F: IntoTransform<T, A::Service>>(t: F, a: A) -> Self {
        Self {
            a,
            t: Rc::new(t.into_transform()),
            _t: std::marker::PhantomData,
        }
    }
}

impl<T, A, C> NewService<C> for ApplyTransform<T, A, C>
where
    A: NewService<C>,
    T: Transform<A::Service, Error = A::Error, InitError = A::InitError>,
{
    type Request = T::Request;
    type Response = T::Response;
    type Error = T::Error;

    type Service = T::Transform;
    type InitError = T::InitError;
    type Future = ApplyTransformFuture<T, A, C>;

    fn new_service(&self, cfg: &C) -> Self::Future {
        ApplyTransformFuture {
            t_cell: self.t.clone(),
            fut_a: self.a.new_service(cfg).into_future(),
            fut_t: None,
        }
    }
}

pub struct ApplyTransformFuture<T, A, C>
where
    A: NewService<C>,
    T: Transform<A::Service, Error = A::Error, InitError = A::InitError>,
{
    fut_a: A::Future,
    fut_t: Option<<T::Future as IntoFuture>::Future>,
    t_cell: Rc<T>,
}

impl<T, A, C> Future for ApplyTransformFuture<T, A, C>
where
    A: NewService<C>,
    T: Transform<A::Service, Error = A::Error, InitError = A::InitError>,
{
    type Item = T::Transform;
    type Error = T::InitError;

    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        if self.fut_t.is_none() {
            if let Async::Ready(service) = self.fut_a.poll()? {
                self.fut_t = Some(self.t_cell.new_transform(service).into_future());
            }
        }
        if let Some(ref mut fut) = self.fut_t {
            fut.poll()
        } else {
            Ok(Async::NotReady)
        }
    }
}