futuresdr 0.0.39

An Experimental Async SDR Runtime for Heterogeneous Architectures.
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 crate::prelude::*;

/// Apply a function to split a stream.
#[derive(Block)]
pub struct Split<
    F,
    A,
    B,
    C,
    I = DefaultCpuReader<A>,
    O0 = DefaultCpuWriter<B>,
    O1 = DefaultCpuWriter<C>,
> where
    F: FnMut(&A) -> (B, C) + Send + 'static,
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    I: CpuBufferReader<Item = A>,
    O0: CpuBufferWriter<Item = B>,
    O1: CpuBufferWriter<Item = C>,
{
    #[input]
    input: I,
    #[output]
    output0: O0,
    #[output]
    output1: O1,
    f: F,
}

impl<F, A, B, C, I, O0, O1> Split<F, A, B, C, I, O0, O1>
where
    F: FnMut(&A) -> (B, C) + Send + 'static,
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    I: CpuBufferReader<Item = A>,
    O0: CpuBufferWriter<Item = B>,
    O1: CpuBufferWriter<Item = C>,
{
    /// Create Split block
    pub fn new(f: F) -> Self {
        Self {
            input: I::default(),
            output0: O0::default(),
            output1: O1::default(),
            f,
        }
    }
}

#[doc(hidden)]
impl<F, A, B, C, I, O1, O2> Kernel for Split<F, A, B, C, I, O1, O2>
where
    F: FnMut(&A) -> (B, C) + Send + 'static,
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    I: CpuBufferReader<Item = A>,
    O1: CpuBufferWriter<Item = B>,
    O2: CpuBufferWriter<Item = C>,
{
    async fn work(
        &mut self,
        io: &mut WorkIo,
        _mio: &mut MessageOutputs,
        _meta: &mut BlockMeta,
    ) -> Result<()> {
        let i0 = self.input.slice();
        let o0 = self.output0.slice();
        let o1 = self.output1.slice();
        let i0_len = i0.len();

        let m = std::cmp::min(i0.len(), o0.len());
        let m = std::cmp::min(m, o1.len());

        if m > 0 {
            for (x, (y0, y1)) in i0.iter().zip(o0.iter_mut().zip(o1.iter_mut())) {
                let (a, b) = (self.f)(x);
                *y0 = a;
                *y1 = b;
            }

            self.input.consume(m);
            self.output0.produce(m);
            self.output1.produce(m);
        }

        if self.input.finished() && m == i0_len {
            io.finished = true;
        }

        Ok(())
    }
}