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

use dope_core::driver::route::{Identity, table::conn::Capacity};
use dope_net::{Transport, wire::domain};

use crate::{
    app::{creation, receive},
    client::{
        app::{self, resume},
        attempt,
    },
};

/// Prepares receive retention for an exact input and continuation pair.
pub trait Policy<'w, 'd: 'w, ID: Identity, A>
where
    A: app::Receive<'d, ID>,
{
    fn prepare<S, T>(
        app: A,
        control: S,
        capacity: Capacity,
    ) -> Result<(A, S, domain::Retained, domain::Resident), creation::Error>
    where
        S: attempt::Control<'d, T, ID>,
        T: Transport;
}

impl<'w, 'd: 'w, ID: Identity, A, C> Policy<'w, 'd, ID, A> for (receive::Borrowed, C)
where
    A: app::Borrowed<'d, ID, Continuation = C>,
    C: resume::Mode<Retention = resume::Absent>,
{
    fn prepare<S, T>(
        app: A,
        mut control: S,
        capacity: Capacity,
    ) -> Result<(A, S, domain::Retained, domain::Resident), creation::Error>
    where
        S: attempt::Control<'d, T, ID>,
        T: Transport,
    {
        attempt::Control::resize(&mut control, capacity.scale::<1>())
            .map_err(creation::Error::Attempt)?;
        Ok((app, control, domain::Retained::ZERO, domain::Resident::ZERO))
    }
}

impl<'w, 'd: 'w, ID: Identity, A, R: Default> Policy<'w, 'd, ID, A>
    for (receive::Owned<R>, resume::Complete)
where
    A: app::Owned<'w, 'd, ID, R, Continuation = resume::Complete>,
{
    fn prepare<S, T>(
        app: A,
        mut control: S,
        capacity: Capacity,
    ) -> Result<(A, S, domain::Retained, domain::Resident), creation::Error>
    where
        S: attempt::Control<'d, T, ID>,
        T: Transport,
    {
        let retain = app
            .retention()
            .capacity(capacity)
            .map_err(creation::Error::Config)?;
        attempt::Control::resize(&mut control, capacity.scale::<1>())
            .map_err(creation::Error::Attempt)?;
        Ok((app, control, retain, domain::Resident::ZERO))
    }
}

impl<'w, 'd: 'w, ID: Identity, A, R: Default> Policy<'w, 'd, ID, A>
    for (receive::Owned<R>, resume::Retained)
where
    A: app::Owned<'w, 'd, ID, R, Continuation = resume::Retained>
        + app::Resumable<'d, ID, Continuation = resume::Retained>,
{
    fn prepare<S, T>(
        app: A,
        mut control: S,
        capacity: Capacity,
    ) -> Result<(A, S, domain::Retained, domain::Resident), creation::Error>
    where
        S: attempt::Control<'d, T, ID>,
        T: Transport,
    {
        let retain = app
            .retention()
            .capacity(capacity)
            .map_err(creation::Error::Config)?;
        let resident = app::Resumable::resident(&app);
        attempt::Control::resize(&mut control, capacity.scale::<1>())
            .map_err(creation::Error::Attempt)?;
        Ok((app, control, retain, resident))
    }
}