isagalaev/debounce - Change WZZIC3CRIGXJWGFRLM2JM7IN6IIZQZ4U4TPMWPNYYSJFNJM25LWQC

Implement low-level stopping and joining for debouncers

Created by isagalaev on December 14, 2021

WZZIC3CRIGXJWGFRLM2JM7IN6IIZQZ4U4TPMWPNYYSJFNJM25LWQC

Dependencies

In channels

main

Change contents

Insertion in src/thread.rs at line 2 [4.34]
[2.64]
[4.97]
```
use std::sync::atomic::{AtomicBool, Ordering};
```
Insertion in src/thread.rs at line 10 [4.34]
[4.287]
[4.287]
```
    stopped: Arc<AtomicBool>,
```

Insertion in src/thread.rs at line 20 [4.34]

[5.306]

[3.0]

        let stopped = Arc::new(AtomicBool::new(false));

Replacement in src/thread.rs at line 23 [4.34]

B:BD[3.76] → [3.76:363]

            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),

[3.76]

[3.363]

            let stopped = stopped.clone();
            move || {
                while !stopped.load(Ordering::Relaxed) {
                    let state = mutex.lock().unwrap().get();
                    match state {
                        State::Empty => thread::park(),
                        State::Wait(duration) => thread::sleep(duration),
                        State::Ready(data) => f(data),
                    }

Replacement in src/thread.rs at line 35 [4.34]

B:BD[5.673] → [5.673:704]

        Self { mutex, thread }

[5.673]

[5.704]

        Self {
            mutex,
            thread,
            stopped,
        }
    }
    fn stop(self) -> JoinHandle<()> {
        self.stopped.store(true, Ordering::Relaxed);
        self.thread

Insertion in src/thread.rs at line 66 [4.34]

[4.1209]


    /// Signals the debouncer thread to quit and returns a
    /// [std::thread::JoinHandle] which can be `.join()`ed in the consumer
    /// thread. The common idiom is:
    ///
    ///     debouncer.stop().join().unwrap();
    pub fn stop(self) -> JoinHandle<()> {
        self.0.stop()
    }

Insertion in src/thread.rs at line 96 [4.34]

[4.1768]


    /// Signals the debouncer thread to quit and returns a
    /// [std::thread::JoinHandle] which can be `.join()`ed in the consumer
    /// thread. The common idiom is:
    ///
    ///     debouncer.stop().join().unwrap();
    pub fn stop(self) -> JoinHandle<()> {
        self.0.stop()
    }