isagalaev/debounce - Change HL3B7CBVIFOE5UDQ4PFYFLTSHWY6ITXMWSLNKFAI7QQHLD5GRF2AC

Reorganize the crate

Created by isagalaev on October 18, 2021

HL3B7CBVIFOE5UDQ4PFYFLTSHWY6ITXMWSLNKFAI7QQHLD5GRF2AC

Dependencies

In channels

main

Change contents

Replacement in src/thread.rs at line 1 [3.34]

B:BD[3.34] → [3.35:97]

use crate::{BufferGet, EventBuffer, MixedEventBuffer, State};

[3.34]

[3.97]

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

Replacement in src/thread.rs at line 6 [3.34]
B:BD[3.189] → [2.0:32]
```
pub struct DebouncerThread<B> {
```
[3.189]
[2.32]
```
struct DebouncerThread<B> {
```

Deletion in src/lib.rs at line 2 [4.47]

B:BD[4.80] → [4.80:187]


use std::cmp::Ordering;
use std::collections::{BinaryHeap, VecDeque};
use std::time::{Duration, Instant};

Insertion in src/lib.rs at line 3 [4.47]
[3.1772]
[3.1772]
```
pub mod buffer;
```

Deletion in src/lib.rs at line 5 [4.47]

∅:D[3.1788] → [4.187:680]

B:BD[4.187] → [4.187:680]

B:BD[4.680] → [3.1789:1845]

∅:D[3.1845] → [4.740:743]

B:BD[4.740] → [4.740:743]

B:BD[4.743] → [3.1846:2096]

∅:D[3.2096] → [4.864:880]

B:BD[4.864] → [4.864:880]


#[derive(Debug, PartialEq, Eq)]
struct Event<T> {
    item: T,
    release_at: Instant,
}
impl<T: Eq> Ord for Event<T> {
    fn cmp(&self, other: &Self) -> Ordering {
        other.release_at.cmp(&self.release_at) // reverse ordering for min-heap
    }
}
impl<T: Eq> PartialOrd for Event<T> {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}
#[derive(Debug, PartialEq)]
pub enum State<T> {
    Ready(T),
    Wait(Duration),
    Empty,
}
trait BufferGet<T> {
    fn get(&mut self) -> State<T>;
}
pub struct EventBuffer<T> {
    delay: Duration,
    events: VecDeque<Event<T>>,
}
impl<T: PartialEq> EventBuffer<T> {
    pub fn new(delay: Duration) -> EventBuffer<T> {
        EventBuffer {
            delay,
            events: VecDeque::new(),
        }
    }

Replacement in src/lib.rs at line 6 [4.47]

B:BD[4.881] → [3.2097:2134]

∅:D[3.2134] → [4.935:1055]

B:BD[4.935] → [4.935:1055]

B:BD[4.1055] → [3.2135:2173]

∅:D[3.2173] → [4.1088:1106]

B:BD[4.1088] → [4.1088:1106]

B:BD[4.1106] → [3.2174:2217]

∅:D[3.2217] → [4.1144:1162]

B:BD[4.1144] → [4.1144:1162]

B:BD[4.1162] → [3.2218:2220]

∅:D[3.2220] → [4.1162:1163]

B:BD[4.1162] → [4.1162:1163]

B:BD[4.1163] → [3.2221:2299]

∅:D[3.2299] → [4.1203:1238]

B:BD[4.1203] → [4.1203:1238]

B:BD[4.1238] → [3.2300:2335]

∅:D[3.2335] → [4.1273:1387]

B:BD[4.1273] → [4.1273:1387]

B:BD[4.1387] → [3.2336:2412]

∅:D[3.2412] → [4.1457:1476]

B:BD[4.1457] → [4.1457:1476]

B:BD[4.1476] → [3.2413:2480]

∅:D[3.2480] → [4.1562:1565]

B:BD[4.1562] → [4.1562:1565]

B:BD[4.1565] → [3.2481:2623]

∅:D[3.2623] → [4.1746:1763]

B:BD[4.1746] → [4.1746:1763]

B:BD[4.1763] → [3.2624:2678]

∅:D[3.2678] → [4.1800:1920]

B:BD[4.1800] → [4.1800:1920]

B:BD[4.1920] → [3.2679:2712]

∅:D[3.2712] → [4.1958:1976]

B:BD[4.1958] → [4.1958:1976]

B:BD[4.1976] → [3.2713:2751]

∅:D[3.2751] → [4.2019:2037]

B:BD[4.2019] → [4.2019:2037]

B:BD[4.2037] → [3.2752:2754]

∅:D[3.2754] → [4.2037:2038]

B:BD[4.2037] → [4.2037:2038]

B:BD[4.2038] → [3.2755:2842]

∅:D[3.2842] → [4.2078:2113]

B:BD[4.2078] → [4.2078:2113]

B:BD[4.2113] → [3.2843:2878]

∅:D[3.2878] → [4.2148:2262]

B:BD[4.2148] → [4.2148:2262]

B:BD[4.2262] → [3.2879:2949]

∅:D[3.2949] → [4.2338:2537]

B:BD[4.2338] → [4.2338:2537]

B:BD[4.2537] → [3.2950:3007]

∅:D[3.3007] → [4.2587:2985]

B:BD[4.2587] → [4.2587:2985]

B:BD[4.2985] → [3.3008:3065]

∅:D[3.3065] → [4.3035:3533]

B:BD[4.3035] → [4.3035:3533]

B:BD[4.3533] → [3.3066:3123]

∅:D[3.3123] → [4.3583:3997]

B:BD[4.3583] → [4.3583:3997]

B:BD[4.3997] → [3.3124:3201]

∅:D[3.3201] → [4.4079:4450]

B:BD[4.4079] → [4.4079:4450]

B:BD[4.4450] → [3.3202:3279]

∅:D[3.3279] → [4.4532:4913]

B:BD[4.4532] → [4.4532:4913]

    pub fn put(&mut self, item: T) {
        let time = Instant::now();
        self.events
            .retain(|e| e.release_at <= time || e.item != item);
        self.events.push_back(Event {
            item,
            release_at: time + self.delay,
        });
    }
}
impl<T> BufferGet<T> for EventBuffer<T> {
    fn get(&mut self) -> State<T> {
        let time = Instant::now();
        match self.events.get(0) {
            None => State::Empty,
            Some(e) if e.release_at > time => State::Wait(e.release_at - time),
            Some(_) => State::Ready(self.events.pop_front().unwrap().item),
        }
    }
}
pub struct MixedEventBuffer<T> {
    events: BinaryHeap<Event<T>>,
}
impl<T: Eq> MixedEventBuffer<T> {
    pub fn new() -> MixedEventBuffer<T> {
        MixedEventBuffer {
            events: BinaryHeap::new(),
        }
    }
    pub fn put(&mut self, item: T, delay: Duration) {
        let time = Instant::now();
        self.events
            .retain(|e| e.release_at <= time || e.item != item);
        self.events.push(Event {
            item,
            release_at: time + delay,
        });
    }
}
impl<T: Eq> BufferGet<T> for MixedEventBuffer<T> {
    fn get(&mut self) -> State<T> {
        let time = Instant::now();
        match self.events.peek() {
            None => State::Empty,
            Some(e) if e.release_at > time => State::Wait(e.release_at - time),
            Some(_) => State::Ready(self.events.pop().unwrap().item),
        }
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    use std::thread::sleep;
    use std::time::Duration;
    mod debouncer {
        use super::*;
        #[test]
        fn wait() {
            let mut debouncer = MixedEventBuffer::new();
            debouncer.put(1, Duration::from_millis(20));
            assert!(matches!(debouncer.get(), State::Wait(_)));
            sleep(Duration::from_millis(10));
            assert!(matches!(debouncer.get(), State::Wait(_)));
            sleep(Duration::from_millis(10));
            assert!(matches!(debouncer.get(), State::Ready(_)));
        }
        #[test]
        fn deduplication() {
            let mut debouncer = MixedEventBuffer::new();
            debouncer.put(1, Duration::from_millis(20));
            debouncer.put(2, Duration::from_millis(30));
            sleep(Duration::from_millis(10));
            debouncer.put(1, Duration::from_millis(10));
            sleep(Duration::from_millis(20));
            assert_eq!(
                vec![debouncer.get(), debouncer.get(), debouncer.get()],
                vec![State::Ready(1), State::Ready(2), State::Empty]
            );
        }
        #[test]
        fn event_order() {
            let mut debouncer = MixedEventBuffer::new();
            debouncer.put(2, Duration::from_millis(20));
            debouncer.put(1, Duration::from_millis(10));
            sleep(Duration::from_millis(30));
            assert_eq!(
                vec![debouncer.get(), debouncer.get()],
                vec![State::Ready(1), State::Ready(2)]
            );
        }
    }
    mod uniform_debouncer {
        use super::*;
        #[test]
        fn wait() {
            let mut debouncer = EventBuffer::new(Duration::from_millis(20));
            debouncer.put(1);
            assert!(matches!(debouncer.get(), State::Wait(_)));
            sleep(Duration::from_millis(10));
            assert!(matches!(debouncer.get(), State::Wait(_)));
            sleep(Duration::from_millis(10));
            assert!(matches!(debouncer.get(), State::Ready(_)));
        }
        #[test]
        fn deduplication() {
            let mut debouncer = EventBuffer::new(Duration::from_millis(20));
            debouncer.put(1);
            debouncer.put(2);
            sleep(Duration::from_millis(10));
            debouncer.put(1);
            sleep(Duration::from_millis(20));
            assert_eq!(
                vec![debouncer.get(), debouncer.get(), debouncer.get()],
                vec![State::Ready(2), State::Ready(1), State::Empty]
            );
        }
    }
}

[4.881]

pub use thread::{EventDebouncer, MixedEventDebouncer};

File addition: buffer.rs (----------)

[4.15]

use std::cmp::Ordering;
use std::collections::{BinaryHeap, VecDeque};
use std::time::{Duration, Instant};
#[derive(Debug, PartialEq, Eq)]
struct Event<T> {
    item: T,
    release_at: Instant,
}
impl<T: Eq> Ord for Event<T> {
    fn cmp(&self, other: &Self) -> Ordering {
        other.release_at.cmp(&self.release_at) // reverse ordering for min-heap
    }
}
impl<T: Eq> PartialOrd for Event<T> {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}
#[derive(Debug, PartialEq)]
pub enum State<T> {
    Ready(T),
    Wait(Duration),
    Empty,
}
pub trait BufferGet<T> {
    fn get(&mut self) -> State<T>;
}
pub struct EventBuffer<T> {
    delay: Duration,
    events: VecDeque<Event<T>>,
}
impl<T: PartialEq> EventBuffer<T> {
    pub fn new(delay: Duration) -> EventBuffer<T> {
        EventBuffer {
            delay,
            events: VecDeque::new(),
        }
    }
    pub fn put(&mut self, item: T) {
        let time = Instant::now();
        self.events
            .retain(|e| e.release_at <= time || e.item != item);
        self.events.push_back(Event {
            item,
            release_at: time + self.delay,
        });
    }
}
impl<T> BufferGet<T> for EventBuffer<T> {
    fn get(&mut self) -> State<T> {
        let time = Instant::now();
        match self.events.get(0) {
            None => State::Empty,
            Some(e) if e.release_at > time => State::Wait(e.release_at - time),
            Some(_) => State::Ready(self.events.pop_front().unwrap().item),
        }
    }
}
pub struct MixedEventBuffer<T> {
    events: BinaryHeap<Event<T>>,
}
impl<T: Eq> MixedEventBuffer<T> {
    pub fn new() -> MixedEventBuffer<T> {
        MixedEventBuffer {
            events: BinaryHeap::new(),
        }
    }
    pub fn put(&mut self, item: T, delay: Duration) {
        let time = Instant::now();
        self.events
            .retain(|e| e.release_at <= time || e.item != item);
        self.events.push(Event {
            item,
            release_at: time + delay,
        });
    }
}
impl<T: Eq> BufferGet<T> for MixedEventBuffer<T> {
    fn get(&mut self) -> State<T> {
        let time = Instant::now();
        match self.events.peek() {
            None => State::Empty,
            Some(e) if e.release_at > time => State::Wait(e.release_at - time),
            Some(_) => State::Ready(self.events.pop().unwrap().item),
        }
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    use std::thread::sleep;
    use std::time::Duration;
    mod debouncer {
        use super::*;
        #[test]
        fn wait() {
            let mut debouncer = MixedEventBuffer::new();
            debouncer.put(1, Duration::from_millis(20));
            assert!(matches!(debouncer.get(), State::Wait(_)));
            sleep(Duration::from_millis(10));
            assert!(matches!(debouncer.get(), State::Wait(_)));
            sleep(Duration::from_millis(10));
            assert!(matches!(debouncer.get(), State::Ready(_)));
        }
        #[test]
        fn deduplication() {
            let mut debouncer = MixedEventBuffer::new();
            debouncer.put(1, Duration::from_millis(20));
            debouncer.put(2, Duration::from_millis(30));
            sleep(Duration::from_millis(10));
            debouncer.put(1, Duration::from_millis(10));
            sleep(Duration::from_millis(20));
            assert_eq!(
                vec![debouncer.get(), debouncer.get(), debouncer.get()],
                vec![State::Ready(1), State::Ready(2), State::Empty]
            );
        }
        #[test]
        fn event_order() {
            let mut debouncer = MixedEventBuffer::new();
            debouncer.put(2, Duration::from_millis(20));
            debouncer.put(1, Duration::from_millis(10));
            sleep(Duration::from_millis(30));
            assert_eq!(
                vec![debouncer.get(), debouncer.get()],
                vec![State::Ready(1), State::Ready(2)]
            );
        }
    }
    mod uniform_debouncer {
        use super::*;
        #[test]
        fn wait() {
            let mut debouncer = EventBuffer::new(Duration::from_millis(20));
            debouncer.put(1);
            assert!(matches!(debouncer.get(), State::Wait(_)));
            sleep(Duration::from_millis(10));
            assert!(matches!(debouncer.get(), State::Wait(_)));
            sleep(Duration::from_millis(10));
            assert!(matches!(debouncer.get(), State::Ready(_)));
        }
        #[test]
        fn deduplication() {
            let mut debouncer = EventBuffer::new(Duration::from_millis(20));
            debouncer.put(1);
            debouncer.put(2);
            sleep(Duration::from_millis(10));
            debouncer.put(1);
            sleep(Duration::from_millis(20));
            assert_eq!(
                vec![debouncer.get(), debouncer.get(), debouncer.get()],
                vec![State::Ready(2), State::Ready(1), State::Empty]
            );
        }
    }
}