isagalaev/debounce - Change IOHM3NIST5FMQDSRXXXOBNK2DKQKHDFB4YWJWRB6B2ROWVB7W75QC

Extract threaded debouncers in a module

Created by isagalaev on October 18, 2021

IOHM3NIST5FMQDSRXXXOBNK2DKQKHDFB4YWJWRB6B2ROWVB7W75QC

Dependencies

In channels

main

Change contents

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

[3.15]

use crate::{BufferGet, EventBuffer, MixedEventBuffer, State};
use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
use std::time::Duration;
pub struct EventDebouncer<T> {
    mutex: Arc<Mutex<EventBuffer<T>>>,
    thread: JoinHandle<()>,
}
fn spawn<B, F, T>(mutex: &Arc<Mutex<B>>, f: F) -> JoinHandle<()>
where
    B: BufferGet<T> + Send + 'static,
    F: Fn(T) -> () + Send + 'static,
    T: Send + 'static,
{
    let mutex = mutex.clone();
    thread::spawn(move || loop {
        let state = { mutex.lock().unwrap().get() };
        match state {
            State::Empty => thread::park(),
            State::Wait(duration) => thread::sleep(duration),
            State::Ready(data) => f(data),
        }
    })
}
impl<T: PartialEq> EventDebouncer<T> {
    pub fn new<F>(delay: Duration, f: F) -> Self
    where
        F: Fn(T) -> () + Send + 'static,
        T: Send + 'static,
    {
        let mutex = Arc::new(Mutex::new(EventBuffer::new(delay)));
        let thread = spawn(&mutex, f);
        Self { mutex, thread }
    }
    pub fn put(&self, data: T) {
        self.mutex.lock().unwrap().put(data);
        self.thread.thread().unpark();
    }
}
pub struct MixedEventDebouncer<T> {
    mutex: Arc<Mutex<MixedEventBuffer<T>>>,
    thread: JoinHandle<()>,
}
impl<T: Eq> MixedEventDebouncer<T> {
    pub fn new<F>(f: F) -> Self
    where
        F: Fn(T) -> () + Send + 'static,
        T: Send + 'static,
    {
        let mutex = Arc::new(Mutex::new(MixedEventBuffer::new()));
        let thread = spawn(&mutex, f);
        Self { mutex, thread }
    }
    pub fn put(&self, data: T, delay: Duration) {
        self.mutex.lock().unwrap().put(data, delay);
        self.thread.thread().unpark();
    }
}

Insertion in src/lib.rs at line 6 [3.47]
[3.187]
[3.187]
```
pub mod thread;
```

Replacement in src/lib.rs at line 34 [3.47]

B:BD[3.680] → [3.680:740]

pub struct Debouncer<T> {
    events: BinaryHeap<Event<T>>,

[3.680]

[3.740]

trait BufferGet<T> {
    fn get(&mut self) -> State<T>;

Replacement in src/lib.rs at line 38 [3.47]

B:BD[3.743] → [3.743:864]

impl<T: Eq> Debouncer<T> {
    pub fn new() -> Debouncer<T> {
        Debouncer {
            events: BinaryHeap::new(),

[3.743]

[3.864]

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 51 [3.47]

B:BD[3.881] → [3.881:935]

    pub fn put(&mut self, item: T, delay: Duration) {

[3.881]

[3.935]

    pub fn put(&mut self, item: T) {

Replacement in src/lib.rs at line 55 [3.47]
B:BD[3.1055] → [3.1055:1088]
```
        self.events.push(Event {
```
[3.1055]
[3.1088]
```
        self.events.push_back(Event {
```

Replacement in src/lib.rs at line 57 [3.47]

B:BD[3.1106] → [3.1106:1144]

            release_at: time + delay,

[3.1106]

[3.1144]

            release_at: time + self.delay,

Insertion in src/lib.rs at line 60 [3.47]
[3.1162]
[3.1162]
```
}
```

Replacement in src/lib.rs at line 62 [3.47]

B:BD[3.1163] → [3.1163:1203]

    pub fn get(&mut self) -> State<T> {

[3.1163]

[3.1203]

impl<T> BufferGet<T> for EventBuffer<T> {
    fn get(&mut self) -> State<T> {

Replacement in src/lib.rs at line 65 [3.47]
B:BD[3.1238] → [3.1238:1273]
```
        match self.events.peek() {
```
[3.1238]
[3.1273]
```
        match self.events.get(0) {
```

Replacement in src/lib.rs at line 68 [3.47]

B:BD[3.1387] → [3.1387:1457]

            Some(_) => State::Ready(self.events.pop().unwrap().item),

[3.1387]

[3.1457]

            Some(_) => State::Ready(self.events.pop_front().unwrap().item),

Replacement in src/lib.rs at line 73 [3.47]

B:BD[3.1476] → [3.1476:1562]

pub struct UniformDebouncer<T> {
    delay: Duration,
    events: VecDeque<Event<T>>,

[3.1476]

[3.1562]

pub struct MixedEventBuffer<T> {
    events: BinaryHeap<Event<T>>,

Replacement in src/lib.rs at line 77 [3.47]

B:BD[3.1565] → [3.1565:1746]

impl<T: PartialEq> UniformDebouncer<T> {
    pub fn new(delay: Duration) -> UniformDebouncer<T> {
        UniformDebouncer {
            delay,
            events: VecDeque::new(),

[3.1565]

[3.1746]

impl<T: Eq> MixedEventBuffer<T> {
    pub fn new() -> MixedEventBuffer<T> {
        MixedEventBuffer {
            events: BinaryHeap::new(),

Replacement in src/lib.rs at line 84 [3.47]

B:BD[3.1763] → [3.1763:1800]

    pub fn put(&mut self, item: T) {

[3.1763]

[3.1800]

    pub fn put(&mut self, item: T, delay: Duration) {

Replacement in src/lib.rs at line 88 [3.47]
B:BD[3.1920] → [3.1920:1958]
```
        self.events.push_back(Event {
```
[3.1920]
[3.1958]
```
        self.events.push(Event {
```

Replacement in src/lib.rs at line 90 [3.47]

B:BD[3.1976] → [3.1976:2019]

            release_at: time + self.delay,

[3.1976]

[3.2019]

            release_at: time + delay,

Insertion in src/lib.rs at line 93 [3.47]
[3.2037]
[3.2037]
```
}
```

Replacement in src/lib.rs at line 95 [3.47]

B:BD[3.2038] → [3.2038:2078]

    pub fn get(&mut self) -> State<T> {

[3.2038]

[3.2078]

impl<T: Eq> BufferGet<T> for MixedEventBuffer<T> {
    fn get(&mut self) -> State<T> {

Replacement in src/lib.rs at line 98 [3.47]
B:BD[3.2113] → [3.2113:2148]
```
        match self.events.get(0) {
```
[3.2113]
[3.2148]
```
        match self.events.peek() {
```

Replacement in src/lib.rs at line 101 [3.47]

B:BD[3.2262] → [3.2262:2338]

            Some(_) => State::Ready(self.events.pop_front().unwrap().item),

[3.2262]

[3.2338]

            Some(_) => State::Ready(self.events.pop().unwrap().item),

Replacement in src/lib.rs at line 117 [3.47]

B:BD[3.2537] → [3.2537:2587]

            let mut debouncer = Debouncer::new();

[3.2537]

[3.2587]

            let mut debouncer = MixedEventBuffer::new();

Replacement in src/lib.rs at line 128 [3.47]

B:BD[3.2985] → [3.2985:3035]

            let mut debouncer = Debouncer::new();

[3.2985]

[3.3035]

            let mut debouncer = MixedEventBuffer::new();

Replacement in src/lib.rs at line 142 [3.47]

B:BD[3.3533] → [3.3533:3583]

            let mut debouncer = Debouncer::new();

[3.3533]

[3.3583]

            let mut debouncer = MixedEventBuffer::new();

Replacement in src/lib.rs at line 158 [3.47]

B:BD[3.3997] → [3.3997:4079]

            let mut debouncer = UniformDebouncer::new(Duration::from_millis(20));

[3.3997]

[3.4079]

            let mut debouncer = EventBuffer::new(Duration::from_millis(20));

Replacement in src/lib.rs at line 169 [3.47]

B:BD[3.4450] → [3.4450:4532]

            let mut debouncer = UniformDebouncer::new(Duration::from_millis(20));

[3.4450]

[3.4532]

            let mut debouncer = EventBuffer::new(Duration::from_millis(20));

Replacement in examples/debounce.rs at line 1 [4.57]
B:BD[4.57] → [4.58:94]
```
use debounce::{EventBuffer, State};
```
[4.57]
[4.94]
```
use debounce::thread::EventDebouncer;
```
Deletion in examples/debounce.rs at line 6 [4.57]
B:BD[4.181] → [4.181:247]
```
use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
```
Deletion in examples/debounce.rs at line 7 [4.57]
B:BD[4.272] → [4.272:273]
B:BD[4.273] → [2.0:94]
∅:D[2.94] → [4.430:432]
B:BD[4.430] → [4.430:432]
```
struct EventDebouncer<T> {
    mutex: Arc<Mutex<EventBuffer<T>>>,
    thread: JoinHandle<()>,
}
```

Deletion in examples/debounce.rs at line 8 [4.57]

B:BD[4.433] → [2.95:869]

∅:D[2.869] → [4.527:530]

B:BD[4.527] → [4.527:530]

impl<T: PartialEq> EventDebouncer<T> {
    fn new<F>(timeout: Duration, f: F) -> Self
    where
        F: Fn(T) -> (),
        F: Send + 'static,
        T: Send + 'static,
    {
        let mutex = Arc::new(Mutex::new(EventBuffer::new(timeout)));
        let mutex_clone = mutex.clone();
        let thread = thread::spawn(move || loop {
            let state = { mutex_clone.lock().unwrap().get() };
            match state {
                State::Empty => thread::park(),
                State::Wait(duration) => thread::sleep(duration),
                State::Ready(data) => f(data),
            }
        });
        Self { mutex, thread }
    }
    fn put(&self, data: T) {
        self.mutex.lock().unwrap().put(data);
        self.thread.thread().unpark();
    }
}

Insertion in examples/debounce.rs at line 9 [4.57]
[4.572]
[4.572]
```
    // Parse arguments
```

Replacement in examples/debounce.rs at line 12 [4.57]

B:BD[4.658] → [4.658:731]

    opts.reqopt("t", "", "debounce timeout in milliseconds", "TIMEOUT");

[4.658]

[4.731]

    opts.reqopt("d", "", "debounce delay in milliseconds", "TIMEOUT");

Replacement in examples/debounce.rs at line 14 [4.57]

B:BD[4.774] → [4.774:832]

    let timeout = matches.opt_str("t").unwrap().parse()?;

[4.774]

[4.992]

    let delay = matches.opt_str("d").unwrap().parse()?;

Replacement in examples/debounce.rs at line 16 [4.57]

B:BD[4.993] → [2.870:964]

    let debouncer = EventDebouncer::new(Duration::from_millis(timeout), move |data: String| {

[4.993]

[2.964]

    // Create threaded debouncer
    let debouncer = EventDebouncer::new(Duration::from_millis(delay), move |data: String| {
        // Debounced strings are written to stdout

Insertion in examples/debounce.rs at line 22 [4.57]

[4.1307]

    // Send strings from stdin to the debouncer indefinitely