sark-http 0.28.6

HTTP wire types, semantics, codecs, and ownership invariants 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

use o3::buffer::{Residency as _, hold, storage};

use crate::{
    owner::{
        evidence,
        handoff::{self, copy, stage},
    },
    payload::{fixed, owned, response::Body as _},
};

/// Response payload with no handler-borrow lifetime.
#[doc(hidden)]
pub enum Ready<'d> {
    Empty,
    Owned(Vec<u8>),
    Copied(copy::Body),
    Retained(storage::Shared),
    Segmented(owned::Segments<'d>),
    /// Retained segments projected from the live request owner.
    Linked(owned::Segments<'d>),
    Fixed(fixed::Body<'d>),
}

impl<'d> Ready<'d> {
    pub fn body_len(&self) -> usize {
        match self {
            Self::Empty => 0,
            Self::Owned(body) => body.len(),
            Self::Copied(body) => body.len(),
            Self::Retained(body) => body.len(),
            Self::Segmented(body) | Self::Linked(body) => body.len(),
            Self::Fixed(body) => body.len(),
        }
    }

    pub fn into_copy(self) -> (Self, Option<evidence::Copy>) {
        let copy = match &self {
            Self::Copied(body) => Some(body.copy()),
            _ => None,
        };
        (self, copy)
    }

    pub fn retention(&self) -> hold::Charge {
        match self {
            Self::Empty => hold::Charge::default(),
            Self::Owned(body) => hold::Charge::from_owner(body.len(), body.capacity()),
            Self::Copied(body) => hold::Charge::from_owner(body.body.len(), body.body.resident()),
            Self::Retained(body) => body.backing().map_or_else(hold::Charge::default, |owner| {
                hold::Charge::from_owner(body.len(), owner.resident())
            }),
            Self::Segmented(body) | Self::Linked(body) => body.charge(),
            Self::Fixed(body) => hold::Charge::from_owner(body.len(), 0),
        }
    }

    pub(in crate::owner::handoff) fn try_linked<'req, B: stage::Body<'req, 'd>>(
        &self,
        origin: handoff::Origin<'req, 'd, B>,
    ) -> Result<hold::Charge, hold::Overflow> {
        let charge = match self {
            Self::Empty => hold::Charge::default(),
            Self::Owned(body) => hold::Charge::from_owner(body.len(), 0),
            Self::Copied(body) => hold::Charge::from_owner(body.len(), 0),
            Self::Retained(body) => body.backing().map_or_else(hold::Charge::default, |owner| {
                if origin.source.is_linked(owner) {
                    hold::Charge::from_owner(owner.len(), owner.resident())
                } else {
                    hold::Charge::default()
                }
            }),
            Self::Segmented(body) => {
                let mut total = hold::Charge::default();
                for owner in body.backings() {
                    if origin.source.is_linked(owner) {
                        let charge = hold::Charge::from_owner(owner.len(), owner.resident());
                        total = total.try_add(charge)?;
                    }
                }
                total
            }
            Self::Linked(body) => body.charge(),
            Self::Fixed(body) => hold::Charge::from_owner(body.len(), 0),
        };
        Ok(charge)
    }
}

const _: () = {
    assert!(std::mem::size_of::<Ready<'static>>() <= 7 * std::mem::size_of::<usize>());
};