dope-net 0.43.0

Owned network transports for dope
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

use o3::base::cell::region;

use crate::link::egress::{
    self,
    load::credit,
    metadata::{self, pool::store::index::Index},
    reserve::{
        demand,
        guard::{Guard, Rollback},
    },
};

pub(in crate::link::egress::metadata::front) struct Vacant<
    'queue,
    'token,
    'p,
    'd,
    T,
    M,
    D: demand::Mode,
> where
    M: credit::Access<'p, 'd>,
{
    parts: Guard<'token, 'd, Parts<'queue, 'p, 'd, T, M, D>>,
}

pub(super) struct Parts<'queue, 'p, 'd, T, M: credit::Access<'p, 'd>, D: demand::Mode> {
    pub(super) queue: metadata::Queue<'queue, 'p, 'd, T, M, D>,
    pub(super) slot: Index<'d>,
    pub(super) stored: credit::Stored<'p>,
}

impl<'queue, 'token, 'p, 'd, T, M: credit::Access<'p, 'd>, D: demand::Mode>
    Vacant<'queue, 'token, 'p, 'd, T, M, D>
{
    pub(in crate::link::egress::metadata::front) fn new(
        queue: metadata::Queue<'queue, 'p, 'd, T, M, D>,
        slot: Index<'d>,
        token: &'token mut region::Token<region::Identity<'d>>,
        stored: credit::Stored<'p>,
    ) -> Self {
        Self {
            parts: Guard::new(
                token,
                Parts {
                    queue,
                    slot,
                    stored,
                },
            ),
        }
    }

    pub(in crate::link::egress::metadata::front) fn region_token(
        &mut self,
    ) -> &mut region::Token<region::Identity<'d>> {
        self.parts.parts_mut().0
    }

    pub(in crate::link::egress::metadata::front) fn restore(self, value: egress::NonEmpty<T>) {
        let (
            token,
            Parts {
                queue,
                slot,
                stored,
            },
        ) = self.parts.into_parts();
        queue.state().restore(slot, stored, |next, entry| {
            queue.pool.store.restore(token, slot, value, next, entry);
        });
    }
}

impl<'p, 'd, T, M: credit::Access<'p, 'd>, D: demand::Mode> Rollback<'d>
    for Parts<'_, 'p, 'd, T, M, D>
{
    fn rollback(self, token: &mut region::Token<region::Identity<'d>>) {
        let Parts {
            queue,
            slot,
            stored,
        } = self;
        queue.pool.store.recycle(token, slot);
        credit::Lane::new(queue).release(token, stored.into_grant());
    }
}