hibana 0.8.0

Const-projected Affine Multiparty Session Types for choreography-first Rust 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
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use super::{
    Clock, CursorEndpoint, EndpointSlot, EpochTable, FrontierObservationDomain, LabelUniverse,
    MintConfigMarker, RecvError, RecvResult, Transport,
};

mod candidates;
mod model;
use self::model::{CurrentOfferAuthority, CurrentOfferEntry, OfferAlignmentCandidateInput};

impl<'r, const ROLE: u8, T, U, C, E, const MAX_RV: usize, Mint, B>
    CursorEndpoint<'r, ROLE, T, U, C, E, MAX_RV, Mint, B>
where
    T: Transport + 'r,
    U: LabelUniverse,
    C: Clock,
    E: EpochTable,
    Mint: MintConfigMarker,
    B: EndpointSlot + 'r,
{
    pub(in crate::endpoint::kernel) fn align_cursor_to_selected_scope(&mut self) -> RecvResult<()> {
        let node_scope = self.cursor.node_scope_id();
        let current_scope = self.current_offer_scope_id();
        if current_scope != node_scope
            && let Some(entry_idx) = self.route_scope_offer_entry_index(current_scope)
            && entry_idx != self.cursor.index()
        {
            self.set_cursor_index(entry_idx);
            self.sync_lane_offer_state();
            return self.align_cursor_to_selected_scope();
        }
        let node_scope = self.current_offer_scope_id();
        let current_idx = self.cursor.index();
        let mut current_frontier_state =
            self.current_frontier_selection_state(node_scope, current_idx);
        let current_frontier = current_frontier_state.frontier;
        let current_parallel = current_frontier_state.parallel();
        let current_scope_selected = self.selected_arm_for_scope(node_scope).is_some();
        if current_scope_selected
            && self
                .current_scope_selection_meta(node_scope, current_idx, current_frontier_state)
                .map(|meta| meta.is_route_entry())
                .unwrap_or(false)
        {
            return Ok(());
        }
        let observation_domain = FrontierObservationDomain::from_parallel(current_parallel);
        let active_entries = self.active_frontier_entries(current_parallel);
        if active_entries.contains_only(current_idx) {
            let Some(current_scope_meta) =
                self.current_scope_selection_meta(node_scope, current_idx, current_frontier_state)
            else {
                return Ok(());
            };
            if current_scope_meta.is_route_entry() && current_scope_meta.has_offer_lanes() {
                return Ok(());
            }
        }
        let observation_key = Self::frontier_observation_key(self, observation_domain);
        let mut observed_entries = self.frontier_observed_entries(observation_domain);
        let cached_entries =
            self.cached_frontier_observed_entries(observation_domain, observation_key);
        if cached_entries.is_none() && observed_entries.len() != 0 {
            Self::refresh_frontier_observation_cache(self, observation_domain);
            observed_entries = self.frontier_observed_entries(observation_domain);
        }
        let reentry_ready_entry_idx =
            self.observed_reentry_entry_idx(observed_entries, current_idx, true);
        let loop_controller_without_evidence =
            current_frontier_state.loop_controller_without_evidence();
        let progress_sibling_exists = if !observation_domain.uses_root_entries() {
            self.global_frontier_progress_sibling_exists(
                current_idx,
                current_frontier,
                loop_controller_without_evidence,
            )
        } else {
            self.root_frontier_progress_sibling_exists(
                observation_domain.root_scope(),
                current_idx,
                current_frontier,
                loop_controller_without_evidence,
            )
        };
        let Some(current_scope_meta) =
            self.current_scope_selection_meta(node_scope, current_idx, current_frontier_state)
        else {
            return Ok(());
        };
        let current_entry = CurrentOfferEntry::from_meta(
            current_scope_meta.is_route_entry(),
            current_scope_meta.has_offer_lanes(),
        );
        let current_authority =
            CurrentOfferAuthority::from_meta(current_scope_meta.is_controller());
        let candidates = self.offer_alignment_candidates(
            observed_entries,
            OfferAlignmentCandidateInput {
                current_idx,
                current_entry,
                current_authority,
                progress_sibling_exists,
            },
        );
        current_frontier_state = candidates.merge_current_observation(current_frontier_state);
        let selection = candidates.select(current_frontier_state);
        let current_entry = candidates.current_entry();
        if let Some((_priority, entry_idx)) = selection {
            if entry_idx != self.cursor.index() {
                self.set_cursor_index(entry_idx);
                self.sync_lane_offer_state();
                return self.align_cursor_to_selected_scope();
            }
            return Ok(());
        }
        if self.current_route_arm_authorized()?.is_some() {
            return Ok(());
        }
        if candidates.current_can_remain_after_alignment(current_frontier_state) {
            return Ok(());
        }
        if !current_entry.is_route_entry() {
            if let Some(entry_idx) = reentry_ready_entry_idx {
                if entry_idx != self.cursor.index() {
                    self.set_cursor_index(entry_idx);
                    self.sync_lane_offer_state();
                    return self.align_cursor_to_selected_scope();
                }
                return Ok(());
            }
        }
        Err(RecvError::PhaseInvariant)
    }
}