rustradio 0.16.5

Software defined radio library
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

//! Canary runs a lambda when it exits.
//!
//! It's an EOF detector.
use crate::Sample;
use crate::stream::{ReadStream, WriteStream};

#[derive(rustradio_macros::Block)]
#[rustradio(crate, new, sync, bound = "T: Sample")]
pub struct Canary<T, F>
where
    F: Fn() + Send,
{
    #[rustradio(in)]
    src: ReadStream<T>,
    #[rustradio(out)]
    dst: WriteStream<T>,
    f: F,
}

impl<T: Sample, F> Canary<T, F>
where
    F: Fn() + Send,
{
    fn process_sync(&mut self, s: T) -> T {
        s
    }
}

impl<T, F> Drop for Canary<T, F>
where
    F: Fn() + Send,
{
    fn drop(&mut self) {
        (self.f)();
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::Result;
    use crate::block::{Block, BlockEOF, BlockRet};
    use crate::blocks::VectorSource;
    use std::sync::atomic::Ordering;

    #[test]
    fn canary() -> Result<()> {
        let c = std::sync::atomic::AtomicBool::new(false);
        let (mut ib, src) = VectorSource::new(vec![1u8, 2, 3]);
        ib.work()?;
        let (mut b, out) = Canary::new(src, || c.store(true, Ordering::Relaxed));
        assert!(!c.load(Ordering::Relaxed));
        let ret = b.work()?;
        assert!(matches![ret, BlockRet::WaitForStream(_, _)], "{ret:?}");
        drop(ib);
        drop(ret);
        assert!(b.eof());
        assert!(!c.load(Ordering::Relaxed));
        drop(b);
        assert!(c.load(Ordering::Relaxed));
        let (res, _) = out.read_buf()?;
        let got = res.slice().to_vec();
        let want = vec![1u8, 2, 3];
        assert_eq!(got, want);
        Ok(())
    }
}