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

use super::super::{ReservedDestinationTopologyCommitProof, ReservedSourceTopologyCommitProof};
use super::{
    Clock, ControlOp, Generation, LabelUniverse, Lane, Rendezvous, SessionId, TopologyError,
    Transport,
};

impl<'rv, 'cfg, T, U, C, E> Rendezvous<'rv, 'cfg, T, U, C, E>
where
    'cfg: 'rv,
    T: Transport,
    U: LabelUniverse,
    C: Clock,
    E: crate::control::cap::mint::EpochTable,
{
    pub(crate) fn reserve_source_topology_commit(
        &self,
        sid: SessionId,
        lane: Lane,
    ) -> Result<ReservedSourceTopologyCommitProof, TopologyError> {
        self.topology.reserve_source_commit(lane, sid)
    }

    pub(crate) fn rollback_source_topology_commit_reservation(
        &self,
        sid: SessionId,
        lane: Lane,
        ticket: ReservedSourceTopologyCommitProof,
    ) {
        self.topology
            .rollback_source_commit_reserved(lane, sid, ticket)
    }

    pub(crate) fn reserve_destination_topology_commit(
        &self,
        sid: SessionId,
        lane: Lane,
    ) -> Result<ReservedDestinationTopologyCommitProof, TopologyError> {
        self.topology.reserve_destination_commit(lane, sid)
    }

    pub(crate) fn rollback_destination_topology_commit_reservation(
        &self,
        sid: SessionId,
        lane: Lane,
        ticket: ReservedDestinationTopologyCommitProof,
    ) {
        self.topology
            .rollback_destination_commit_reserved(lane, sid, ticket)
    }

    pub(crate) fn assert_prepared_destination_topology_commit(
        &self,
        ticket: &ReservedDestinationTopologyCommitProof,
        sid: SessionId,
        lane: Lane,
        target: Generation,
    ) {
        assert_eq!(self.r#gen.last(lane), ticket.previous_generation());
        assert_eq!(ticket.target(), target);
        self.topology
            .assert_destination_commit_reserved(lane, sid, ticket);
    }

    pub(crate) fn assert_prepared_source_topology_commit(
        &self,
        ticket: &ReservedSourceTopologyCommitProof,
        sid: SessionId,
        lane: Lane,
        target: Generation,
    ) {
        assert_eq!(self.r#gen.last(lane), ticket.previous_generation());
        assert_eq!(ticket.target(), target);
        self.topology
            .assert_source_commit_reserved(lane, sid, ticket);
    }

    pub(crate) fn publish_prepared_destination_topology_commit(
        &mut self,
        ticket: ReservedDestinationTopologyCommitProof,
        lane: Lane,
    ) {
        let target = ticket.target();
        self.r#gen.publish_prepared(lane, target);
        self.topology
            .finalize_prepared_destination_commit_unchecked(ticket);
    }

    pub(crate) fn publish_prepared_source_topology_commit(
        &mut self,
        ticket: ReservedSourceTopologyCommitProof,
        sid: SessionId,
        lane: Lane,
    ) {
        let target = ticket.target();
        self.topology
            .clear_prepared_source_commit_unchecked(&ticket);
        self.r#gen.publish_prepared(lane, target);
        ticket.commit();
        let packed = ((lane.as_wire() as u32) & 0xFF) | ((target.0 as u32) << 16);
        self.emit_effect(ControlOp::TopologyCommit, sid, lane, packed);
    }
}