ltrait-extra 0.4.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

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

impl<T> SorterExt for T where T: Sorter {}

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

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

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

    f: F,

    _ctx: PhantomData<Cushion>,
}

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

impl<T, Ctx, F> Sorter for SorterIf<T, Ctx, F>
where
    T: Sorter<Context = Ctx>,
    F: Fn(&Ctx) -> bool + Send,
    Ctx: Sync + Send,
{
    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<T, Ctx>
where
    T: Sorter<Context = Ctx>,
    Ctx: Sync,
{
    sorter: T,

    _ctx: PhantomData<Ctx>,
}

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

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

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