Splits a signal into two parts

split.rs

use std::sync::Arc;
use std::cell::RefCell;

use bounded_spsc_queue::{Producer, Consumer, make};

use sample::Signal;

const SPLIT_BUFFER_SIZE: usize = 512;

#[allow(dead_code)]
pub struct Joint<S>
where
    S: Signal + Sized,
{
    sig: S,
    pipes: [Producer<<S as Signal>::Frame>; 2],
}

#[allow(dead_code)]
pub struct Split<S>
where
    S: Signal + Sized,
{
    sig: Arc<RefCell<Joint<S>>>,
    pipe: Consumer<<S as Signal>::Frame>,
}

impl<S> Joint<S>
where
    S: Signal + Sized,
{
    /// Adds a value to all pipes
    pub fn produce(&mut self) {
        let val = self.sig.next();
        for pipe in self.pipes.iter_mut() {
            pipe.try_push(val);
        }
    }
}

#[allow(unused_must_use)]
impl<S> Signal for Split<S>
where
    S: Signal + Sized,
{
    type Frame = S::Frame;

    fn next(&mut self) -> Self::Frame {
        match self.pipe.try_pop() {
            Some(v) => v,
            None => {
                // Reasonably, we can assume that if this is borrowed then it's the other Split
                // that's borrowing it. In that case, we can spin on pop() for as long as is
                // necessary to get the value. Not ideal though.
                self.sig.try_borrow_mut().and_then(|mut s| Ok(s.produce()));
                self.pipe.pop()
            }
        }
    }
}

#[allow(dead_code)]
pub fn split<S: Signal>(s: S) -> (Split<S>, Split<S>) {
    let (p1, c1) = make(SPLIT_BUFFER_SIZE);
    let (p2, c2) = make(SPLIT_BUFFER_SIZE);

    let joint = Joint {
        sig: s,
        pipes: [p1, p2],
    };

    let ref_joint = Arc::new(RefCell::new(joint));

    let s1 = Split {
        sig: ref_joint.clone(),
        pipe: c1,
    };

    let s2 = Split {
        sig: ref_joint.clone(),
        pipe: c2,
    };

    (s1, s2)
}

#[cfg(test)]
mod tests {
    use super::*;
    use sample::{Signal, signal};

    #[test]
    fn test_split_signal() {
        let sig = signal::gen(|| [0.]);
        let (mut one, _) = split(sig);
        assert_eq!(one.next(), [0.]);
    }

    #[test]
    fn test_split_and_overwrite() {
        let mut val = 0.;
        let ramp = signal::gen_mut(move || {
            val = val + 0.25;
            [val]
        });
        let (mut one, mut two) = split(ramp);
        assert_eq!(one.next(), [0.25]);
        assert_eq!(one.next(), [0.5]);
        assert_eq!(two.next(), [0.25]);
        assert_eq!(two.next(), [0.5]);
        assert_eq!(two.next(), [0.75]);
    }
}