dope-session 0.2.3

Thin io_uring adaptor with "Manifolds"
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

use crate::pool::slot::WRITE_BUF_CAP;

pub trait WriteBufStorage: Default + 'static {
    fn as_slice(&self) -> &[u8];
    fn as_mut_slice(&mut self) -> &mut [u8];
}

impl WriteBufStorage for () {
    #[inline(always)]
    fn as_slice(&self) -> &[u8] {
        &[]
    }
    #[inline(always)]
    fn as_mut_slice(&mut self) -> &mut [u8] {
        &mut []
    }
}

#[repr(transparent)]
pub struct WriteBufArr(pub(crate) [u8; WRITE_BUF_CAP]);

impl Default for WriteBufArr {
    #[inline(always)]
    fn default() -> Self {
        Self([0u8; WRITE_BUF_CAP])
    }
}

impl WriteBufStorage for WriteBufArr {
    #[inline(always)]
    fn as_slice(&self) -> &[u8] {
        &self.0
    }
    #[inline(always)]
    fn as_mut_slice(&mut self) -> &mut [u8] {
        &mut self.0
    }
}

pub trait CodecLayer: 'static {
    type ConnState: Default + 'static;
    type Staging: WriteBufStorage;
    const IS_PASSTHROUGH: bool;

    fn is_active(state: &Self::ConnState) -> bool;
    fn process_inbound(state: &mut Self::ConnState, wire_in: &[u8]);
    fn process_outbound(state: &mut Self::ConnState, plaintext_in: &[u8]);
    fn take_plaintext(state: &mut Self::ConnState) -> Vec<u8>;
    fn install_plaintext(state: &mut Self::ConnState, plaintext: Vec<u8>);
    fn take_inflight(state: &mut Self::ConnState) -> Option<(*const u8, u32)>;
    fn consume_inflight(state: &mut Self::ConnState, n: usize) -> bool;
    fn has_inflight(state: &Self::ConnState) -> bool;
    fn wire_slice(state: &Self::ConnState) -> &[u8];
    fn close_pending(state: &Self::ConnState) -> bool;
}

pub struct Plain;

impl CodecLayer for Plain {
    type ConnState = ();
    type Staging = ();
    const IS_PASSTHROUGH: bool = true;

    #[inline(always)]
    fn is_active(_: &()) -> bool {
        true
    }
    #[inline(always)]
    fn process_inbound(_: &mut (), _: &[u8]) {}
    #[inline(always)]
    fn process_outbound(_: &mut (), _: &[u8]) {}
    #[inline(always)]
    fn take_plaintext(_: &mut ()) -> Vec<u8> {
        Vec::new()
    }
    #[inline(always)]
    fn install_plaintext(_: &mut (), _: Vec<u8>) {}
    #[inline(always)]
    fn take_inflight(_: &mut ()) -> Option<(*const u8, u32)> {
        None
    }
    #[inline(always)]
    fn consume_inflight(_: &mut (), _: usize) -> bool {
        false
    }
    #[inline(always)]
    fn has_inflight(_: &()) -> bool {
        false
    }
    #[inline(always)]
    fn wire_slice(_: &()) -> &[u8] {
        &[]
    }
    #[inline(always)]
    fn close_pending(_: &()) -> bool {
        false
    }
}