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

use crate::{
    endpoint::kernel::{core::MaterializedRouteBranch, lane_port},
    global::typestate::RecvMeta,
};

pub(crate) struct DecodeState<'r> {
    pub(crate) branch: Option<MaterializedRouteBranch<'r>>,
    prepared_meta: Option<RecvMeta>,
    pending_recv: lane_port::PendingRecv,
    pub(crate) restore_on_drop: bool,
}

impl<'r> DecodeState<'r> {
    #[inline]
    pub(crate) const fn empty() -> Self {
        Self {
            branch: None,
            prepared_meta: None,
            pending_recv: lane_port::PendingRecv::new(),
            restore_on_drop: false,
        }
    }

    #[inline]
    pub(crate) fn new(branch: MaterializedRouteBranch<'r>) -> Self {
        Self {
            branch: Some(branch),
            prepared_meta: None,
            pending_recv: lane_port::PendingRecv::new(),
            restore_on_drop: true,
        }
    }

    #[inline]
    pub(crate) fn branch(&self) -> Option<&MaterializedRouteBranch<'r>> {
        self.branch.as_ref()
    }

    #[inline]
    pub(crate) fn branch_mut(&mut self) -> Option<&mut MaterializedRouteBranch<'r>> {
        self.branch.as_mut()
    }

    #[inline]
    pub(crate) fn take_branch(&mut self) -> Option<MaterializedRouteBranch<'r>> {
        self.branch.take()
    }

    #[inline]
    pub(crate) fn discard_terminal(&mut self) {
        if let Some(branch) = self.branch.take() {
            branch.discard_terminal();
        }
        self.restore_on_drop = false;
    }

    #[inline]
    pub(crate) fn prepared_meta(&self) -> Option<RecvMeta> {
        self.prepared_meta
    }

    #[inline]
    pub(crate) fn set_prepared_meta(&mut self, prepared_meta: Option<RecvMeta>) {
        self.prepared_meta = prepared_meta;
    }

    #[inline]
    pub(crate) fn pending_recv_mut(&mut self) -> &mut lane_port::PendingRecv {
        &mut self.pending_recv
    }
}