kutil 0.0.6

Kutil utilities collection
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use super::{super::super::super::std::collections::*, preference::*, selector::*, weight::*};

use std::{hash::*, iter::*, str::*};

//
// Preferences
//

/// List of [Preference].
#[derive(Clone, Debug)]
pub struct Preferences<SelectionT>(pub Vec<Preference<SelectionT>>);

impl<SelectionT> Preferences<SelectionT> {
    /// Sort by weight (highest to lowest).
    pub fn sorted(mut self) -> Self {
        self.0.sort_by(|a, b| b.weight.cmp(&a.weight));
        self
    }

    /// Parse, combine, and sort.
    pub fn parse(representations: &Vec<&str>) -> Self
    where
        SelectionT: Clone + Eq + FromStr,
    {
        let preferences: Vec<_> = representations
            .iter()
            .flat_map(|representation| representation.split(","))
            .filter_map(move |format| {
                let mut split = format.splitn(2, ';');

                let selector = (split.next().expect("splitn not empty").trim()).parse().ok()?;

                let weight = match split.next() {
                    Some(weight) => Weight::parse(weight.trim())?,
                    None => Weight::MAX,
                };

                Some(Preference::new(selector, weight))
            })
            .collect();

        Self(preferences).sorted()
    }

    /// Select the most preferred allowance.
    ///
    /// If there is a tie, we will go by the order of allowances.
    pub fn best<'context, 'allowances, 'selection>(
        &'context self,
        allowances: &'allowances [SelectionT],
    ) -> Option<&'selection SelectionT>
    where
        'context: 'selection,
        'allowances: 'selection,
        SelectionT: Hash + Eq,
    {
        if self.0.is_empty() {
            None
        } else {
            let mut candidates = FastHashSet::<&SelectionT>::with_capacity(allowances.len());

            for (index, preference) in self.0.iter().enumerate() {
                let selections = preference.selector.select(allowances);

                if !selections.is_empty() {
                    candidates.extend(selections);

                    if preference.selector.is_specific() {
                        // There might still be more candidates if there are other preferences
                        // of equal weight (and they would be right after us)
                        candidates.extend(self.select_tied(index, preference.weight, allowances));
                    }

                    break;
                }
            }

            if candidates.len() == 1 {
                // No contest
                return Some(candidates.into_iter().next().expect("iter not empty"));
            } else if !candidates.is_empty() {
                // Break the tie
                for selection in allowances {
                    if candidates.contains(&selection) {
                        return Some(selection);
                    }
                }
            }

            None
        }
    }

    /// Select the most preferred allowance.
    ///
    /// If there is a tie, we will go by the order of allowances.
    ///
    /// If no best preference can be found we'll return the first allowance. `allowances` must not
    /// be empty!
    pub fn best_or_first<'context, 'allowances, 'selection>(
        &'context self,
        allowances: &'allowances [SelectionT],
    ) -> &'selection SelectionT
    where
        'context: 'selection,
        'allowances: 'selection,
        SelectionT: Hash + Eq,
    {
        assert!(allowances.len() > 0);
        self.best(allowances).unwrap_or_else(|| &allowances[0])
    }

    // Selections with equal weight.
    fn select_tied<'context, 'allowances, 'selection>(
        &'context self,
        index: usize,
        weight: Weight,
        allowances: &'allowances [SelectionT],
    ) -> FastHashSet<&'selection SelectionT>
    where
        'context: 'selection,
        'allowances: 'selection,
        SelectionT: Hash + Eq,
    {
        let mut tied = FastHashSet::with_capacity(self.0.len() - index);

        for preference in &self.0[index + 1..] {
            if preference.weight != weight {
                break;
            }

            tied.extend(preference.selector.select(allowances));
        }

        tied
    }
}