pecos_core/sets/
vec_set.rs

1// Copyright 2024 The PECOS Developers
2//
3// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
4// in compliance with the License.You may obtain a copy of the License at
5//
6//     https://www.apache.org/licenses/LICENSE-2.0
7//
8// Unless required by applicable law or agreed to in writing, software distributed under the License
9// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
10// or implied. See the License for the specific language governing permissions and limitations under
11// the License.
12
13mod iterators;
14mod operators;
15mod set_impl;
16
17use crate::{Element, Set};
18use core::slice::Iter;
19
20#[derive(Clone, Debug)]
21pub struct VecSet<E: Element> {
22    elements: Vec<E>,
23}
24
25#[macro_export]
26macro_rules! vecset {
27    ($($x:expr),+ $(,)?) => {
28        {
29            let arr = [$($x),+];
30            VecSet::from(arr)
31        }
32    };
33}
34
35impl<E: Element, const N: usize> From<[E; N]> for VecSet<E> {
36    #[inline]
37    fn from(arr: [E; N]) -> Self {
38        Self::from_iter(arr)
39    }
40}
41
42impl<E: Element> FromIterator<E> for VecSet<E> {
43    #[inline]
44    fn from_iter<I: IntoIterator<Item = E>>(iter: I) -> Self {
45        let mut set = Self::new();
46        for item in iter {
47            set.insert(item);
48        }
49        set
50    }
51}
52
53impl<E: Element> VecSet<E> {
54    #[inline]
55    #[must_use]
56    pub fn new() -> Self {
57        Self::default()
58    }
59
60    #[inline]
61    pub fn iter(&self) -> Iter<'_, E> {
62        self.elements.iter()
63    }
64}
65
66impl<E: Element> Default for VecSet<E> {
67    #[inline]
68    fn default() -> Self {
69        Self {
70            elements: Vec::default(),
71        }
72    }
73}
74
75impl<'a, E: Element> IntoIterator for &'a VecSet<E> {
76    type Item = &'a E;
77    type IntoIter = Iter<'a, E>;
78
79    #[inline]
80    fn into_iter(self) -> Self::IntoIter {
81        self.iter()
82    }
83}
84
85#[cfg(test)]
86mod tests {
87    use super::super::set::Set;
88    use super::VecSet;
89
90    #[test]
91    fn test_new() {
92        let set = VecSet::<u32>::new();
93        assert!(set.elements.is_empty());
94    }
95
96    #[test]
97    fn test_with_capacity() {
98        let set = VecSet::<u32>::with_capacity(10);
99        assert!(set.elements.is_empty());
100        assert_eq!(set.capacity(), 10);
101    }
102
103    #[test]
104    fn test_new_with_vec() {
105        let set: VecSet<usize> = vec![4, 5, 6, 4].into_iter().collect();
106        assert_eq!(set.elements, vec![4, 5, 6]);
107    }
108
109    #[test]
110    fn test_new_from() {
111        let set = VecSet::<u32>::from([4, 5, 6, 4]);
112        assert_eq!(set.elements, vec![4, 5, 6]);
113    }
114
115    #[test]
116    fn test_insert() {
117        let mut set = VecSet::<u32>::new();
118        set.insert(1);
119        assert_eq!(set.elements, vec![1]);
120        set.insert(5);
121        set.insert(1);
122        assert_eq!(set.elements, vec![1, 5]);
123    }
124
125    #[test]
126    fn test_remove() {
127        let mut set: VecSet<u8> = VecSet::from([4, 5, 6, 4]);
128        set.remove(&5);
129        assert_eq!(set.elements, vec![4, 6]);
130        set.remove(&7);
131        assert_eq!(set.elements, vec![4, 6]);
132    }
133
134    #[test]
135    fn test_union() {
136        let mut set_a: VecSet<u8> = VecSet::from([1, 2]);
137        let set_b = VecSet::from([2, 3]);
138        set_a.union_update(&set_b);
139        assert_eq!(set_a.elements, vec![1, 2, 3]);
140    }
141
142    #[test]
143    fn test_symmetric_difference_update() {
144        let mut set_a = VecSet::<u32>::from([4, 5, 6, 4]);
145        let set_b = VecSet::<u32>::from([1, 3, 4]);
146        set_a.symmetric_difference_update(&set_b);
147        assert_eq!(set_a.elements, vec![5, 6, 1, 3]);
148    }
149
150    #[test]
151    fn test_intersection_update() {
152        let mut set_a: VecSet<u8> = VecSet::from([1, 2, 3]);
153        let set_b = VecSet::from([2, 3, 4]);
154        set_a.intersection_update(&set_b);
155        assert_eq!(set_a.elements, vec![2, 3]);
156    }
157
158    #[test]
159    fn test_intersection() {
160        let set_a: VecSet<u8> = VecSet::from([1, 2, 3]);
161        let set_b = VecSet::from([2, 3, 4]);
162        let intersection: Vec<_> = set_a.intersection(&set_b).copied().collect();
163        assert_eq!(intersection, vec![2, 3]);
164    }
165
166    #[test]
167    fn test_symmetric_difference() {
168        let set_a = VecSet::<u32>::from([4, 5, 6, 4]);
169        let set_b = VecSet::<u32>::from([1, 3, 4]);
170        let sym_diff: Vec<_> = set_a.symmetric_difference(&set_b).copied().collect();
171        assert_eq!(sym_diff, vec![5, 6, 1, 3]);
172    }
173
174    #[test]
175    fn test_bitor_assign() {
176        let mut set_a: VecSet<u8> = VecSet::from([1, 2]);
177        let set_b: VecSet<u8> = VecSet::from([2, 3]);
178        set_a |= &set_b;
179        assert_eq!(set_a.elements, vec![1, 2, 3]);
180    }
181
182    #[test]
183    fn test_bitxor_assign() {
184        let mut set_a: VecSet<u8> = VecSet::from([1, 2, 3]);
185        let set_b: VecSet<u8> = VecSet::from([2, 3, 4]);
186        set_a ^= &set_b;
187        assert_eq!(set_a.elements, vec![1, 4]);
188    }
189
190    #[test]
191    fn test_bitand_assign() {
192        let mut set_a: VecSet<u8> = VecSet::from([1, 2, 3]);
193        let set_b = VecSet::from([2, 3, 4]);
194        set_a &= &set_b;
195        assert_eq!(set_a.elements, vec![2, 3]);
196    }
197
198    #[test]
199    fn test_bitand_assign_single_element_ref() {
200        let mut set_a: VecSet<u8> = VecSet::from([1, 2, 3]);
201        let element: u8 = 2;
202        set_a &= &element;
203        assert_eq!(set_a.elements, vec![2]);
204
205        let mut set_b: VecSet<u8> = VecSet::from([1, 2, 3]);
206        let non_existing_element: u8 = 4;
207        set_b &= &non_existing_element;
208        assert_eq!(set_b.elements, Vec::<u8>::new());
209    }
210
211    #[test]
212    fn test_difference() {
213        let set_a: VecSet<u8> = VecSet::from([1, 2, 3]);
214        let set_b = VecSet::from([2, 3, 4]);
215        let diff: Vec<_> = set_a.difference(&set_b).copied().collect();
216        assert_eq!(diff, vec![1]);
217    }
218
219    #[test]
220    fn test_capacity() {
221        let mut set = VecSet::<u32>::with_capacity(10);
222        assert_eq!(set.capacity(), 10);
223        set.insert(1);
224        assert!(set.capacity() >= 1);
225    }
226
227    #[test]
228    fn test_clear() {
229        let mut set = VecSet::<u32>::from([1, 2, 3]);
230        assert!(!set.is_empty());
231        set.clear();
232        assert!(set.is_empty());
233    }
234
235    #[test]
236    fn test_symmetric_difference_item_update() {
237        let mut set = VecSet::<u32>::from([1, 2, 3]);
238        set.symmetric_difference_item_update(&2);
239        assert_eq!(set.elements, vec![1, 3]);
240        set.symmetric_difference_item_update(&4);
241        assert_eq!(set.elements, vec![1, 3, 4]);
242    }
243
244    #[test]
245    fn test_union_item_update() {
246        let mut set = VecSet::<u32>::from([1, 2, 3]);
247        set.union_item_update(&4);
248        assert_eq!(set.elements, vec![1, 2, 3, 4]);
249    }
250
251    #[test]
252    fn test_sub_ref() {
253        let set_a: VecSet<u8> = VecSet::from([1, 2, 3]);
254        let set_b: VecSet<u8> = VecSet::from([2, 3, 4]);
255        let difference: Vec<_> = set_a.difference_ref(&set_b).copied().collect();
256        assert_eq!(difference, vec![1]);
257    }
258
259    #[test]
260    fn test_a_xor_b_sub_c() {
261        let mut set_a: VecSet<u8> = VecSet::from([1, 2, 3, 4, 5]);
262        let set_b: VecSet<u8> = VecSet::from([2, 3, 6]);
263        let set_c: VecSet<u8> = VecSet::from([3]);
264        set_a ^= set_b.difference(&set_c).copied().collect::<VecSet<_>>();
265        assert_eq!(set_a.elements, vec![1, 3, 4, 5, 6]);
266    }
267
268    #[test]
269    fn test_a_xor_b_sub_c_glyphs() {
270        let mut set_a: VecSet<u8> = VecSet::from([1, 2, 3, 4, 5]);
271        let set_b: VecSet<u8> = VecSet::from([2, 3, 6]);
272        let set_c: VecSet<u8> = VecSet::from([3]);
273        set_a ^= &set_b - &set_c; // TODO: Get this to work for Set
274        assert_eq!(set_a.elements, vec![1, 3, 4, 5, 6]);
275    }
276}
pecos_core/sets/vec_set.rs

pecos_core/sets/
vec_set.rs
