dope-net 0.46.0

Owned network transports for dope
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

use dope_core::driver::route;
pub mod domain;
pub mod failure;
pub mod open;
pub mod receive;
pub mod send;
pub mod terminal;

/// A protocol and route-storage family owned by its enclosing assembly.
/// Borrowed wire state retains its storage owner independently of the driver brand.
pub trait Spec: Sized {
    type Connection<'d, ID: route::Identity + 'd>: 'd
    where
        Self: 'd;
    type Storage<ID: route::Identity>;
    type Binding<'d, ID: route::Identity + 'd>: 'd
    where
        Self: 'd;
    type Runtime<'w, 'd, ID: route::Identity + 'w>: open::Runtime<'w, 'd, Self, ID> + 'w
    where
        Self: 'w,
        'd: 'w;
    type SendStorage<'d>: send::Store + 'd
    where
        Self: 'd;
    /// Selector that structurally determines the exact open-error family.
    type OpenFailure: failure::Class<Self, failure::Open>;
    /// Selector that structurally determines the exact terminal-error family.
    type TerminalFailure: failure::Class<Self, failure::Terminal>;

    type Bootstrap;
    type Receive: receive::Policy<Self>;
    type Send: send::Policy<Self>;
}

#[derive(Clone, Copy, Default, PartialEq, Eq)]
pub struct Identity;

/// Stateless runtime for the transparent wire.
pub struct Runtime;

impl Spec for Identity {
    type Connection<'d, ID: route::Identity + 'd>
        = Self
    where
        Self: 'd;
    type Storage<ID: route::Identity> = Self;
    type Binding<'d, ID: route::Identity + 'd>
        = Self
    where
        Self: 'd;
    type Runtime<'w, 'd, ID: route::Identity + 'w>
        = Runtime
    where
        Self: 'w,
        'd: 'w;
    type SendStorage<'d>
        = ()
    where
        Self: 'd;
    type OpenFailure = failure::Never;
    type TerminalFailure = failure::Never;

    type Bootstrap = Identity;
    type Receive = receive::Transparent;
    type Send = send::Direct;
}

impl domain::Init<Identity> for Identity {
    fn runtime<'w, 'd, ID: route::Identity + 'w>(_: domain::Limits, _: Identity) -> Runtime
    where
        Identity: 'w,
        'd: 'w,
    {
        Runtime
    }
}

impl<'w, 'd: 'w, ID: route::Identity + 'w> open::Runtime<'w, 'd, Identity, ID> for Runtime {
    fn open<C, T>(
        &mut self,
        context: C,
        consume: impl FnOnce(C, Identity, ()) -> open::Disposition<T, Identity, ()>,
    ) -> open::Outcome<C, T, open::Error<'w, Identity>> {
        let output = consume(context, Identity, ()).into_output(|wire, send| {
            let Identity = wire;
            send
        });
        open::Outcome::Opened(output)
    }
}