jobflow 0.3.0

Executes jobs in order
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

use crate::backend::job::Data;
use crate::sync::promise::MapPromise;
use crate::sync::promise::{IntoPromise, PollPromise, Promise, PromiseSet};

/// The backend funnel implementation.
///
/// Funnels accepts inputs from tasks, and produces one output
#[derive(Debug)]
pub struct BackendFunnel {
    promises: PromiseSet<'static, Vec<Data>>,
}

impl BackendFunnel {
    /// Creates a new backend funnel
    pub fn new() -> Self {
        Self {
            promises: PromiseSet::new(),
        }
    }

    /// Inserts a promise into this backend funnel
    pub fn insert<P: IntoPromise<Output = Data> + 'static>(&mut self, p: P) {
        self.promises.insert(p.into_promise().map(|d| vec![d]));
    }

    /// Inserts a promise into this backend funnel
    pub fn insert_iter<
        I: IntoIterator<Item = Data> + 'static,
        P: IntoPromise<Output = I> + 'static,
    >(
        &mut self,
        p: P,
    ) {
        self.promises
            .insert(p.into_promise().map(|i: I| i.into_iter().collect()));
    }
}

impl IntoPromise for BackendFunnel {
    type Output = Vec<Data>;
    type IntoPromise = BackendFunnelPromise;

    fn into_promise(self) -> Self::IntoPromise {
        BackendFunnelPromise { set: self.promises }
    }
}

/// Backend future promise
pub struct BackendFunnelPromise {
    set: PromiseSet<'static, Vec<Data>>,
}

impl Promise for BackendFunnelPromise {
    type Output = Vec<Data>;

    fn poll(&mut self) -> PollPromise<Self::Output> {
        match self.set.poll() {
            PollPromise::Ready(ready) => PollPromise::Ready(ready.into_iter().flatten().collect()),
            PollPromise::Pending => PollPromise::Pending,
        }
    }
}