ltrait 1.0.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
65
66
67

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

use std::marker::PhantomData;

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

    _marker: PhantomData<&'a T>,
}

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

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

    async fn run<Cusion: 'a + Send>(
        &self,
        mut batcher: Batcher<'a, Cusion, Self::Context>,
    ) -> Result<Option<Cusion>> {
        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).await?;
        }

        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_cusion(0)?))
        } else {
            Ok(None)
        }
    }
}