use std::time::{Duration, Instant};
struct Event<T> {
    item: T,
}
pub enum State<T> {
    Ready(T),
    Wait(Duration),
    Empty,
}
pub struct Debouncer<T> {
}
        Debouncer {
        }
    }
        let time = Instant::now();
    }
    pub fn get(&mut self) -> State<T> {
        let time = Instant::now();
            None => State::Empty,
        }
    }
}
            Some(e) if e.release_at > time => State::Wait(e.release_at - time),
            Some(_) => State::Ready(self.events.pop().unwrap().item),
        match self.events.peek() {
        self.events
            .retain(|e| e.release_at <= time || e.item != item);
        self.events.push(Event {
            item,
            release_at: time + delay,
        });
    pub fn put(&mut self, item: T, delay: Duration) {
            events: BinaryHeap::new(),
impl<T: Eq> Debouncer<T> {
    pub fn new() -> Debouncer<T> {
    events: BinaryHeap<Event<T>>,
#[derive(Debug)]
    release_at: Instant,
}
impl<T: Eq> Ord for Event<T> {
    fn cmp(&self, other: &Self) -> Ordering {
    }
}
impl<T: Eq> PartialOrd for Event<T> {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
        other.release_at.cmp(&self.release_at) // reverse ordering for min-heap
#[derive(Debug, PartialEq, Eq)]
use std::cmp::Ordering;
use std::collections::BinaryHeap;

#![feature(exit_status_error, binary_heap_retain)]

#![feature(exit_status_error)]

mod debounce;

use debounce::{Debouncer, State};

use debounce::MixedEventDebouncer;

use std::thread::sleep;

use std::sync::Arc;

    let mut processors = HashMap::new();

    for processor in Config::parse()?.processors {
        register_processor(&mut processors, &mut inotify, processor)
            .unwrap_or_else(|e| eprintln!("Error: {}", e))
    }

    let processors = Arc::new({
        let mut map = HashMap::new();
        for processor in Config::parse()?.processors {
            register_processor(&mut map, &mut inotify, processor)
                .unwrap_or_else(|e| eprintln!("Error: {}", e))
        }
        map
    });

    let processors_clone = Arc::clone(&processors);
    let debouncer = MixedEventDebouncer::new(move |file: File| {
        let processor = &processors_clone[&file.wd];
        let filename = processor.path.join(&file.name);
        println!("Processing {:?}", filename);
        process(&filename, &processor.command, &processor.args[..])
            .unwrap_or_else(|e| eprintln!("Error: {}", e));
    });

    let mut debouncer = Debouncer::new();

        println!("Waiting...");

            let delay = Duration::from_millis(processors[&event.wd].debounce);

            let delay = Duration::from_millis((processors[&event.wd]).debounce);

        loop {
            match debouncer.get() {
                State::Empty => break,
                State::Wait(_) => sleep(Duration::from_millis(50)),
                State::Ready(file) => {
                    let processor = &processors[&file.wd];
                    let filename = processor.path.join(&file.name);
                    println!("Processing {:?}", filename);
                    process(&filename, &processor.command, &processor.args[..])
                        .unwrap_or_else(|e| eprintln!("Error: {}", e));
                }
            }
            for event in inotify.read_events(&mut buffer)? {
                let delay = Duration::from_millis(processors[&event.wd].debounce);
                debouncer.put(File::from(event), delay)
            }
        }

debounce = { path = "../debounce" }