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

#[derive(Clone, Copy, Eq, PartialEq)]
#[repr(u8)]
pub(in super::super) enum ProgressEvidence {
    Absent,
    Present,
}

impl ProgressEvidence {
    #[inline]
    pub(in super::super) const fn is_absent(self) -> bool {
        matches!(self, Self::Absent)
    }
}

#[derive(Clone, Copy, Eq, PartialEq)]
pub(super) enum CandidateAuthority {
    Passive,
    Controller,
    DynamicController,
}

impl CandidateAuthority {
    pub(super) const fn from_observation(controller: bool, dynamic: bool) -> Self {
        if !controller {
            Self::Passive
        } else if dynamic {
            Self::DynamicController
        } else {
            Self::Controller
        }
    }

    pub(super) const fn merge(self, other: Self) -> Self {
        match (self, other) {
            (Self::DynamicController, Self::DynamicController)
            | (Self::DynamicController, Self::Controller)
            | (Self::DynamicController, Self::Passive)
            | (Self::Controller, Self::DynamicController)
            | (Self::Passive, Self::DynamicController) => Self::DynamicController,
            (Self::Controller, Self::Controller)
            | (Self::Controller, Self::Passive)
            | (Self::Passive, Self::Controller) => Self::Controller,
            (Self::Passive, Self::Passive) => Self::Passive,
        }
    }
}

#[derive(Clone, Copy)]
pub(in super::super) enum CurrentOfferEntry {
    RouteWithOfferLanes,
    RouteWithoutOfferLanes,
    NonRoute,
}

impl CurrentOfferEntry {
    #[inline]
    pub(in super::super) const fn is_route_entry(self) -> bool {
        matches!(
            self,
            Self::RouteWithOfferLanes | Self::RouteWithoutOfferLanes
        )
    }

    #[inline]
    pub(in super::super) const fn has_offer_lanes(self) -> bool {
        matches!(self, Self::RouteWithOfferLanes)
    }

    #[inline]
    pub(in super::super) const fn is_unrunnable_route(self) -> bool {
        matches!(self, Self::RouteWithoutOfferLanes)
    }
}

#[derive(Clone, Copy)]
pub(in super::super) enum CurrentOfferAuthority {
    Controller,
    Passive,
}

impl CurrentOfferAuthority {
    #[inline]
    pub(in super::super) const fn is_controller(self) -> bool {
        matches!(self, Self::Controller)
    }
}

#[derive(Clone, Copy)]
pub(in super::super) enum ProgressSiblingPresence {
    Absent,
    Present,
}

impl ProgressSiblingPresence {
    #[inline]
    pub(in super::super) const fn from_observed_progress_sibling(observed: bool) -> Self {
        if observed {
            Self::Present
        } else {
            Self::Absent
        }
    }

    #[inline]
    pub(in super::super) const fn exists(self) -> bool {
        matches!(self, Self::Present)
    }
}

#[derive(Clone, Copy)]
pub(in super::super) struct OfferAlignmentCandidateInput {
    pub(in super::super) current_idx: usize,
    pub(in super::super) current_entry: CurrentOfferEntry,
    pub(in super::super) current_authority: CurrentOfferAuthority,
    pub(in super::super) progress_sibling_presence: ProgressSiblingPresence,
    pub(in super::super) current_observation: super::current::CurrentOfferObservation,
}