ltrait-extra 0.2.0

Extra components and helpers for LTrait
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use ltrait::{sorter::SorterWrapper, Sorter};
use std::marker::PhantomData;

pub struct SorterIf<'a, T, Cusion, F>
where
    T: Sorter<'a, Context = Cusion>,
    F: Fn(&Cusion) -> bool + Send + 'a,
    Cusion: Sync,
{
    sorter: T,

    f: F,

    _ctx: PhantomData<&'a Cusion>,
}

impl<'a, T> SorterExt<'a> for T where T: Sorter<'a> {}

pub trait SorterExt<'a>: Sorter<'a> {
    fn to_if<Cusion, F, TransF>(
        self,
        f: F,
        transformer: TransF,
    ) -> impl Sorter<'a, Context = Cusion>
    // Wrapもされる
    where
        Self: Sized,
        Cusion: Sync + Send + 'a,
        F: Fn(&Cusion) -> bool + Send + 'a,
        TransF: Fn(&Cusion) -> <Self as Sorter<'a>>::Context + Send + 'a,
        <Self as Sorter<'a>>::Context: Sync,
    {
        SorterIf::new(self, f, transformer)
    }

    fn reverse(self) -> impl Sorter<'a, Context = <Self as Sorter<'a>>::Context>
    where
        Self: Sized,
        <Self as Sorter<'a>>::Context: Sync,
    {
        ReversedSorter::new(self)
    }
}

impl<'a, Cusion, F, InnerT, TransF, Ctx>
    SorterIf<'a, SorterWrapper<'a, Ctx, InnerT, TransF, Cusion>, Cusion, F>
where
    F: Fn(&Cusion) -> bool + Send,
    Cusion: Sync + Send,
    InnerT: Sorter<'a, Context = Ctx>,
    TransF: Fn(&Cusion) -> Ctx + Send,
    Ctx: Sync,
{
    pub fn new(sorter: InnerT, f: F, transformer: TransF) -> Self {
        Self {
            sorter: SorterWrapper::new(sorter, transformer),
            f,
            _ctx: PhantomData,
        }
    }
}

impl<'a, T, Ctx, F> Sorter<'a> for SorterIf<'a, T, Ctx, F>
where
    T: Sorter<'a, Context = Ctx>,
    F: Fn(&Ctx) -> bool + Send + 'a,
    Ctx: Sync,
{
    type Context = Ctx;

    fn compare(&self, lhs: &Self::Context, rhs: &Self::Context, input: &str) -> std::cmp::Ordering {
        if (self.f)(lhs) {
            self.sorter.compare(lhs, rhs, input)
        } else {
            std::cmp::Ordering::Equal
        }
    }
}

pub struct ReversedSorter<'a, T, Ctx>
where
    T: Sorter<'a, Context = Ctx>,
    Ctx: Sync,
{
    sorter: T,

    _ctx: PhantomData<&'a Ctx>,
}

impl<'a, T, Ctx> ReversedSorter<'a, T, Ctx>
where
    T: Sorter<'a, Context = Ctx>,
    Ctx: Sync,
{
    pub fn new(sorter: T) -> Self {
        Self {
            sorter,
            _ctx: PhantomData,
        }
    }
}

impl<'a, T, Ctx> Sorter<'a> for ReversedSorter<'a, T, Ctx>
where
    T: Sorter<'a, Context = Ctx>,
    Ctx: Sync,
{
    type Context = Ctx;

    fn compare(&self, lhs: &Self::Context, rhs: &Self::Context, input: &str) -> std::cmp::Ordering {
        self.sorter.compare(lhs, rhs, input).reverse()
    }
}