arrayset 3.1.1

An array-backed ordered set type.
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

use super::OrdMap;

#[derive(Debug)]
pub struct VacantEntry<'a, K, V, const N: usize> {
    map: &'a mut OrdMap<K, V, N>,
    key: K,
    /// The index that the entry would be inserted into.
    index: usize,
}

impl<'a, K, V, const N: usize> VacantEntry<'a, K, V, N> {
    pub fn into_key(self) -> K {
        self.key
    }
    pub fn key(&self) -> &K {
        &self.key
    }
    /// The index this entry would insert at
    pub fn index(&self) -> usize {
        self.index
    }
    /// Try to insert a value into the map.  Returns the key and value on error.
    pub fn insert(self, value: V) -> Result<&'a mut V, (K, V)> {
        self.map
            .insert_at(self.index, self.key, value)
            .map(|()| &mut self.map.values_mut_slice()[self.index])
    }
}

#[derive(Debug)]
pub struct OccupiedEntry<'a, K, V, const N: usize> {
    pub(super) map: &'a mut OrdMap<K, V, N>,
    /// The index that the key occupies.
    pub(super) index: usize,
}

impl<'a, K, V, const N: usize> OccupiedEntry<'a, K, V, N> {
    /// A reference to the key in the map.
    pub fn key(&self) -> &K {
        &self.map.keys_slice()[self.index]
    }

    /// A reference to the value in the map.
    pub fn get(&self) -> &V {
        &self.map.values_slice()[self.index]
    }

    /// A reference to the value in the map.
    pub fn get_mut(&mut self) -> &mut V {
        &mut self.map.values_mut_slice()[self.index]
    }

    /// A reference to the value in the map.
    pub fn into_mut(self) -> &'a mut V {
        &mut self.map.values_mut_slice()[self.index]
    }

    /// The index this entry would insert at
    pub fn index(&self) -> usize {
        self.index
    }

    /// Replace the old value in the map.
    pub fn replace(&mut self, value: V) -> V {
        core::mem::replace(&mut self.map.values_mut_slice()[self.index], value)
    }

    /// Remove the old value from the map.
    pub fn remove(self) -> V {
        self.map.remove_at(self.index).1
    }
    /// Remove the old value from the map, returning both the key and value
    pub fn remove_key_value(self) -> (K, V) {
        self.map.remove_at(self.index)
    }
}

#[derive(Debug)]
pub enum Entry<'a, K, V, const N: usize>
// where
//     K: 'a,
//     V: 'a,
{
    Vacant(VacantEntry<'a, K, V, N>),
    Occupied(OccupiedEntry<'a, K, V, N>),
}

impl<'a, K, V, const N: usize> Entry<'a, K, V, N> {
    pub(super) fn occupied(map: &'a mut OrdMap<K, V, N>, index: usize) -> Self {
        Entry::Occupied(OccupiedEntry { map, index })
    }
    pub(super) fn vacant(map: &'a mut OrdMap<K, V, N>, index: usize, key: K) -> Self {
        Entry::Vacant(VacantEntry { map, key, index })
    }

    pub fn and_modify<F>(self, f: F) -> Self
    where
        F: FnOnce(&mut V),
    {
        match self {
            Entry::Vacant(entry) => Entry::Vacant(entry),
            Entry::Occupied(mut entry) => {
                f(entry.get_mut());
                Entry::Occupied(entry)
            }
        }
    }

    pub fn key(&self) -> &K {
        match self {
            Entry::Vacant(entry) => &entry.key,
            Entry::Occupied(entry) => &entry.key(),
        }
    }

    /// Insert the default value if vacant.  If the map is full, return the key as an Err.
    /// If the map was full, a default is not constructed.
    pub fn or_default(self) -> Result<&'a mut V, K>
    where
        V: Default,
    {
        self.or_insert_with(Default::default)
    }

    /// Insert the value if vacant.  If the map is full, return the key and value as an Err.
    pub fn or_insert(self, value: V) -> Result<&'a mut V, (K, V)> {
        match self {
            Entry::Vacant(entry) => entry.insert(value),
            Entry::Occupied(entry) => Ok(entry.into_mut()),
        }
    }

    /// Insert the value if vacant.  If the map is full, return the key, and the function is not executed.
    pub fn or_insert_with<F>(self, function: F) -> Result<&'a mut V, K>
    where
        F: FnOnce() -> V,
    {
        match self {
            Entry::Vacant(entry) => {
                if entry.map.len < N {
                    match entry.insert(function()) {
                        Ok(v) => Ok(v),
                        Err(_) => unreachable!(),
                    }
                } else {
                    Err(entry.key)
                }
            }
            Entry::Occupied(entry) => Ok(entry.into_mut()),
        }
    }

    /// Insert the value if vacant.  If the map is full, return the key, and the function is not executed.
    pub fn or_insert_with_key<F>(self, function: F) -> Result<&'a mut V, K>
    where
        F: FnOnce(&K) -> V,
    {
        match self {
            Entry::Vacant(entry) => {
                if entry.map.len < N {
                    let value = function(&entry.key);
                    match entry.insert(value) {
                        Ok(v) => Ok(v),
                        Err(_) => unreachable!(),
                    }
                } else {
                    Err(entry.key)
                }
            }
            Entry::Occupied(entry) => Ok(entry.into_mut()),
        }
    }
}