dope-core 0.15.0

The manifold runtime
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

use std::mem;

use crate::driver::{self, route, schedule::ready};

#[derive(Clone, Copy)]
pub struct Handle<'d> {
    driver: driver::Reference<'d>,
    key: ready::FixedKey<'d>,
}

impl<'d> Handle<'d> {
    pub(super) const fn new(driver: driver::Reference<'d>, key: ready::FixedKey<'d>) -> Self {
        Self { driver, key }
    }

    pub fn set_target<Tag: route::Tag>(self, target: route::Operation<'d, Tag>) {
        self.driver
            .ready()
            .arena()
            .set_target(self.key.key(), target.into_token());
    }

    pub fn activate(self) {
        self.driver
            .ready()
            .arena()
            .activate_dispatch(self.key.key());
    }

    pub fn key(self) -> ready::Key<'d> {
        self.key.key()
    }

    pub fn target(self) -> ready::Target<'d> {
        ready::Target {
            driver: self.driver,
            key: self.key.key(),
        }
    }

    #[doc(hidden)]
    pub fn identity(self) -> ready::FixedIdentity<'d> {
        ready::FixedIdentity::new(self.key)
    }

    #[doc(hidden)]
    pub fn arm_recv_credit<T: route::Credit<'d>>(self, target: T) -> bool {
        self.driver.credits().arm_recv_credit(self.key, target)
    }

    #[doc(hidden)]
    pub fn wake_recv_credit<T: route::Credit<'d>>(self, target: T, wake: driver::RecvCreditWake) {
        self.driver
            .credits()
            .wake_recv_credit(self.key, target, wake);
    }

    pub fn retain_recv_credit<T: route::Credit<'d>>(self, target: T) -> bool {
        self.driver.credits().retain_recv_credit(self.key, target)
    }

    pub fn release_recv_credit<T: route::Credit<'d>>(
        self,
        target: T,
        wake: driver::RecvCreditWake,
    ) {
        self.driver
            .credits()
            .release_recv_credit(self.key, target, wake);
    }

    #[doc(hidden)]
    pub fn cancel_recv_credit<T: route::Credit<'d>>(self, target: T) -> bool {
        self.driver.credits().cancel_recv_credit(self.key, target)
    }

    #[doc(hidden)]
    pub fn has_recv_credit<T: route::Credit<'d>>(self, target: T) -> bool {
        self.driver.credits().has_recv_credit(self.key, target)
    }

    #[doc(hidden)]
    pub fn take_recv_credit<T: route::Credit<'d>>(
        self,
        target: T,
    ) -> Option<driver::RecvCreditWake> {
        self.driver.credits().take_recv_credit(self.key, target)
    }

    #[doc(hidden)]
    pub fn arm_recv_buffer<T: route::Credit<'d>>(self, target: T) -> bool {
        self.driver.credits().arm_fixed_buffer(self.key, target)
    }

    #[doc(hidden)]
    pub fn cancel_recv_buffer<T: route::Credit<'d>>(self, target: T) -> bool {
        self.driver.credits().cancel_fixed_buffer(self.key, target)
    }

    #[doc(hidden)]
    pub fn take_recv_buffer<T: route::Credit<'d>>(
        self,
        target: T,
    ) -> Option<driver::RecvBufferCredit<'d>> {
        self.driver.credits().take_fixed_buffer(self.key, target)
    }
}

const _: () = {
    assert!(mem::size_of::<ready::Key<'static>>() == mem::size_of::<u64>());
    assert!(mem::size_of::<Handle<'static>>() == 2 * mem::size_of::<usize>());
};