dope-runtime 0.38.0

Thread-per-core execution and process lifecycle 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

use dope_core::{BranchError, driver::storage};

/// Builds one output from exact generative storage.
pub trait Build<S>: Sized
where
    S: storage::Plan,
{
    type Output<'life, 'p, 'd>: 'life
    where
        'd: 'p,
        'p: 'life,
        'd: 'life,
        Self: 'd,
        S: 'd;
    type Error;

    fn build<'life, 'p, 'd>(
        self,
        storage: &'life S::Output<'p, 'd>,
    ) -> Result<Self::Output<'life, 'p, 'd>, Self::Error>
    where
        'd: 'p,
        'p: 'life,
        'd: 'life,
        Self: 'd,
        S: 'd;
}

impl<S, A, B> Build<S> for (A, B)
where
    S: storage::Plan,
    A: Build<S>,
    B: Build<S>,
{
    type Output<'life, 'p, 'd>
        = (A::Output<'life, 'p, 'd>, B::Output<'life, 'p, 'd>)
    where
        'd: 'p,
        'p: 'life,
        'd: 'life,
        Self: 'd,
        S: 'd;
    type Error = BranchError<A::Error, B::Error>;

    fn build<'life, 'p, 'd>(
        self,
        storage: &'life S::Output<'p, 'd>,
    ) -> Result<Self::Output<'life, 'p, 'd>, Self::Error>
    where
        'd: 'p,
        'p: 'life,
        'd: 'life,
        Self: 'd,
        S: 'd,
    {
        let first = self.0.build(storage).map_err(BranchError::First)?;
        let second = self.1.build(storage).map_err(BranchError::Second)?;
        Ok((first, second))
    }
}