hibana 0.9.2

Session-typed choreographic programming for no_std Rust protocols, inspired by affine MPST
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

//! Affine lane guard used by cursor endpoints.
//!
//! The guard is the detached RAII witness for a leased lane. `LaneLease`
//! creates it only after converting the borrow-bound rendezvous lease into a
//! `Port`, so the endpoint keeps only the shorter borrow lifetime.

use core::cell::Cell;
use core::marker::PhantomData;

use crate::{
    rendezvous::core::{LaneRelease, Rendezvous},
    session::types::{Lane, SessionId},
    transport::Transport,
};

/// Lease-backed lane guard.
///
/// Dropping the guard releases the lane via the underlying rendezvous.
/// The raw pointer erases the longer rendezvous lifetime; the shorter endpoint
/// borrow is carried by `active_leases`.
pub(crate) struct LaneGuard<'lease, T: Transport> {
    rendezvous: *const (),
    sid: SessionId,
    lane: Lane,
    active_leases: &'lease Cell<u32>,
    _marker: PhantomData<fn() -> T>,
}

impl<'lease, T> LaneGuard<'lease, T>
where
    T: Transport,
{
    pub(crate) fn new_detached(
        rendezvous: *const (),
        sid: SessionId,
        lane: Lane,
        active_leases: &'lease Cell<u32>,
    ) -> Self {
        Self {
            rendezvous,
            sid,
            lane,
            active_leases,
            _marker: PhantomData,
        }
    }
}

impl<'lease, T> Drop for LaneGuard<'lease, T>
where
    T: Transport,
{
    fn drop(&mut self) {
        let sid = self.sid;
        let lane = self.lane;
        if !self.rendezvous.is_null() {
            /* SAFETY: `LaneGuard` stores the rendezvous pointer that issued the
            lane lease. Drop only needs a shared rendezvous borrow to release
            the counted lane handle and emit the release evidence. */
            unsafe {
                let rv = &*self.rendezvous.cast::<Rendezvous<'static, 'static, T>>();
                match rv.release_lane(sid, lane) {
                    LaneRelease::Released => rv.emit_lane_release(sid, lane),
                    LaneRelease::StillHeld => {}
                }
            }
        }

        let current = self.active_leases.get();
        if current == 0 {
            crate::invariant();
        }
        self.active_leases.set(current - 1);
    }
}