ltrait 1.5.0

Yet Another Fuzzy Finder (Builder) for OS Wide, inspired from vim-fall and ddu.vim (and xmonad)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use ltrait::{
    UI,
    color_eyre::eyre::Result,
    launcher::batcher::Batcher,
    ui::{Buffer, Position},
};

use std::marker::PhantomData;

pub struct DummyUI<T, F>
where
    F: Fn(&T),
{
    f: F,

    _marker: PhantomData<T>,
}

impl<T, F> DummyUI<T, F>
where
    T: Sync + Send,
    F: Fn(&T) + Sync,
{
    pub fn new(f: F) -> Self {
        Self {
            f,
            _marker: PhantomData,
        }
    }
}

impl<T, F, Cushion> UI<Cushion> for DummyUI<T, F>
where
    T: Sync + Send,
    F: Fn(&T) + Sync,
    Cushion: Send + Sync + 'static,
{
    type Context = T;

    async fn run(&self, mut batcher: Batcher<Cushion, Self::Context>) -> Result<Option<Cushion>> {
        let mut more = true;
        let mut buf: Buffer<(T, usize)> = Buffer::default();

        while more {
            let from = batcher.prepare().await;
            more = batcher.merge(&mut buf, from)?;
        }

        let mut pos = Position::default();
        let mut least_one = false;
        while let Some(&(ref c, _)) = buf.next(&mut pos) {
            (self.f)(c);
            if !least_one {
                least_one = true;
            }
        }

        if least_one {
            Ok(Some(batcher.compute_cushion(0)?))
        } else {
            Ok(None)
        }
    }
}