seq_set/
lib.rs

1use std::collections::HashSet;
2use std::hash::Hash;
3
4/// A Set collection that maintains a deterministic insertion order.
5#[derive(Debug, Clone)]
6pub struct SeqSet<T>
7where
8    T: Eq + Hash + Clone,
9{
10    set: HashSet<T>, // For O(1) existence checks
11    vec: Vec<T>,     // To maintain deterministic insertion order
12}
13
14impl<T> SeqSet<T>
15where
16    T: Eq + Hash + Clone,
17{
18    pub fn new() -> Self {
19        SeqSet {
20            set: HashSet::new(),
21            vec: Vec::new(),
22        }
23    }
24
25    /// Inserts a value into the set.
26    ///
27    /// Returns `true` if the value was not present in the set.
28    /// Returns `false` if the value was already present.
29    pub fn insert(&mut self, value: T) -> bool {
30        if self.set.insert(value.clone()) {
31            self.vec.push(value);
32            true
33        } else {
34            false
35        }
36    }
37
38    /// Checks if the set contains a value.
39    pub fn contains(&self, value: &T) -> bool {
40        self.set.contains(value)
41    }
42
43    /// Removes a value from the set.
44    ///
45    /// Returns `true` if the value was present and removed.
46    /// Returns `false` if the value was not present.
47    pub fn remove(&mut self, value: &T) -> bool {
48        if self.set.remove(value) {
49            // Find the position of the value in the Vec and remove it.
50            if let Some(pos) = self.vec.iter().position(|x| x == value) {
51                self.vec.remove(pos);
52            }
53            true
54        } else {
55            false
56        }
57    }
58
59    /// Returns the number of elements in the set.
60    pub fn len(&self) -> usize {
61        self.set.len()
62    }
63
64    /// Returns `true` if the set contains no elements.
65    pub fn is_empty(&self) -> bool {
66        self.set.is_empty()
67    }
68
69    /// Returns an iterator over the elements in insertion order.
70    pub fn iter(&self) -> SeqSetIter<'_, T> {
71        SeqSetIter {
72            inner: self.vec.iter(),
73        }
74    }
75
76    /// Returns a mutable iterator over the elements in insertion order.
77    pub fn iter_mut(&mut self) -> SeqSetIterMut<'_, T> {
78        SeqSetIterMut {
79            inner: self.vec.iter_mut(),
80        }
81    }
82
83    /// Clears all elements from the set.
84    pub fn clear(&mut self) {
85        self.set.clear();
86        self.vec.clear();
87    }
88
89    pub fn to_vec(&self) -> Vec<T> {
90        self.vec.clone()
91    }
92}
93
94pub struct SeqSetIter<'a, T>
95where
96    T: Eq + Hash + Clone,
97{
98    inner: std::slice::Iter<'a, T>,
99}
100
101impl<'a, T> Iterator for SeqSetIter<'a, T>
102where
103    T: Eq + Hash + Clone,
104{
105    type Item = &'a T;
106
107    fn next(&mut self) -> Option<Self::Item> {
108        self.inner.next()
109    }
110}
111
112impl<'a, T> IntoIterator for &'a SeqSet<T>
113where
114    T: Eq + Hash + Clone,
115{
116    type Item = &'a T;
117    type IntoIter = SeqSetIter<'a, T>;
118
119    fn into_iter(self) -> Self::IntoIter {
120        self.iter()
121    }
122}
123
124pub struct SeqSetIterMut<'a, T>
125where
126    T: Eq + Hash + Clone,
127{
128    inner: std::slice::IterMut<'a, T>,
129}
130
131impl<'a, T> Iterator for SeqSetIterMut<'a, T>
132where
133    T: Eq + Hash + Clone,
134{
135    type Item = &'a mut T;
136
137    fn next(&mut self) -> Option<Self::Item> {
138        self.inner.next()
139    }
140}
141
142impl<'a, T> IntoIterator for &'a mut SeqSet<T>
143where
144    T: Eq + Hash + Clone,
145{
146    type Item = &'a mut T;
147    type IntoIter = SeqSetIterMut<'a, T>;
148
149    fn into_iter(self) -> Self::IntoIter {
150        self.iter_mut()
151    }
152}
153
154pub struct SeqSetIntoIter<T>
155where
156    T: Eq + Hash + Clone,
157{
158    inner: std::vec::IntoIter<T>,
159}
160
161impl<T> Iterator for SeqSetIntoIter<T>
162where
163    T: Eq + Hash + Clone,
164{
165    type Item = T;
166
167    fn next(&mut self) -> Option<Self::Item> {
168        self.inner.next()
169    }
170}
171
172impl<T> IntoIterator for SeqSet<T>
173where
174    T: Eq + Hash + Clone,
175{
176    type Item = T;
177    type IntoIter = SeqSetIntoIter<T>;
178
179    fn into_iter(self) -> Self::IntoIter {
180        SeqSetIntoIter {
181            inner: self.vec.into_iter(),
182        }
183    }
184}
185
186
187impl<T> FromIterator<T> for SeqSet<T>
188where
189    T: Eq + Hash + Clone,
190{
191    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
192        let mut seq_set = SeqSet::new();
193        for item in iter {
194            seq_set.insert(item);
195        }
196        seq_set
197    }
198}
199
200impl<T> From<SeqSet<T>> for Vec<T>
201where
202    T: Eq + Hash + Clone,
203{
204    fn from(set: SeqSet<T>) -> Self {
205        set.vec
206    }
207}
seq_set/lib.rs

seq_set/
lib.rs
