dope-manifold 0.28.0

Owned application and service composition for dope
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

use dope_core::driver::{route, settings};
use dope_runtime::executor;

use crate::app::dispatch;

/// Activates the exact installed owner selected for this target's route.
///
/// # Safety
/// The call must retain the installed owner selected for `R`.
unsafe fn activate<'a, 'driver, 'turn, 'd, M, R>(
    call: executor::raw::Call<'a, M, (), executor::raw::Activate<'driver, 'turn, 'd>>,
) where
    'd: 'driver + 'turn,
    M: dispatch::raw::Activate<'d, R>,
    R: route::App,
{
    let (owner, (), wake) = call.into_parts();
    let (target, turn, driver) = wake.into_parts();
    let target = driver
        .driver_ref()
        .targets::<R>()
        .bind(target.slot(), target.epoch());
    let mut root = dispatch::raw::Context::<dispatch::raw::Retained>::new(driver);
    let mut driver = root.narrow::<M::Access>();
    // SAFETY: the caller retains the installed owner selected for R;
    // rebinding preserves its slot and epoch and narrowing preserves access.
    unsafe { M::activate(owner, target, turn, &mut driver) };
}

/// Statically selected activation capability for one exact route.
///
/// # Safety
/// `call` receives the exact installed owner selected for the target route.
pub unsafe trait Wakes<'d, M, R: route::App> {
    type Plan;

    const ROUTES: settings::Routes;

    fn select() -> Option<Self::Plan>;

    /// # Safety
    /// The call retains the exact pinned owner and plan selected for this route.
    unsafe fn call<'a, 'driver, 'turn>(
        call: executor::raw::Call<'a, M, Self::Plan, executor::raw::Activate<'driver, 'turn, 'd>>,
    ) where
        'd: 'driver + 'turn;
}

// SAFETY: projection preserves the exact pinned owner and selected inner plan.
unsafe impl<'d, M, R> Wakes<'d, M, R> for dispatch::raw::Projected<M>
where
    R: route::App,
    M: dispatch::raw::Projection<'d>,
    M::Inner: dispatch::raw::Manifold<'d, Route = R>,
{
    type Plan =
        <<M::Inner as dispatch::raw::Manifold<'d>>::Activate as Wakes<'d, M::Inner, R>>::Plan;

    const ROUTES: settings::Routes =
        <<M::Inner as dispatch::raw::Manifold<'d>>::Activate as Wakes<'d, M::Inner, R>>::ROUTES;

    fn select() -> Option<Self::Plan> {
        <<M::Inner as dispatch::raw::Manifold<'d>>::Activate as Wakes<'d, M::Inner, R>>::select()
    }

    unsafe fn call<'a, 'driver, 'turn>(
        call: executor::raw::Call<'a, M, Self::Plan, executor::raw::Activate<'driver, 'turn, 'd>>,
    ) where
        'd: 'driver + 'turn,
    {
        // SAFETY: projection keeps the installed owner pinned and preserves its selected plan.
        unsafe {
            <<M::Inner as dispatch::raw::Manifold<'d>>::Activate as Wakes<'d, M::Inner, R>>::call(
                call.map_owner(dispatch::raw::Projection::inner_mut),
            )
        }
    }
}

// SAFETY: the singleton route selects M's plain activation with the same pinned owner.
unsafe impl<'d, M, R> Wakes<'d, M, R> for dispatch::raw::Plain
where
    M: dispatch::raw::Activate<'d, R, Access = dispatch::raw::Plain>,
    R: route::App,
{
    type Plan = ();

    const ROUTES: settings::Routes = settings::Routes::singleton_id(R::ID);

    fn select() -> Option<Self::Plan> {
        Some(())
    }

    unsafe fn call<'a, 'driver, 'turn>(
        call: executor::raw::Call<'a, M, Self::Plan, executor::raw::Activate<'driver, 'turn, 'd>>,
    ) where
        'd: 'driver + 'turn,
    {
        // SAFETY: this call retains the exact installed owner selected for R.
        unsafe { activate::<M, R>(call) };
    }
}

// SAFETY: the singleton route selects M's retained activation with the same pinned owner.
unsafe impl<'d, M, R> Wakes<'d, M, R> for dispatch::raw::Retained
where
    M: dispatch::raw::Activate<'d, R, Access = dispatch::raw::Retained>,
    R: route::App,
{
    type Plan = ();

    const ROUTES: settings::Routes = settings::Routes::singleton_id(R::ID);

    fn select() -> Option<Self::Plan> {
        Some(())
    }

    unsafe fn call<'a, 'driver, 'turn>(
        call: executor::raw::Call<'a, M, Self::Plan, executor::raw::Activate<'driver, 'turn, 'd>>,
    ) where
        'd: 'driver + 'turn,
    {
        // SAFETY: this call retains the exact installed owner selected for R.
        unsafe { activate::<M, R>(call) };
    }
}