hibana 0.9.6

Choreography-derived runtime enforcement kernel for no_std Rust multiparty protocols
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

use super::OfferCursorReadiness;

#[derive(Clone, Copy)]
pub(in crate::endpoint::kernel::offer) enum OfferArmRecvEvidence {
    HasRecv,
    Recvless,
}

#[derive(Clone, Copy)]
pub(in crate::endpoint::kernel::offer) enum OfferControllerCursorArm {
    AtArm,
    OutsideArm,
}

impl OfferControllerCursorArm {
    #[inline]
    const fn is_outside_arm(self) -> bool {
        matches!(self, Self::OutsideArm)
    }
}

#[derive(Clone, Copy)]
pub(in crate::endpoint::kernel::offer) enum OfferMaterializationReadiness {
    Ready,
    Pending,
}

impl OfferMaterializationReadiness {
    #[inline]
    const fn is_pending(self) -> bool {
        matches!(self, Self::Pending)
    }
}

#[derive(Clone, Copy)]
pub(in crate::endpoint::kernel::offer) struct OfferControllerLocalEvidence {
    cursor: OfferCursorReadiness,
    cursor_arm: OfferControllerCursorArm,
    materialization: OfferMaterializationReadiness,
}

impl OfferControllerLocalEvidence {
    #[inline]
    pub(in crate::endpoint::kernel::offer) const fn new(
        cursor: OfferCursorReadiness,
        cursor_arm: OfferControllerCursorArm,
        materialization: OfferMaterializationReadiness,
    ) -> Self {
        Self {
            cursor,
            cursor_arm,
            materialization,
        }
    }

    #[inline]
    pub(in crate::endpoint::kernel::offer) const fn materialization_pending(self) -> bool {
        self.materialization.is_pending()
    }

    #[inline]
    pub(in crate::endpoint::kernel::offer) const fn non_entry_cursor_ready(self) -> bool {
        matches!(self.cursor, OfferCursorReadiness::NonRecv) && self.cursor_arm.is_outside_arm()
    }
}

#[derive(Clone, Copy)]
pub(in crate::endpoint::kernel::offer) enum OfferPassiveReadySignal {
    Observed,
    Absent,
}

impl OfferPassiveReadySignal {
    #[inline]
    const fn is_observed(self) -> bool {
        matches!(self, Self::Observed)
    }
}

#[derive(Clone, Copy)]
pub(in crate::endpoint::kernel::offer) enum OfferPassiveRecvEvidence {
    HasRecv,
    Recvless,
}

impl OfferPassiveRecvEvidence {
    #[inline]
    const fn is_recvless(self) -> bool {
        matches!(self, Self::Recvless)
    }
}

#[derive(Clone, Copy)]
pub(in crate::endpoint::kernel::offer) struct OfferPassiveEvidence {
    ready_signal: OfferPassiveReadySignal,
    recv: OfferPassiveRecvEvidence,
}

impl OfferPassiveEvidence {
    #[inline]
    pub(in crate::endpoint::kernel::offer) const fn new(
        ready_signal: OfferPassiveReadySignal,
        recv: OfferPassiveRecvEvidence,
    ) -> Self {
        Self { ready_signal, recv }
    }

    #[inline]
    pub(in crate::endpoint::kernel::offer) const fn has_ready_signal(self) -> bool {
        self.ready_signal.is_observed()
    }

    #[inline]
    pub(in crate::endpoint::kernel::offer) const fn dynamic_scope_without_recv(self) -> bool {
        self.recv.is_recvless()
    }
}