Untitled

use std::sync::Arc;
use std::sync::mpsc::{channel, Sender};
use std::thread::JoinHandle;
use std::time::Duration;

//unsafe impl Send for Message{}

#[derive(Debug)]
struct Message {
    msg: usize
}

struct Looper {
    sender: Sender<Message>,
    threads: Vec<JoinHandle<()>>
}

impl Looper{
    fn new <T: Fn(Message)->() + Send + 'static, Q: Fn()->() + Send + 'static> (process: T, cleanup: Q) -> Self {
        let (tx, rx) = channel::<Message>();
        let mut threads = Vec::new();
        threads.push(std::thread::spawn(move || {
            while let Ok(msg) = rx.recv(){
                process(msg);
            }
            cleanup();
        }));
        return Looper{
            sender: tx,
            threads
        }
    }

    pub fn send(&self, msg: Message){
        self.sender.send(msg);
    }
}

fn main() {
    let f1 = |mut s: Message| {s.msg = 1;
        println!("Processata{:?}", s)};
    let f2 = || {println!("Cleanup!")};
    let str = Arc::new(Looper::new(f1, f2));

    let lo1 = str.clone();
    let s = std::thread::spawn(move || {
        for i in 0..10 {
            lo1.send( Message{ msg: 0});
        }
    });





    for i in str.threads{
        i.join().unwrap();
    }
}