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
118
119

use super::{PRESENT_STATE_INDEX_CAPACITY, ScopeId, StateIndex};
use crate::global::const_dsl::ScopeKind;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(kani, derive(kani::Arbitrary))]
pub(crate) enum FrontierKind {
    Route,
    Reentry,
    Parallel,
    PassiveObserver,
}

impl FrontierKind {
    pub(crate) const ALL_BITS: u8 = (1 << 4) - 1;

    #[inline]
    pub(crate) const fn bit(self) -> u8 {
        match self {
            Self::Route => 1 << 0,
            Self::Reentry => 1 << 1,
            Self::Parallel => 1 << 2,
            Self::PassiveObserver => 1 << 3,
        }
    }
}

#[inline]
pub(crate) fn checked_state_index(idx: usize) -> Option<StateIndex> {
    if idx < PRESENT_STATE_INDEX_CAPACITY {
        Some(StateIndex::new(idx as u16))
    } else {
        None
    }
}

#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct OfferEntryKey {
    scope: ScopeId,
    entry: StateIndex,
}

impl OfferEntryKey {
    pub(crate) const EMPTY: Self = Self {
        scope: ScopeId::none(),
        entry: StateIndex::ABSENT,
    };

    #[inline]
    pub(crate) const fn new(scope: ScopeId, entry: StateIndex) -> Option<Self> {
        if !matches!(scope.kind(), Some(ScopeKind::Route)) || entry.is_absent() {
            None
        } else {
            Some(Self { scope, entry })
        }
    }

    #[inline]
    pub(crate) fn from_index(scope: ScopeId, entry_idx: usize) -> Option<Self> {
        Self::new(scope, checked_state_index(entry_idx)?)
    }

    #[inline]
    pub(crate) const fn is_absent(self) -> bool {
        self.scope.is_none() || self.entry.is_absent()
    }

    #[inline]
    pub(crate) const fn scope(self) -> ScopeId {
        self.scope
    }

    #[inline]
    pub(crate) const fn entry(self) -> StateIndex {
        self.entry
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct LaneOfferState {
    pub(crate) scope: ScopeId,
    pub(crate) entry: StateIndex,
    pub(crate) parallel_root: ScopeId,
    pub(crate) frontier: FrontierKind,
    pub(crate) flags: u8,
}

impl LaneOfferState {
    pub(crate) const FLAG_CONTROLLER: u8 = 1;
    pub(crate) const FLAG_DYNAMIC: u8 = 1 << 1;
    pub(crate) const FLAG_INTRINSIC_READY: u8 = 1 << 2;
    pub(crate) const EMPTY: Self = Self {
        scope: ScopeId::none(),
        entry: StateIndex::ABSENT,
        parallel_root: ScopeId::none(),
        frontier: FrontierKind::Route,
        flags: 0,
    };

    #[inline]
    pub(crate) const fn key(self) -> Option<OfferEntryKey> {
        OfferEntryKey::new(self.scope, self.entry)
    }

    #[inline]
    pub(crate) fn is_controller(self) -> bool {
        (self.flags & Self::FLAG_CONTROLLER) != 0
    }

    #[inline]
    pub(crate) fn is_dynamic(self) -> bool {
        (self.flags & Self::FLAG_DYNAMIC) != 0
    }

    #[inline]
    pub(crate) fn intrinsic_ready(self) -> bool {
        (self.flags & Self::FLAG_INTRINSIC_READY) != 0
    }
}