hyper 1.8.1

A protective and efficient HTTP library for all.
Documentation 
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

use std::error::Error as StdError;
use std::future::Future;

use crate::body::Body;
use crate::service::service::Service;
use crate::{Request, Response};

/// An asynchronous function from [`Request`] to [`Response`].
///
/// This is a *sealed* trait, meaning that it can not be implemented directly. Rather, it is an
/// alias for [`Service`]s that accept a [`Request`] and return a [`Future`] that resolves to a
/// [`Response`]. External callers should implement [`Service`] instead.
///
/// Rather than being generic over the request and response, this trait is generic across the
/// request [`Body`] and response [`Body`].
///
/// See the crate-level [`service`][crate::service] documentation for more information.
///
/// See [`Service`] for more information.
pub trait HttpService<ReqBody>: sealed::Sealed<ReqBody> {
    /// The [`Body`] body of the [`Response`].
    type ResBody: Body;

    /// The error type that can occur within this [`Service`].
    ///
    /// Note: Returning an `Error` to a hyper server, the behavior depends on the protocol. In
    /// most cases, hyper will cause the connection to be abruptly aborted. In most cases, it is
    /// better to return a `Response` with a 4xx or 5xx status code.
    ///
    /// See [`Service::Error`] for more information.
    type Error: Into<Box<dyn StdError + Send + Sync>>;

    /// The [`Future`] returned by this [`Service`].
    type Future: Future<Output = Result<Response<Self::ResBody>, Self::Error>>;

    #[doc(hidden)]
    fn call(&mut self, req: Request<ReqBody>) -> Self::Future;
}

impl<T, B1, B2> HttpService<B1> for T
where
    T: Service<Request<B1>, Response = Response<B2>>,
    B2: Body,
    T::Error: Into<Box<dyn StdError + Send + Sync>>,
{
    type ResBody = B2;

    type Error = T::Error;
    type Future = T::Future;

    fn call(&mut self, req: Request<B1>) -> Self::Future {
        Service::call(self, req)
    }
}

impl<T, B1, B2> sealed::Sealed<B1> for T
where
    T: Service<Request<B1>, Response = Response<B2>>,
    B2: Body,
{
}

mod sealed {
    pub trait Sealed<T> {}
}