isagalaev/debounce - Change VXKHXMQLNMD7OG4CKSZTX75WMHYTGXJG7AL7YTQBMI2WJ3GQC6JQC

Generic DebouncerThread

Created by isagalaev on October 18, 2021

VXKHXMQLNMD7OG4CKSZTX75WMHYTGXJG7AL7YTQBMI2WJ3GQC6JQC

Dependencies

[2] IOHM3NIST5FMQDSRXXXOBNK2DKQKHDFB4YWJWRB6B2ROWVB7W75QC

In channels

main

Change contents

Replacement in src/thread.rs at line 6 [2.34]

B:BD[2.189] → [2.189:259]

pub struct EventDebouncer<T> {
    mutex: Arc<Mutex<EventBuffer<T>>>,

[2.189]

[2.259]

pub struct DebouncerThread<B> {
    mutex: Arc<Mutex<B>>,

Replacement in src/thread.rs at line 11 [2.34]

B:BD[2.290] → [2.290:766]

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

[2.290]

[2.766]

impl<B> DebouncerThread<B> {
    fn new<F, T>(buffer: B, f: F) -> Self
    where
        B: BufferGet<T> + Send + 'static,
        F: Fn(T) -> () + Send + 'static,
        T: Send + 'static,
    {
        let mutex = Arc::new(Mutex::new(buffer));
        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 }
    }

Insertion in src/thread.rs at line 32 [2.34]

[2.769]

pub struct EventDebouncer<T>(DebouncerThread<EventBuffer<T>>);

Replacement in src/thread.rs at line 40 [2.34]

B:BD[2.941] → [2.941:1078]

        let mutex = Arc::new(Mutex::new(EventBuffer::new(delay)));
        let thread = spawn(&mutex, f);
        Self { mutex, thread }

[2.941]

[2.1078]

        Self(DebouncerThread::new(EventBuffer::new(delay), f))

Replacement in src/thread.rs at line 44 [2.34]

B:BD[2.1118] → [2.1118:1203]

        self.mutex.lock().unwrap().put(data);
        self.thread.thread().unpark();

[2.1118]

[2.1203]

        self.0.mutex.lock().unwrap().put(data);
        self.0.thread.thread().unpark();

Replacement in src/thread.rs at line 49 [2.34]

B:BD[2.1212] → [2.1212:1322]

pub struct MixedEventDebouncer<T> {
    mutex: Arc<Mutex<MixedEventBuffer<T>>>,
    thread: JoinHandle<()>,
}

[2.1212]

[2.1322]

pub struct MixedEventDebouncer<T>(DebouncerThread<MixedEventBuffer<T>>);

Replacement in src/thread.rs at line 57 [2.34]

B:BD[2.1476] → [2.1476:1613]

        let mutex = Arc::new(Mutex::new(MixedEventBuffer::new()));
        let thread = spawn(&mutex, f);
        Self { mutex, thread }

[2.1476]

[2.1613]

        Self(DebouncerThread::new(MixedEventBuffer::new(), f))

Replacement in src/thread.rs at line 61 [2.34]

B:BD[2.1670] → [2.1670:1762]

        self.mutex.lock().unwrap().put(data, delay);
        self.thread.thread().unpark();

[2.1670]

[2.1762]

        self.0.mutex.lock().unwrap().put(data, delay);
        self.0.thread.thread().unpark();