use crate::buffer::{Buffer, EventBuffer, MixedEventBuffer, State};

use crate::buffer::{EventBuffer, Get, MixedEventBuffer, State};

        B: Buffer + Send + 'static,

        B: Get + Send + 'static,

pub trait Buffer {

/// Common interface for getting events out of debouncing buffers.
pub trait Get: Sized {

    /// Attemtps to get the next element out of a buffer. If an element is
    /// ready (`State::Ready`) it's removed from the buffer.

    /// Returns an iterator over all `State::Ready` elements of the buffer.
    /// Stops when either the next element is in (`State::Wait`) or the buffer
    /// is `State::Empty`.
    fn iter(&mut self) -> BufferIter<Self> {
        BufferIter(self)
    }

/// Wraps a mutable reference to a buffer and implements an `Iterator` returning
/// elements in `State::Ready`. Commonly instantiated by `buffer.iter()`.
pub struct BufferIter<'a, B: Get>(&'a mut B);
impl<'a, B: Get> Iterator for BufferIter<'a, B> {
    type Item = B::Data;
    fn next(&mut self) -> Option<Self::Item> {
        match self.0.get() {
            State::Ready(data) => Some(data),
            _ => None,
        }
    }
}

impl<T> Buffer for EventBuffer<T> {

impl<T> Get for EventBuffer<T> {

impl<T: Eq> Buffer for MixedEventBuffer<T> {

impl<T: Eq> Get for MixedEventBuffer<T> {

            assert_eq!(
                vec![debouncer.get(), debouncer.get(), debouncer.get()],
                vec![State::Ready(2), State::Ready(1), State::Empty]
            );

            assert!(debouncer.iter().eq([2, 1]));

            assert_eq!(
                vec![debouncer.get(), debouncer.get(), debouncer.get()],
                vec![State::Ready(1), State::Ready(2), State::Empty]
            );

            assert!(debouncer.iter().eq([1, 2]));

            assert_eq!(
                vec![debouncer.get(), debouncer.get()],
                vec![State::Ready(1), State::Ready(2)]
            );

            assert!(debouncer.iter().eq([1, 2]));