sark-http 0.21.0

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

use std::{num::NonZero, ops::ControlFlow};

use o3::{
    buffer::{resident, storage},
    mem,
};

pub mod flatten;
pub mod iter;

mod error;
mod segment;
mod segments;

pub use error::Error;
use flatten::State;
pub use segment::Segment;
pub use segments::Segments;

/// Retained input or its single admitted, cooperatively copied output.
#[must_use = "step or release the retained body"]
pub struct Flatten<'d>(State<'d>);

impl<'d> Flatten<'d> {
    pub const fn new(source: Segments<'d>) -> Self {
        Self(State::Input(source))
    }

    pub fn try_push(
        self,
        segment: Segment<'d>,
    ) -> Result<Self, mem::Rejected<(Self, Segment<'d>), flatten::Error>> {
        match self.0 {
            State::Input(source) => match source.try_push(segment) {
                Ok(source) => Ok(Self::new(source)),
                Err(rejected) => {
                    let ((source, segment), error) = rejected.into_parts();
                    Err(mem::Rejected::new(
                        (Self::new(source), segment),
                        flatten::Error::Assembly(error),
                    ))
                }
            },
            state @ State::Copying(_) => Err(mem::Rejected::new(
                (Self(state), segment),
                flatten::Error::Finished,
            )),
        }
    }

    /// Empty and single-owner bodies complete without allocating or copying.
    /// Multi-owner bodies reserve once, then copy at most `budget` bytes per call.
    pub fn try_step(
        self,
        budget: NonZero<usize>,
    ) -> Result<ControlFlow<resident::Shared<'d>, Self>, mem::Rejected<Self, storage::AllocError>>
    {
        use o3::buffer::segments;

        let copy = match self.0 {
            State::Input(source) => match source.storage {
                segments::Shape::Empty => return Ok(ControlFlow::Break(resident::Shared::new())),
                segments::Shape::One(owner) => return Ok(ControlFlow::Break(owner.into_inner())),
                segments::Shape::Many(source) => match segments::Flatten::try_new(source) {
                    Ok(copy) => copy,
                    Err(rejected) => {
                        let (source, error) = rejected.into_parts();
                        return Err(mem::Rejected::new(
                            Self::new(Segments::from(segments::Shape::Many(source))),
                            error,
                        ));
                    }
                },
            },
            State::Copying(copy) => copy,
        };
        Ok(match copy.step(budget) {
            ControlFlow::Break(output) => ControlFlow::Break(resident::Shared::from(output)),
            ControlFlow::Continue(copy) => ControlFlow::Continue(Self(State::Copying(copy))),
        })
    }
}