/// Threaded debouncer wrapping `EventBuffer`. Accepts a common delay and a
/// callback function which is going to be called by a background thread with
/// debounced events.

/// Threaded debouncer wrapping `MixedEventBuffer`. Accepts a callback function
/// which is going to be called by a background thread with debounced events.
/// The delay is specified separately for each event as an argument to `.put()`.

//! Data structures and helpers for *debouncing* a stream of events: removing
//! duplicate events occurring closely in time.
//!
//! Examples of such events:
//!
//! - File write operations coming from a file system monitor
//! - Similar log strings from a `tail -f`
//! - Hardware signals from a sensor
//!
//! Debouncers accept a raw stream of events and add a grace period during which
//! similar events are considered duplicates. The event is delivered after the
//! timeout expires after the last seen duplicate.
//!
//!
//! ## Data structures vs. debouncers
//!
//! The debouncing logic itself is implemented as passive data structures in the
//! `debounce::buffer` module. A buffer only implements `.put` and `.get`, and
//! is independent of a particular way of organizing asynchronicity, be it
//! periodic polling, threads, async streams or some other magic.
//!
//! The crate also provides threaded debouncers built on top of the buffers,
//! which is what you probably want to use most of the time.
//!
//!
//! ## Example usage
//!
//! ```rust
//! use debounce::EventDebouncer;
//! use std::thread::sleep;
//! use std::time::Duration;
//!
//! let delay = Duration::from_millis(10);
//! let debouncer = EventDebouncer::new(delay, move |data: String| {
//!     println!("{}", data);
//! });
//!
//! debouncer.put(String::from("foo"));
//! debouncer.put(String::from("foo"));
//! debouncer.put(String::from("bar"));
//! sleep(delay);
//!
//! // prints one "foo" and one "bar" after the delay
//! ```
//!
//! A working command-line debouncer is implemented in `examples/debounce.rs`
//! and can be used right away:
//!
//! ```sh
//! inotifywait -m -e close_write . | debounce -d 100
//! ```

/// Current state of the debouncing buffer returned from `.get()`:
///
/// - `Ready(T)` when the event is ready to be delivered after the timeout
///   (moves data out of the buffer)
/// - `Wait(Duration)` indicates how much time is left until `Ready`
/// - `Empty` means the buffer is empty

/// Debouncing buffer with a common delay for all events. Accepts events via
/// `.put()` which tracks the time of the event and de-duplicates them against
/// the current buffer content. Subsequent call to `.get()` which returns the
/// `State` of the buffer.
///
/// Implemented on top of a `VecDeque` and should be slightly more preformant
/// than `MixedEventBuffer`.

/// Debouncing buffer with per-event delays. Accepts events via `.put(T, delay)`
/// which tracks the time of the event and de-duplicates them against the
/// current buffer content. Subsequent call to `.get()` which returns the
/// `State` of the buffer.
///
/// Implemented on top of a `BinaryHeap` and should be slightly less preformant
/// than `EventBuffer`.

use debounce::thread::EventDebouncer;

use debounce::EventDebouncer;

# debounce
Data structures and helpers for *debouncing* a stream of events: removing
duplicate events occurring closely in time.
<https://doc.rust-lang.org/debounce>

description = "Data structures and helpers for debouncing a stream of events: removing duplicate events occurring closely in time."

documentation = "https://doc.rust-lang.org/debounce"

getopts = "*"

getopts = "0.2"