dope-net 0.11.0

The manifold runtime
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

pub mod buffered;
pub mod identity;
pub mod send;

use std::io;

use crate::RetainBytes;

use self::send::{Plain, Prepared, SendStorage, Storage, Vectored};

pub enum Reclaim {
    OnSubmit,
    OnComplete,
}

#[derive(Clone, Copy)]
pub struct RuntimeLimits {
    max_connections: usize,
    max_retained_recv_chunks: usize,
    max_recv_len: usize,
}

impl RuntimeLimits {
    pub fn new(
        max_connections: usize,
        max_retained_recv_chunks: usize,
        max_recv_len: usize,
    ) -> Self {
        Self {
            max_connections,
            max_retained_recv_chunks,
            max_recv_len,
        }
    }

    pub fn max_connections(self) -> usize {
        self.max_connections
    }

    pub fn max_retained_recv_chunks(self) -> usize {
        self.max_retained_recv_chunks
    }

    pub fn max_recv_len(self) -> usize {
        self.max_recv_len
    }
}

pub trait Wire: 'static + Sized {
    type InitConfig: 'static;
    type RuntimeContext: 'static;
    type Open<'a>: OpenReservation<Self>
    where
        Self: 'a;
    type Recv<'a>: RetainBytes + 'a;
    type SendStorage: SendStorage;

    const RECLAIM: Reclaim;

    const RAW_RECV: bool = false;

    fn runtime_context(
        limits: RuntimeLimits,
        config: Self::InitConfig,
    ) -> io::Result<Self::RuntimeContext>;

    fn prepare_open(runtime: &mut Self::RuntimeContext) -> Option<Self::Open<'_>>;

    fn holds_plain(&self, _send: &Self::SendStorage) -> bool {
        false
    }

    fn process_recv<'a>(
        &mut self,
        runtime: &mut Self::RuntimeContext,
        bytes: &'a [u8],
    ) -> Option<Self::Recv<'a>>;

    fn recv_eof(&mut self) {}

    fn prepare_send<'a>(
        &'a mut self,
        send: Storage<'a, Self::SendStorage>,
        plain: Plain<'a>,
    ) -> Prepared<'a>;

    fn prepare_send_vectored<'a>(
        &'a mut self,
        send: Storage<'a, Self::SendStorage>,
        plain: Vectored<'a>,
    ) -> Prepared<'a>;

    fn submit_failed(&mut self) {}

    fn after_send<'a>(&'a mut self, send: Storage<'a, Self::SendStorage>, n: usize)
    -> Prepared<'a>;

    fn flush_pending<'a>(&'a mut self, send: Storage<'a, Self::SendStorage>) -> Prepared<'a>;

    fn graceful_close<'a>(&'a mut self, send: Storage<'a, Self::SendStorage>) -> Prepared<'a> {
        send.empty(0)
    }
}

pub trait OpenReservation<W: Wire> {
    fn commit(self) -> (W, W::SendStorage);
}

pub struct ReadyOpen<W: Wire>(Option<(W, W::SendStorage)>);

impl<W: Wire> ReadyOpen<W> {
    pub fn new(wire: W, send: W::SendStorage) -> Self {
        Self(Some((wire, send)))
    }
}

impl<W: Wire> OpenReservation<W> for ReadyOpen<W> {
    fn commit(mut self) -> (W, W::SendStorage) {
        self.0.take().unwrap()
    }
}