sark-core 0.21.0

Fiber-free request, route, dispatch, and lifecycle core for Sark
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
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

//! Trusted request projection bindings.

use std::{mem, ops};

use o3::{buffer, buffer::resident, mem::rc};
use request::{Projection, field, frame::proof, path};
use sark_http::request::{Bytes, span};

use crate::{request, route};

pub struct Path<'a, R> {
    req: &'a R,
    cap: route::raw::PathCapture,
}

impl<'a, R> Path<'a, R> {
    /// Binds a generated capture to its exact request.
    ///
    /// # Safety
    /// `cap` must have been matched from `req`.
    pub const unsafe fn new(req: &'a R, cap: route::raw::PathCapture) -> Self {
        Self { req, cap }
    }
}

impl<'req, R: route::Schema>
    Path<'_, request::raw::Parsed<request::Head<&'req [u8], R::Frame>, R>>
{
    pub fn get(self) -> &'req [u8] {
        let path = self.req.owner().path();
        let range = self.cap.start()..self.cap.end();
        unsafe { path.get_unchecked(range) }
    }

    pub fn try_parse<T: field::Path>(self) -> Result<T, field::Error> {
        let start = self.cap.start();
        T::parse(path::Capture::new(self.get(), start))
    }
}

impl<'d, R: route::Schema> Path<'_, request::raw::Parsed<request::Parts<'d, R::Frame>, R>> {
    /// Retains a capture within this route, whose end fits the immutable owner.
    pub fn try_get(self) -> Result<Bytes<'d>, rc::Error> {
        let range = self.cap.start()..self.cap.end();
        Ok(match self.req.owner().head.route() {
            Projection::Frame(path) => {
                let start = path.start + range.start;
                let end = path.start + range.end;
                let owner = self.req.owner().head.owner();
                let frame = unsafe { buffer::raw::Segment::try_project(owner, start..end) }?;
                Bytes::from_shared(self.req.owner().id, frame)
            }
            Projection::Root => self.static_path(b"/", range),
            Projection::Star => self.static_path(b"*", range),
        })
    }

    pub fn try_parse<T: field::Path>(self) -> Result<T, field::Error> {
        let path = self.req.owner().head.borrow().path();
        let range = self.cap.start()..self.cap.end();
        // SAFETY: this capture was matched from this exact retained request.
        let value = unsafe { path.get_unchecked(range) };
        T::parse(path::Capture::new(value, self.cap.start()))
    }

    fn static_path(self, path: &'d [u8], range: ops::Range<usize>) -> Bytes<'d> {
        let frame = unsafe { path.get_unchecked(range) };
        Bytes::new(self.req.owner().id, resident::Shared::from(frame))
    }
}

pub struct Bound<'a, R> {
    req: &'a R,
    span: span::Span,
}

impl<'a, R> Bound<'a, R> {
    /// Binds a parsed frame to its exact request head.
    ///
    /// # Safety
    /// `span` must have been parsed from `req`.
    pub const unsafe fn new(req: &'a R, span: span::Span) -> Self {
        Self { req, span }
    }
}

impl<'req, R: route::Schema>
    Bound<'_, request::raw::Parsed<request::Head<&'req [u8], R::Frame>, R>>
{
    pub fn get(self) -> &'req [u8] {
        let range = self.span.start()..self.span.end();
        let owner = *self.req.owner().owner();
        unsafe { owner.get_unchecked(range) }
    }
}

impl<'a, 'req, R: route::Schema<Frame = proof::Peer>>
    Bound<'a, request::raw::Parsed<request::Head<&'req [u8], proof::Peer>, R>>
{
    pub fn required(
        req: &'a request::raw::Parsed<request::Head<&'req [u8], proof::Peer>, R>,
    ) -> Self {
        Self {
            req,
            span: req.owner().peer(),
        }
    }
}

impl<'d, R: route::Schema> Bound<'_, request::raw::Parsed<request::Parts<'d, R::Frame>, R>> {
    pub fn try_get(self) -> Result<Bytes<'d>, rc::Error> {
        let range = self.span.start()..self.span.end();
        let owner = self.req.owner().head.owner();
        let frame = unsafe { buffer::raw::Segment::try_project(owner, range) }?;
        Ok(Bytes::from_shared(self.req.owner().id, frame))
    }
}

impl<'a, 'd, R: route::Schema<Frame = proof::Peer>>
    Bound<'a, request::raw::Parsed<request::Parts<'d, proof::Peer>, R>>
{
    pub fn required(req: &'a request::raw::Parsed<request::Parts<'d, proof::Peer>, R>) -> Self {
        Self {
            req,
            span: req.owner().head.peer(),
        }
    }
}

const _: () = {
    assert!(mem::size_of::<Path<'_, ()>>() == 3 * mem::size_of::<usize>());
    assert!(mem::size_of::<Bound<'_, ()>>() == 2 * mem::size_of::<usize>());
};