#[derive(Debug)]
#[derive(Clone)]
pub struct DataIn {
    v: Option<Vec<f32>>,
    default: f32,
    name: String
}

impl DataIn {
    pub fn new(name: String, default: f32) -> DataIn {
        DataIn { name, v: None, default }
    }

    pub fn get(&mut self) -> Vec<f32> {
        let v = self.v.take();
        v.unwrap_or(vec![self.default])
    }

    pub fn set(&mut self, v: Vec<f32>) {
        self.v = Some(v);
    }
}

pub trait MisoWorker {
    fn get_data(&self) -> Vec<DataIn>;
    fn extract(&mut self, vals: &[f32]) -> f32;
}

pub struct MisoModule<T: MisoWorker> {
    data: Vec<DataIn>,
    worker: T
}

impl <T: MisoWorker> MisoModule<T> {
    fn extract(&mut self, output: usize, len: usize) -> Vec<f32> {
        assert_eq!(output, 0);
        let mut val = Vec::with_capacity(len);
        let vecs = self.data.iter_mut().map(|d| d.get());
        let mut cycles = vecs.map(|item| item.into_iter().cycle()).collect::<Vec<_>>();

        let mut inputs = Vec::with_capacity(cycles.len());
        for i in 0..len {
            inputs.clear();
            inputs.extend(cycles.iter_mut().map(|c| c.next().unwrap()));
            val.push(self.worker.extract(&inputs));
        }
        val
    }
}

fn main() {
    return ();
}