sark 0.9.0

Simple Asynchronous Rust webKit - Server
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
86
87

use std::ops::Range;

use super::PathProbe;
use super::request_impl::RouteRequestImpl;
use crate::request;

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct PathCapture {
    pub start: usize,
    pub end: usize,
}

impl PathCapture {
    pub const fn new(start: usize, end: usize) -> Self {
        Self { start, end }
    }

    pub const fn as_range(self) -> Range<usize> {
        self.start..self.end
    }
}

pub trait RawRouteParams: Default {
    type Captures;

    fn from_captures<P: PathProbe>(path: &P, captures: Self::Captures) -> Option<Self>;
}

impl RawRouteParams for () {
    type Captures = ();

    fn from_captures<P: PathProbe>(_path: &P, _captures: Self::Captures) -> Option<Self> {
        Some(())
    }
}

pub trait RouteParams<'req>: Sized {
    type Raw: Default;

    fn from_raw(req: &request::Ref<'req>, raw: Self::Raw) -> Option<Self>;
}

impl<'req> RouteParams<'req> for () {
    type Raw = ();

    fn from_raw(_req: &request::Ref<'req>, _raw: Self::Raw) -> Option<Self> {
        Some(())
    }
}

pub trait RouteSpec {
    type Kind;

    type Request: RouteRequestImpl<
            HeaderSlot = Self::HeaderSlot,
            RawHeaders = Self::RawHeaders,
            RawParams = Self::RawParams,
        > + for<'req> RouteRequestImpl<
            Params<'req> = Self::Params<'req>,
            Headers<'req> = Self::Headers<'req>,
        >;

    type Params<'req>: RouteParams<'req, Raw = Self::RawParams>;
    type RawParams: RawRouteParams<Captures = Self::Captures>;
    type Headers<'req>;
    type RawHeaders: Default;
    type HeaderSlot: Copy;
    type Response<'req>: sark_core::http::Shape<'req>;
    type AsyncResponse: sark_core::http::OwnedShape;
    type Stream: 'static;
    type ParsedBody<'req>;

    type Captures;

    const STATIC_RESPONSE: bool = false;
    const RESPONSE_BODY_KIND: sark_core::http::body_kind::ResponseKind =
        sark_core::http::body_kind::ResponseKind::Inline;
    const BODY_POLICY: super::BodyPolicy = <Self::Request as RouteRequestImpl>::BODY_POLICY;
    const MAX_BODY: usize = 1024 * 1024;

    const EMIT_DATE: bool = true;
    const EMIT_SERVER: bool = true;

    fn parse_body<'req>(raw: &'req [u8]) -> sark_core::error::Result<Self::ParsedBody<'req>>;

    fn from_captures<P: PathProbe>(path: &P, captures: Self::Captures) -> Option<Self::RawParams>;
}