sark-http 0.29.0

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

use std::ptr;

use o3::depot::map::compact::Insert as _;

use crate::{
    field::metadata::{block, map::record::Span},
    payload::compress::dynamic::{
        Field, Whole, hash,
        table::delta::{
            Admission,
            buffer::{Storage, insert::Insert, record},
        },
        table::state::Size,
    },
};

pub(in crate::payload::compress::dynamic::table::delta) struct Append<'a> {
    pub(super) storage: &'a mut Storage,
}

pub(in crate::payload::compress::dynamic::table::delta) struct Ready<'a, 'field> {
    pub(super) storage: &'a mut Storage,
    pub(super) plan: record::Plan<'field>,
}

impl<'a> Append<'a> {
    pub(in crate::payload::compress::dynamic::table::delta) fn try_prepare<'field>(
        self,
        probe: hash::Probe<'field>,
        size: Size,
        proof: block::Name,
    ) -> Result<Ready<'a, 'field>, Admission> {
        let head = self.storage.header();
        let field = probe.field();
        let field = Field {
            name: Span::from_slice(field.name),
            value: Span::from_slice(field.value),
            proof,
            validation: Whole::from_value(
                proof,
                block::Value::from_span(Span::from_slice(field.value)),
            ),
        };
        let plan = record::Plan::new(
            field,
            probe.digest(),
            size,
            head.used,
            head.len,
            head.bytes,
            head.entries,
        )?;
        Ok(Ready {
            storage: self.storage,
            plan,
        })
    }
}

impl Ready<'_, '_> {
    pub(in crate::payload::compress::dynamic::table::delta) fn commit(self) {
        let Self { storage, plan } = self;
        let record = plan.record();
        let field = plan.field();
        let (head, bytes) = storage.block.parts_mut();
        let pointer = bytes.as_mut_ptr().cast::<u8>();
        // SAFETY: the retained plan admitted this record and all its data in
        // the disjoint tail planes. Header alignment also aligns the record
        // plane at the tail's start; publication follows both index inserts.
        unsafe {
            pointer
                .cast::<record::Record>()
                .add(plan.ordinal())
                .write(record);
            let mut out = pointer.add(head.plan.data + record.start());
            for span in [field.name, field.value] {
                let (first, second) = span.parts();
                ptr::copy(first.as_ptr(), out, first.len());
                out = out.add(first.len());
                ptr::copy(second.as_ptr(), out, second.len());
                out = out.add(second.len());
            }
        }
        let exact = Insert::<0> {
            ready: Ready { storage, plan },
        }
        .insert();
        exact.insert();
    }
}