hashira 0.0.2-alpha

A server side rendering framework build on top of Yew
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use std::{
    convert::Infallible,
    future::{ready, Ready},
};

use crate::{app::RequestContext, error::BoxError, routing::Params};
use futures::Future;
use http::{HeaderMap, Method, Uri, Version};

use super::Body;

/// Provides a way for creating a type from a request.
pub trait FromRequest: Sized {
    /// The returned error on failure.
    type Error: Into<BoxError>;

    /// The future that resolves to the type.
    type Fut: Future<Output = Result<Self, Self::Error>>;

    /// Returns a future that resolves to the type or error.
    fn from_request(ctx: &RequestContext, body: &mut Body) -> Self::Fut;
}

impl FromRequest for RequestContext {
    type Error = Infallible;
    type Fut = Ready<Result<RequestContext, Infallible>>;

    fn from_request(ctx: &RequestContext, _body: &mut Body) -> Self::Fut {
        ready(Ok(ctx.clone()))
    }
}

impl FromRequest for () {
    type Error = Infallible;
    type Fut = Ready<Result<(), Self::Error>>;

    fn from_request(_ctx: &RequestContext, _body: &mut Body) -> Self::Fut {
        ready(Ok(()))
    }
}

impl FromRequest for Method {
    type Error = Infallible;
    type Fut = Ready<Result<Method, Infallible>>;

    fn from_request(ctx: &RequestContext, _body: &mut Body) -> Self::Fut {
        ready(Ok(ctx.request().method().clone()))
    }
}

impl FromRequest for HeaderMap {
    type Error = Infallible;
    type Fut = Ready<Result<HeaderMap, Infallible>>;

    fn from_request(ctx: &RequestContext, _body: &mut Body) -> Self::Fut {
        ready(Ok(ctx.request().headers().clone()))
    }
}

impl FromRequest for Version {
    type Error = Infallible;
    type Fut = Ready<Result<Version, Infallible>>;

    fn from_request(ctx: &RequestContext, _body: &mut Body) -> Self::Fut {
        ready(Ok(ctx.request().version()))
    }
}

impl FromRequest for Uri {
    type Error = Infallible;
    type Fut = Ready<Result<Uri, Infallible>>;

    fn from_request(ctx: &RequestContext, _body: &mut Body) -> Self::Fut {
        ready(Ok(ctx.request().uri().clone()))
    }
}

impl FromRequest for Params {
    type Error = Infallible;
    type Fut = Ready<Result<Params, Infallible>>;

    fn from_request(ctx: &RequestContext, _body: &mut Body) -> Self::Fut {
        ready(Ok(ctx.params().clone()))
    }
}