read_fonts/collections/int_set/
mod.rs

1//! A fast, efficient, sparse, & ordered unsigned integer (u32) bit set which is invertible.
2//!
3//! The bitset is implemented using fixed size pages which allows it to compactly
4//! represent sparse membership. However, the set excels when set members are typically
5//! clustered together. For example when representing glyph id or unicode codepoint values
6//! in a font.
7//!
8//! The set can have inclusive (the set of integers which are members) or
9//! exclusive (the set of integers which are not members) membership. The
10//! exclusive/inverted version of the set is useful for patterns such as
11//! "keep all codepoints except for {x, y, z, ...}".
12//!
13//! When constructing a new [`IntSet`] from an existing lists of integer values the most efficient
14//! way to create the set is to initialize it from a sorted (ascending) iterator of the values.
15//!
16//! For a type to be stored in the [`IntSet`] it must implement the [`Domain`] trait, and all
17//! unique values of that type must be able to be mapped to and from a unique `u32` value.
18//! See the [`Domain`] trait for more information.
19
20mod bitpage;
21mod bitset;
22mod input_bit_stream;
23mod output_bit_stream;
24pub mod sparse_bit_set;
25
26pub use bitset::U32Set;
27use core::ops::{Bound, RangeBounds};
28use font_types::{GlyphId, GlyphId16, NameId, Tag};
29use std::hash::Hash;
30use std::marker::PhantomData;
31use std::ops::RangeInclusive;
32use std::{
33    cmp::Ordering,
34    fmt::{Debug, Display},
35};
36
37/// A fast & efficient invertible ordered set for small (up to 32-bit) unsigned integer types.
38#[derive(Clone)]
39pub struct IntSet<T>(Membership, PhantomData<T>);
40
41/// Defines the domain of `IntSet` member types.
42///
43/// Members of `IntSet` must implement this trait. Members of `IntSet`'s must meet the following
44/// conditions to be used in an `IntSet`:
45///
46/// 1. Every possible unique value of `T` must be able map to and from a unique `u32`
47///    integer.
48///
49/// 2. The mapped `u32` values must retain the same ordering as the values in `T`.
50///
51/// 3. `ordered_values`() must iterate over all values in `T` in sorted order (ascending).
52///
53/// `from_u32`() will only ever be called with u32 values that are part of the domain of T as defined
54/// by an implementation of this trait. So it doesn't need to correctly handle values
55/// that are outside the domain of `T`.
56pub trait Domain: Sized + Copy {
57    /// Converts this value of `T` to a value in u32.
58    ///
59    /// The mapped value must maintain the same ordering as `T`.
60    fn to_u32(&self) -> u32;
61
62    /// Returns `true` if the value is part of this domain.
63    fn contains(value: u32) -> bool;
64
65    /// Converts a mapped u32 value back to T.
66    ///
67    /// Will only ever be called with values produced by `to_u32`.
68    fn from_u32(member: InDomain) -> Self;
69
70    /// Returns true if all u32 values between the mapped u32 min and mapped u32 max value of T are used.
71    fn is_continuous() -> bool;
72
73    /// Returns an iterator which iterates over all values in the domain of `T`
74    ///
75    /// Values should be converted to `u32`'s according to the mapping defined in
76    /// `to_u32`/`from_u32`.
77    fn ordered_values() -> impl DoubleEndedIterator<Item = u32>;
78
79    /// Return an iterator which iterates over all values of T in the given range.
80    ///
81    /// Values should be converted to `u32`'s according to the mapping defined in
82    /// `to_u32`/`from_u32`.
83    fn ordered_values_range(range: RangeInclusive<Self>) -> impl DoubleEndedIterator<Item = u32>;
84
85    /// Returns the number of members in the domain.
86    fn count() -> u64;
87}
88
89/// Marks a mapped value as being in the domain of `T` for [`Domain`].
90///
91/// See [`Domain`] for more information.
92pub struct InDomain(u32);
93
94#[derive(Clone, Debug, Hash, PartialEq, Eq)]
95#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
96enum Membership {
97    /// Records a set of integers which are members of the set.
98    Inclusive(U32Set),
99
100    /// Records the set of integers which are not members of the set.
101    Exclusive(U32Set),
102}
103
104impl InDomain {
105    pub fn value(&self) -> u32 {
106        self.0
107    }
108}
109
110impl<T> Default for IntSet<T> {
111    fn default() -> IntSet<T> {
112        IntSet::empty()
113    }
114}
115
116impl<T: Domain> IntSet<T> {
117    /// Returns an iterator over all members of the set in sorted ascending order.
118    ///
119    /// Note: iteration of inverted sets can be extremely slow due to the very large number of members in the set
120    /// care should be taken when using `.iter()` in combination with an inverted set.
121    pub fn iter(&self) -> impl DoubleEndedIterator<Item = T> + '_ {
122        let u32_iter = match &self.0 {
123            Membership::Inclusive(s) => Iter::new_bidirectional(s.iter(), None),
124            Membership::Exclusive(s) => {
125                Iter::new_bidirectional(s.iter(), Some(T::ordered_values()))
126            }
127        };
128        u32_iter.map(|v| T::from_u32(InDomain(v)))
129    }
130
131    /// If this is an inclusive membership set then returns an iterator over the members, otherwise returns `None`.
132    pub fn inclusive_iter(&self) -> Option<impl DoubleEndedIterator<Item = T> + '_> {
133        match &self.0 {
134            Membership::Inclusive(s) => Some(s.iter().map(|v| T::from_u32(InDomain(v)))),
135            Membership::Exclusive(_) => None,
136        }
137    }
138
139    fn iter_from_u32(&self, value: T) -> impl Iterator<Item = u32> + '_ {
140        match &self.0 {
141            Membership::Inclusive(s) => Iter::new(s.iter_from(value.to_u32()), None),
142            Membership::Exclusive(s) => {
143                let value_u32 = value.to_u32();
144                let max = T::ordered_values().next_back();
145                let it = max.map(|max| T::ordered_values_range(value..=T::from_u32(InDomain(max))));
146                let min = it.and_then(|mut it| it.next());
147
148                if let (Some(min), Some(max)) = (min, max) {
149                    Iter::new(
150                        s.iter_from(value_u32),
151                        Some(T::ordered_values_range(
152                            T::from_u32(InDomain(min))..=T::from_u32(InDomain(max)),
153                        )),
154                    )
155                } else {
156                    // either min or max doesn't exist, so just return an iterator that has no values.
157                    let mut it = Iter::new(s.iter_from(u32::MAX), None);
158                    it.next();
159                    it
160                }
161            }
162        }
163    }
164
165    /// Returns an iterator over the members of this set that are after `value` in ascending order.
166    ///
167    /// Note: iteration of inverted sets can be extremely slow due to the very large number of members in the set
168    /// care should be taken when using `.iter()` in combination with an inverted set.
169    pub fn iter_after(&self, value: T) -> impl Iterator<Item = T> + '_ {
170        self.range((Bound::Excluded(value), Bound::Unbounded))
171    }
172
173    /// Returns an iterator over members of this set that are in `range`.
174    pub fn range<R: RangeBounds<T>>(&self, range: R) -> impl Iterator<Item = T> + '_ {
175        let mut it = match range.start_bound() {
176            Bound::Included(start) | Bound::Excluded(start) => {
177                self.iter_from_u32(*start).peekable()
178            }
179            Bound::Unbounded => {
180                let min = T::from_u32(InDomain(T::ordered_values().next().unwrap()));
181                self.iter_from_u32(min).peekable()
182            }
183        };
184
185        if let Bound::Excluded(start) = range.start_bound() {
186            it.next_if_eq(&start.to_u32());
187        }
188
189        let range_end = range.end_bound().cloned();
190        it.take_while(move |v| match range_end {
191            Bound::Included(end) => *v <= end.to_u32(),
192            Bound::Excluded(end) => *v < end.to_u32(),
193            Bound::Unbounded => true,
194        })
195        .map(move |v| T::from_u32(InDomain(v)))
196    }
197
198    /// Returns an iterator over all disjoint ranges of values within the set in sorted ascending order.
199    pub fn iter_ranges(&self) -> impl Iterator<Item = RangeInclusive<T>> + '_ {
200        self.iter_ranges_invertible(false)
201    }
202
203    /// Returns an iterator over all disjoint ranges of values not within the set in sorted ascending order.
204    pub fn iter_excluded_ranges(&self) -> impl Iterator<Item = RangeInclusive<T>> + '_ {
205        self.iter_ranges_invertible(true)
206    }
207
208    fn iter_ranges_invertible(
209        &self,
210        inverted: bool,
211    ) -> impl Iterator<Item = RangeInclusive<T>> + '_ {
212        let u32_iter = match (&self.0, inverted) {
213            (Membership::Inclusive(s), false) | (Membership::Exclusive(s), true)
214                if T::is_continuous() =>
215            {
216                RangeIter::Inclusive::<_, _, T> {
217                    ranges: s.iter_ranges(),
218                }
219            }
220            (Membership::Inclusive(s), false) | (Membership::Exclusive(s), true) => {
221                RangeIter::InclusiveDiscontinuous::<_, _, T> {
222                    ranges: s.iter_ranges(),
223                    current_range: None,
224                    phantom: PhantomData::<T>,
225                }
226            }
227            (Membership::Exclusive(s), false) | (Membership::Inclusive(s), true)
228                if T::is_continuous() =>
229            {
230                RangeIter::Exclusive::<_, _, T> {
231                    ranges: s.iter_ranges(),
232                    min: T::ordered_values().next().unwrap(),
233                    max: T::ordered_values().next_back().unwrap(),
234                    done: false,
235                }
236            }
237            (Membership::Exclusive(s), false) | (Membership::Inclusive(s), true) => {
238                RangeIter::ExclusiveDiscontinuous::<_, _, T> {
239                    all_values: Some(T::ordered_values()),
240                    set: s,
241                    next_value: None,
242                }
243            }
244        };
245
246        u32_iter.map(|r| T::from_u32(InDomain(*r.start()))..=T::from_u32(InDomain(*r.end())))
247    }
248
249    /// Adds a value to the set.
250    ///
251    /// Returns `true` if the value was newly inserted.
252    pub fn insert(&mut self, val: T) -> bool {
253        let val = val.to_u32();
254        match &mut self.0 {
255            Membership::Inclusive(s) => s.insert(val),
256            Membership::Exclusive(s) => s.remove(val),
257        }
258    }
259
260    /// Add all values in range as members of this set.
261    pub fn insert_range(&mut self, range: RangeInclusive<T>) {
262        if T::is_continuous() {
263            let range = range.start().to_u32()..=range.end().to_u32();
264            match &mut self.0 {
265                Membership::Inclusive(s) => s.insert_range(range),
266                Membership::Exclusive(s) => s.remove_range(range),
267            }
268        } else {
269            let range = T::ordered_values_range(range);
270            match &mut self.0 {
271                Membership::Inclusive(s) => s.extend(range),
272                Membership::Exclusive(s) => s.remove_all(range),
273            }
274        }
275    }
276
277    /// An alternate version of [`extend()`] which is optimized for inserting an unsorted iterator of values.
278    ///
279    /// [`extend()`]: Self::extend
280    pub fn extend_unsorted<U: IntoIterator<Item = T>>(&mut self, iter: U) {
281        let iter = iter.into_iter().map(|v| v.to_u32());
282        match &mut self.0 {
283            Membership::Inclusive(s) => s.extend_unsorted(iter),
284            Membership::Exclusive(s) => s.remove_all(iter),
285        }
286    }
287
288    /// Removes a value from the set. Returns whether the value was present in the set.
289    pub fn remove(&mut self, val: T) -> bool {
290        let val = val.to_u32();
291        match &mut self.0 {
292            Membership::Inclusive(s) => s.remove(val),
293            Membership::Exclusive(s) => s.insert(val),
294        }
295    }
296
297    // Removes all values in iter from the set.
298    pub fn remove_all<U: IntoIterator<Item = T>>(&mut self, iter: U) {
299        let iter = iter.into_iter().map(|v| v.to_u32());
300        match &mut self.0 {
301            Membership::Inclusive(s) => s.remove_all(iter),
302            Membership::Exclusive(s) => s.extend(iter),
303        }
304    }
305
306    /// Removes all values in range as members of this set.
307    pub fn remove_range(&mut self, range: RangeInclusive<T>) {
308        if T::is_continuous() {
309            let range = range.start().to_u32()..=range.end().to_u32();
310            match &mut self.0 {
311                Membership::Inclusive(s) => s.remove_range(range),
312                Membership::Exclusive(s) => s.insert_range(range),
313            }
314        } else {
315            let range = T::ordered_values_range(range);
316            match &mut self.0 {
317                Membership::Inclusive(s) => s.remove_all(range),
318                Membership::Exclusive(s) => s.extend(range),
319            }
320        }
321    }
322
323    /// Sets the members of this set to the union of self and other.
324    pub fn union(&mut self, other: &IntSet<T>) {
325        match (&mut self.0, &other.0) {
326            (Membership::Inclusive(a), Membership::Inclusive(b)) => a.union(b),
327            (Membership::Inclusive(a), Membership::Exclusive(b)) => {
328                a.reversed_subtract(b);
329                self.invert();
330            }
331            (Membership::Exclusive(a), Membership::Inclusive(b)) => a.subtract(b),
332            (Membership::Exclusive(a), Membership::Exclusive(b)) => a.intersect(b),
333        }
334    }
335
336    /// Sets the members of this set to the intersection of self and other.
337    pub fn intersect(&mut self, other: &IntSet<T>) {
338        match (&mut self.0, &other.0) {
339            (Membership::Inclusive(a), Membership::Inclusive(b)) => a.intersect(b),
340            (Membership::Inclusive(a), Membership::Exclusive(b)) => a.subtract(b),
341            (Membership::Exclusive(a), Membership::Inclusive(b)) => {
342                a.reversed_subtract(b);
343                self.invert();
344            }
345            (Membership::Exclusive(a), Membership::Exclusive(b)) => a.union(b),
346        }
347    }
348
349    /// Sets the members of this set to self - other.
350    pub fn subtract(&mut self, other: &IntSet<T>) {
351        match (&mut self.0, &other.0) {
352            (Membership::Inclusive(a), Membership::Inclusive(b)) => a.subtract(b),
353            (Membership::Inclusive(a), Membership::Exclusive(b)) => a.intersect(b),
354            (Membership::Exclusive(a), Membership::Inclusive(b)) => a.union(b),
355            (Membership::Exclusive(a), Membership::Exclusive(b)) => {
356                a.reversed_subtract(b);
357                self.invert();
358            }
359        }
360    }
361
362    /// Returns true if this set contains at least one element in 'range'.
363    pub fn intersects_range(&self, range: RangeInclusive<T>) -> bool {
364        self.range(range).next().is_some()
365    }
366
367    /// Returns true if this set contains at least one element in 'other'.
368    pub fn intersects_set(&self, other: &IntSet<T>) -> bool {
369        // Iterate the smaller set and check for member ship in the larger set
370        // Estimate the true size as the number of pages.
371        let (a, b) = match (&self.0, &other.0) {
372            (Membership::Inclusive(us), Membership::Inclusive(them)) => {
373                // Can utilize the bitset intersects method.
374                return us.intersects_set(them);
375            }
376
377            (
378                Membership::Inclusive(us) | Membership::Exclusive(us),
379                Membership::Inclusive(them) | Membership::Exclusive(them),
380            ) => {
381                if us.num_pages() > them.num_pages() {
382                    (self, other)
383                } else {
384                    (other, self)
385                }
386            }
387        };
388
389        for range in b.iter_ranges() {
390            if a.intersects_range(range) {
391                return true;
392            }
393        }
394        false
395    }
396
397    /// Returns first element in the set, if any. This element is always the minimum of all elements in the set.
398    pub fn first(&self) -> Option<T> {
399        return self.iter().next();
400    }
401
402    /// Returns the last element in the set, if any. This element is always the maximum of all elements in the set.
403    pub fn last(&self) -> Option<T> {
404        return self.iter().next_back();
405    }
406
407    /// Returns `true` if the set contains a value.
408    pub fn contains(&self, val: T) -> bool {
409        let val = val.to_u32();
410        match &self.0 {
411            Membership::Inclusive(s) => s.contains(val),
412            Membership::Exclusive(s) => !s.contains(val),
413        }
414    }
415
416    /// Returns the number of members in this set.
417    pub fn len(&self) -> u64 {
418        match &self.0 {
419            Membership::Inclusive(s) => s.len(),
420            Membership::Exclusive(s) => T::count() - s.len(),
421        }
422    }
423
424    /// Return true if there are no members in this set.
425    pub fn is_empty(&self) -> bool {
426        self.len() == 0
427    }
428}
429
430impl IntSet<u32> {
431    pub(crate) fn from_bitset(set: U32Set) -> IntSet<u32> {
432        IntSet(Membership::Inclusive(set), PhantomData::<u32>)
433    }
434}
435
436impl<T> IntSet<T> {
437    /// Create a new, (empty) `IntSet`.
438    ///
439    /// You can create a new full set with [`IntSet::all`].
440    pub const fn new() -> Self {
441        Self::empty()
442    }
443
444    /// Create a new empty set (inclusive).
445    pub const fn empty() -> Self {
446        IntSet(Membership::Inclusive(U32Set::empty()), PhantomData::<T>)
447    }
448
449    /// Create a new set which contains all integers (exclusive).
450    pub const fn all() -> Self {
451        IntSet(Membership::Exclusive(U32Set::empty()), PhantomData::<T>)
452    }
453
454    /// Returns true if this set is inverted (has exclusive membership).
455    pub fn is_inverted(&self) -> bool {
456        match &self.0 {
457            Membership::Inclusive(_) => false,
458            Membership::Exclusive(_) => true,
459        }
460    }
461
462    /// Return the inverted version of this set.
463    pub fn invert(&mut self) {
464        let reuse_storage = match &mut self.0 {
465            // take the existing storage to reuse in a new set of the opposite
466            // type.
467            Membership::Inclusive(s) | Membership::Exclusive(s) => {
468                std::mem::replace(s, U32Set::empty())
469            }
470        };
471
472        // reuse the storage with a membership of the opposite type.
473        self.0 = match &mut self.0 {
474            Membership::Inclusive(_) => Membership::Exclusive(reuse_storage),
475            Membership::Exclusive(_) => Membership::Inclusive(reuse_storage),
476        };
477    }
478
479    /// Clears the set, removing all values.
480    pub fn clear(&mut self) {
481        let mut reuse_storage = match &mut self.0 {
482            // if we're inclusive, we just clear the storage
483            Membership::Inclusive(s) => {
484                s.clear();
485                return;
486            }
487            // otherwise take the existing storage to reuse in a new
488            // inclusive set:
489            Membership::Exclusive(s) => std::mem::replace(s, U32Set::empty()),
490        };
491        // reuse the now empty storage and mark us as inclusive
492        reuse_storage.clear();
493        self.0 = Membership::Inclusive(reuse_storage);
494    }
495}
496
497impl<T: Domain> FromIterator<T> for IntSet<T> {
498    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
499        let mut s = IntSet::empty();
500        s.extend(iter);
501        s
502    }
503}
504
505impl<T: Domain> Extend<T> for IntSet<T> {
506    /// Extends a collection with the contents of an iterator.
507    ///
508    /// This implementation is optimized to provide the best performance when the iterator contains sorted values.
509    /// Consider using [`extend_unsorted()`] if the iterator is known to contain unsorted values.
510    ///
511    /// [`extend_unsorted()`]: IntSet::extend_unsorted
512    fn extend<U: IntoIterator<Item = T>>(&mut self, iter: U) {
513        let iter = iter.into_iter().map(|v| v.to_u32());
514        match &mut self.0 {
515            Membership::Inclusive(s) => s.extend(iter),
516            Membership::Exclusive(s) => s.remove_all(iter),
517        }
518    }
519}
520
521impl<T: Domain> PartialEq for IntSet<T> {
522    fn eq(&self, other: &Self) -> bool {
523        match (&self.0, &other.0) {
524            (Membership::Inclusive(a), Membership::Inclusive(b)) => a == b,
525            (Membership::Exclusive(a), Membership::Exclusive(b)) => a == b,
526            (Membership::Inclusive(_), Membership::Exclusive(_))
527            | (Membership::Exclusive(_), Membership::Inclusive(_)) => {
528                // while these sets have different membership modes, they can still be equal if they happen to have
529                // the same effective set of members. In this case fallback to checking via iterator equality.
530                // iter_ranges() is used instead of iter() because for exclusive sets it's likely to be significantly
531                // faster and have far less items.
532                if self.len() == other.len() {
533                    let r = self
534                        .iter_ranges()
535                        .map(|r| r.start().to_u32()..=r.end().to_u32())
536                        .eq(other
537                            .iter_ranges()
538                            .map(|r| r.start().to_u32()..=r.end().to_u32()));
539                    r
540                } else {
541                    // Shortcut iteration equality check if lengths aren't the same.
542                    false
543                }
544            }
545        }
546    }
547}
548
549impl<T: Domain> Hash for IntSet<T> {
550    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
551        // Because equality considers two sets with the same effective members (but different membership modes) as
552        // equal, hash must be based on the effective member set as well. Exclusive sets may have extremely large numbers
553        // of effective members, so here we use iter_ranges() to produce the hash, which should typically produce a more
554        // reasonable numbers elements.
555        self.iter_ranges()
556            .map(|r| r.start().to_u32()..=r.end().to_u32())
557            .for_each(|r| r.hash(state));
558    }
559}
560
561impl<T: Domain + Ord> Ord for IntSet<T> {
562    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
563        match (&self.0, &other.0) {
564            (Membership::Inclusive(a), Membership::Inclusive(b)) => a.cmp(b),
565            _ => {
566                let mut this = self
567                    .iter_ranges()
568                    .map(|r| r.start().to_u32()..=r.end().to_u32());
569                let mut other = other
570                    .iter_ranges()
571                    .map(|r| r.start().to_u32()..=r.end().to_u32());
572                loop {
573                    match (this.next(), other.next()) {
574                        (Some(a), Some(b)) => {
575                            let cmp = a.start().cmp(b.start());
576                            if cmp != Ordering::Equal {
577                                return cmp;
578                            }
579
580                            match a.end().cmp(b.end()) {
581                                Ordering::Equal => continue,
582                                // If a range isn't equal then there are two possible scenarios:
583                                // 1. The set with the shorter range has at least one more range.
584                                //    In this case the set with the shorter range's next element will always be bigger
585                                //    then the other set's next element and should be considered greater.
586                                // 2. The set with the shorter range does not have anymore ranges, in that case we
587                                //    know the other set has at least one more element and thus should be considered greater.
588                                Ordering::Less => {
589                                    return if this.next().is_some() {
590                                        Ordering::Greater
591                                    } else {
592                                        Ordering::Less
593                                    };
594                                }
595                                Ordering::Greater => {
596                                    return if other.next().is_some() {
597                                        Ordering::Less
598                                    } else {
599                                        Ordering::Greater
600                                    };
601                                }
602                            }
603                        }
604                        (None, None) => return Ordering::Equal,
605                        (None, Some(_)) => return Ordering::Less,
606                        (Some(_), None) => return Ordering::Greater,
607                    }
608                }
609            }
610        }
611    }
612}
613
614impl<T: Domain + Ord> PartialOrd for IntSet<T> {
615    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
616        Some(self.cmp(other))
617    }
618}
619
620impl<T: Domain> Eq for IntSet<T> {}
621
622impl<T: Domain, const N: usize> From<[T; N]> for IntSet<T> {
623    fn from(value: [T; N]) -> Self {
624        value.into_iter().collect()
625    }
626}
627
628impl<T: Domain + Debug> Debug for IntSet<T> {
629    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
630        f.debug_set().entries(self.iter()).finish()
631    }
632}
633
634impl<T> Display for IntSet<T>
635where
636    T: Domain + Display,
637{
638    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
639        let mut ranges = self.iter_ranges().peekable();
640        write!(f, "{{ ")?;
641        while let Some(range) = ranges.next() {
642            write!(f, "{}..={}", range.start(), range.end())?;
643            if ranges.peek().is_some() {
644                write!(f, ", ")?;
645            }
646        }
647        write!(f, "}}")
648    }
649}
650
651#[cfg(feature = "serde")]
652impl<T: Domain> serde::Serialize for IntSet<T> {
653    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
654        self.0.serialize(serializer)
655    }
656}
657
658#[cfg(feature = "serde")]
659impl<'de, T: Domain> serde::Deserialize<'de> for IntSet<T> {
660    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
661    where
662        D: serde::Deserializer<'de>,
663    {
664        let members = Membership::deserialize(deserializer)?;
665        let bits = match &members {
666            Membership::Inclusive(bit_set) => bit_set,
667            Membership::Exclusive(bit_set) => bit_set,
668        };
669
670        if let Some(bad) = bits.iter().find(|val| !T::contains(*val)) {
671            return Err(serde::de::Error::custom(format!(
672                "value '{bad}' out of range for domain {}",
673                std::any::type_name::<T>(),
674            )));
675        }
676        Ok(IntSet(members, PhantomData))
677    }
678}
679
680struct Iter<SetIter, AllValuesIter> {
681    set_values: SetIter,
682    all_values: Option<AllValuesIter>,
683    next_skipped_forward: Option<u32>,
684    next_skipped_backward: Option<u32>,
685}
686
687impl<SetIter, AllValuesIter> Iter<SetIter, AllValuesIter>
688where
689    SetIter: Iterator<Item = u32>,
690    AllValuesIter: Iterator<Item = u32>,
691{
692    fn new(
693        mut set_values: SetIter,
694        all_values: Option<AllValuesIter>,
695    ) -> Iter<SetIter, AllValuesIter> {
696        match all_values {
697            Some(_) => Iter {
698                next_skipped_forward: set_values.next(),
699                next_skipped_backward: None,
700                set_values,
701                all_values,
702            },
703            None => Iter {
704                next_skipped_forward: None,
705                next_skipped_backward: None,
706                set_values,
707                all_values,
708            },
709        }
710    }
711}
712
713impl<SetIter, AllValuesIter> Iter<SetIter, AllValuesIter>
714where
715    SetIter: DoubleEndedIterator<Item = u32>,
716    AllValuesIter: DoubleEndedIterator<Item = u32>,
717{
718    fn new_bidirectional(
719        mut set_values: SetIter,
720        all_values: Option<AllValuesIter>,
721    ) -> Iter<SetIter, AllValuesIter> {
722        match all_values {
723            Some(_) => Iter {
724                next_skipped_forward: set_values.next(),
725                next_skipped_backward: set_values.next_back(),
726                set_values,
727                all_values,
728            },
729            None => Iter {
730                set_values,
731                all_values,
732                next_skipped_forward: None,
733                next_skipped_backward: None,
734            },
735        }
736    }
737}
738
739impl<SetIter, AllValuesIter> Iterator for Iter<SetIter, AllValuesIter>
740where
741    SetIter: Iterator<Item = u32>,
742    AllValuesIter: Iterator<Item = u32>,
743{
744    type Item = u32;
745
746    fn next(&mut self) -> Option<u32> {
747        let Some(all_values_it) = &mut self.all_values else {
748            return self.set_values.next();
749        };
750
751        for index in all_values_it.by_ref() {
752            let index = index.to_u32();
753            loop {
754                let Some(skip) = self.next_skipped_forward else {
755                    // There are no skips left in the iterator, but there may still be a skipped
756                    // number on the backwards iteration, so check that.
757                    if let Some(skip) = self.next_skipped_backward {
758                        if skip == index {
759                            // this index should be skipped, go to the next one.
760                            break;
761                        }
762                    }
763                    // No-longer any values to skip, can freely return index
764                    return Some(index);
765                };
766
767                if index < skip {
768                    // Not a skipped value
769                    return Some(index);
770                }
771
772                self.next_skipped_forward = self.set_values.next();
773                if index > skip {
774                    // We've passed the skip value, need to check the next one.
775                    continue;
776                }
777
778                // index == skip, so we need to skip this index.
779                break;
780            }
781        }
782        None
783    }
784}
785
786impl<SetIter, AllValuesIter> DoubleEndedIterator for Iter<SetIter, AllValuesIter>
787where
788    SetIter: DoubleEndedIterator<Item = u32>,
789    AllValuesIter: DoubleEndedIterator<Item = u32>,
790{
791    fn next_back(&mut self) -> Option<Self::Item> {
792        let Some(all_values_it) = &mut self.all_values else {
793            return self.set_values.next_back();
794        };
795
796        for index in all_values_it.by_ref().rev() {
797            let index = index.to_u32();
798            loop {
799                let Some(skip) = self.next_skipped_backward else {
800                    // There are no skips left in the iterator, but there may still be a skipped
801                    // number on the backwards iteration, so check that.
802                    if let Some(skip) = self.next_skipped_forward {
803                        if skip == index {
804                            // this index should be skipped, go to the next one.
805                            break;
806                        }
807                    }
808                    // No-longer any values to skip, can freely return index
809                    return Some(index);
810                };
811
812                if index > skip {
813                    // Not a skipped value
814                    return Some(index);
815                }
816
817                self.next_skipped_backward = self.set_values.next_back();
818                if index < skip {
819                    // We've passed the skip value, need to check the next one.
820                    continue;
821                }
822
823                // index == skip, so we need to skip this index.
824                break;
825            }
826        }
827        None
828    }
829}
830
831enum RangeIter<'a, InclusiveRangeIter, AllValuesIter, T>
832where
833    InclusiveRangeIter: Iterator<Item = RangeInclusive<u32>>,
834    AllValuesIter: Iterator<Item = u32>,
835    T: Domain,
836{
837    Inclusive {
838        ranges: InclusiveRangeIter,
839    },
840    InclusiveDiscontinuous {
841        ranges: InclusiveRangeIter,
842        current_range: Option<RangeInclusive<u32>>,
843        phantom: PhantomData<T>,
844    },
845    Exclusive {
846        ranges: InclusiveRangeIter,
847        min: u32,
848        max: u32,
849        done: bool,
850    },
851    ExclusiveDiscontinuous {
852        all_values: Option<AllValuesIter>,
853        set: &'a U32Set,
854        next_value: Option<u32>,
855    },
856}
857
858impl<InclusiveRangeIter, AllValuesIter, T> Iterator
859    for RangeIter<'_, InclusiveRangeIter, AllValuesIter, T>
860where
861    InclusiveRangeIter: Iterator<Item = RangeInclusive<u32>>,
862    AllValuesIter: Iterator<Item = u32>,
863    T: Domain,
864{
865    type Item = RangeInclusive<u32>;
866
867    fn next(&mut self) -> Option<Self::Item> {
868        match self {
869            RangeIter::Inclusive { ranges } => ranges.next(),
870            RangeIter::InclusiveDiscontinuous {
871                ranges,
872                current_range,
873                phantom: _,
874            } => loop {
875                // Discontinuous domains need special handling since members of the domain may be adjacent
876                // while their u32 representations may not be. So this iterator implementation compares successive
877                // ranges from the underlying u32 range iterator and merges any ranges that are found to be adjacent
878                // in the domain of type T.
879                let Some(next_range) = ranges.next() else {
880                    // No more ranges, commit the one we've got.
881                    return current_range.take();
882                };
883
884                let Some(range) = current_range.clone() else {
885                    // Populate current range, then move to the next so we can check if it's adjacent.
886                    *current_range = Some(next_range);
887                    continue;
888                };
889
890                // Check if next_range can merge into current_range
891                if RangeIter::<InclusiveRangeIter, AllValuesIter, T>::are_values_adjacent(
892                    *range.end(),
893                    *next_range.start(),
894                ) {
895                    // Do the merge, and check next
896                    *current_range = Some(*range.start()..=*next_range.end());
897                    continue;
898                }
899
900                // No merge is possible, return current range and replace it with next
901                *current_range = Some(next_range);
902                return Some(range);
903            },
904            RangeIter::Exclusive {
905                ranges,
906                min,
907                max,
908                done,
909            } => RangeIter::<InclusiveRangeIter, AllValuesIter, T>::next_exclusive(
910                ranges, min, max, done,
911            ),
912            RangeIter::ExclusiveDiscontinuous {
913                all_values,
914                set,
915                next_value,
916            } => RangeIter::<InclusiveRangeIter, AllValuesIter, T>::next_discontinuous(
917                all_values, set, next_value,
918            ),
919        }
920    }
921}
922
923impl<'a, InclusiveRangeIter, AllValuesIter, T> RangeIter<'a, InclusiveRangeIter, AllValuesIter, T>
924where
925    InclusiveRangeIter: Iterator<Item = RangeInclusive<u32>>,
926    AllValuesIter: Iterator<Item = u32>,
927    T: Domain,
928{
929    /// Iterate the ranges of an exclusive set where the domain is continuous.
930    fn next_exclusive(
931        ranges: &mut InclusiveRangeIter,
932        min: &mut u32,
933        max: &mut u32,
934        done: &mut bool,
935    ) -> Option<RangeInclusive<u32>> {
936        if *done {
937            return None;
938        }
939
940        loop {
941            let next_range = ranges.next();
942
943            let Some(next_range) = next_range else {
944                *done = true;
945                return Some(*min..=*max);
946            };
947
948            if next_range.contains(min) {
949                if *next_range.end() >= *max {
950                    break;
951                }
952                *min = next_range.end() + 1;
953                continue;
954            }
955
956            let result = *min..=(next_range.start() - 1);
957            if *next_range.end() < *max {
958                *min = next_range.end() + 1;
959            } else {
960                *done = true;
961            }
962            return Some(result);
963        }
964
965        *done = true;
966        None
967    }
968
969    /// Iterate the ranges of an exclusive set where the domain is discontinuous.
970    fn next_discontinuous(
971        all_values: &mut Option<AllValuesIter>,
972        set: &'a U32Set,
973        next_value: &mut Option<u32>,
974    ) -> Option<RangeInclusive<u32>> {
975        let all_values_iter = all_values.as_mut().unwrap();
976
977        let mut current_range: Option<RangeInclusive<u32>> = None;
978        loop {
979            let next = next_value.take().or_else(|| all_values_iter.next());
980            let Some(next) = next else {
981                // No more values, so the current range is over, return it.
982                return current_range;
983            };
984
985            if set.contains(next) {
986                if let Some(range) = current_range {
987                    // current range has ended, return it. No need to save 'next' as it's not in the set.
988                    return Some(range);
989                }
990                continue;
991            }
992
993            let Some(range) = current_range.as_ref() else {
994                current_range = Some(next..=next);
995                continue;
996            };
997
998            current_range = Some(*range.start()..=next);
999        }
1000    }
1001
1002    fn are_values_adjacent(a: u32, b: u32) -> bool {
1003        let mut it = T::ordered_values_range(T::from_u32(InDomain(a))..=T::from_u32(InDomain(b)));
1004        it.next(); // skip 'a'
1005        if let Some(second) = it.next() {
1006            // if a and b are adject then the second value in the iterator should be 'b'
1007            return second.to_u32() == b.to_u32();
1008        }
1009        false
1010    }
1011}
1012
1013impl Domain for u32 {
1014    fn to_u32(&self) -> u32 {
1015        *self
1016    }
1017
1018    fn from_u32(member: InDomain) -> u32 {
1019        member.value()
1020    }
1021
1022    fn contains(_value: u32) -> bool {
1023        true
1024    }
1025
1026    fn is_continuous() -> bool {
1027        true
1028    }
1029
1030    fn ordered_values() -> impl DoubleEndedIterator<Item = u32> {
1031        u32::MIN..=u32::MAX
1032    }
1033
1034    fn ordered_values_range(range: RangeInclusive<u32>) -> impl DoubleEndedIterator<Item = u32> {
1035        range
1036    }
1037
1038    fn count() -> u64 {
1039        (u32::MAX as u64) - (u32::MIN as u64) + 1
1040    }
1041}
1042
1043impl Domain for u16 {
1044    fn to_u32(&self) -> u32 {
1045        *self as u32
1046    }
1047
1048    fn from_u32(member: InDomain) -> u16 {
1049        member.value() as u16
1050    }
1051
1052    fn contains(value: u32) -> bool {
1053        (u16::MIN as u32..=u16::MAX as _).contains(&value)
1054    }
1055
1056    fn is_continuous() -> bool {
1057        true
1058    }
1059
1060    fn ordered_values() -> impl DoubleEndedIterator<Item = u32> {
1061        (u16::MIN as u32)..=(u16::MAX as u32)
1062    }
1063
1064    fn ordered_values_range(range: RangeInclusive<u16>) -> impl DoubleEndedIterator<Item = u32> {
1065        (*range.start() as u32)..=(*range.end() as u32)
1066    }
1067
1068    fn count() -> u64 {
1069        (u16::MAX as u64) - (u16::MIN as u64) + 1
1070    }
1071}
1072
1073impl Domain for u8 {
1074    fn to_u32(&self) -> u32 {
1075        *self as u32
1076    }
1077
1078    fn from_u32(member: InDomain) -> u8 {
1079        member.value() as u8
1080    }
1081
1082    fn contains(value: u32) -> bool {
1083        (u8::MIN as u32..=u8::MAX as _).contains(&value)
1084    }
1085
1086    fn is_continuous() -> bool {
1087        true
1088    }
1089
1090    fn ordered_values() -> impl DoubleEndedIterator<Item = u32> {
1091        (u8::MIN as u32)..=(u8::MAX as u32)
1092    }
1093
1094    fn ordered_values_range(range: RangeInclusive<u8>) -> impl DoubleEndedIterator<Item = u32> {
1095        (*range.start() as u32)..=(*range.end() as u32)
1096    }
1097
1098    fn count() -> u64 {
1099        (u8::MAX as u64) - (u8::MIN as u64) + 1
1100    }
1101}
1102
1103impl Domain for GlyphId16 {
1104    fn to_u32(&self) -> u32 {
1105        self.to_u16() as u32
1106    }
1107
1108    fn from_u32(member: InDomain) -> GlyphId16 {
1109        GlyphId16::new(member.value() as u16)
1110    }
1111
1112    fn contains(value: u32) -> bool {
1113        (u16::MIN as u32..=u16::MAX as _).contains(&value)
1114    }
1115
1116    fn is_continuous() -> bool {
1117        true
1118    }
1119
1120    fn ordered_values() -> impl DoubleEndedIterator<Item = u32> {
1121        (u16::MIN as u32)..=(u16::MAX as u32)
1122    }
1123
1124    fn ordered_values_range(
1125        range: RangeInclusive<GlyphId16>,
1126    ) -> impl DoubleEndedIterator<Item = u32> {
1127        range.start().to_u32()..=range.end().to_u32()
1128    }
1129
1130    fn count() -> u64 {
1131        (u16::MAX as u64) - (u16::MIN as u64) + 1
1132    }
1133}
1134
1135impl Domain for GlyphId {
1136    fn to_u32(&self) -> u32 {
1137        GlyphId::to_u32(*self)
1138    }
1139
1140    fn from_u32(member: InDomain) -> GlyphId {
1141        GlyphId::from(member.value())
1142    }
1143
1144    fn contains(_value: u32) -> bool {
1145        true
1146    }
1147
1148    fn is_continuous() -> bool {
1149        true
1150    }
1151
1152    fn ordered_values() -> impl DoubleEndedIterator<Item = u32> {
1153        u32::MIN..=u32::MAX
1154    }
1155
1156    fn ordered_values_range(
1157        range: RangeInclusive<GlyphId>,
1158    ) -> impl DoubleEndedIterator<Item = u32> {
1159        range.start().to_u32()..=range.end().to_u32()
1160    }
1161
1162    fn count() -> u64 {
1163        (u32::MAX as u64) - (u32::MIN as u64) + 1
1164    }
1165}
1166
1167impl Domain for Tag {
1168    fn to_u32(&self) -> u32 {
1169        u32::from_be_bytes(self.to_be_bytes())
1170    }
1171
1172    fn from_u32(member: InDomain) -> Tag {
1173        Tag::from_u32(member.value())
1174    }
1175
1176    fn contains(_value: u32) -> bool {
1177        true
1178    }
1179
1180    fn is_continuous() -> bool {
1181        true
1182    }
1183
1184    fn ordered_values() -> impl DoubleEndedIterator<Item = u32> {
1185        u32::MIN..=u32::MAX
1186    }
1187
1188    fn ordered_values_range(range: RangeInclusive<Tag>) -> impl DoubleEndedIterator<Item = u32> {
1189        range.start().to_u32()..=range.end().to_u32()
1190    }
1191
1192    fn count() -> u64 {
1193        (u32::MAX as u64) - (u32::MIN as u64) + 1
1194    }
1195}
1196
1197impl Domain for NameId {
1198    fn to_u32(&self) -> u32 {
1199        self.to_u16() as u32
1200    }
1201
1202    fn from_u32(member: InDomain) -> NameId {
1203        NameId::new(member.value() as u16)
1204    }
1205
1206    fn contains(value: u32) -> bool {
1207        (u16::MIN as u32..=u16::MAX as u32).contains(&value)
1208    }
1209
1210    fn is_continuous() -> bool {
1211        true
1212    }
1213
1214    fn ordered_values() -> impl DoubleEndedIterator<Item = u32> {
1215        (u16::MIN as u32)..=(u16::MAX as u32)
1216    }
1217
1218    fn ordered_values_range(range: RangeInclusive<NameId>) -> impl DoubleEndedIterator<Item = u32> {
1219        (range.start().to_u16() as u32)..=(range.end().to_u16() as u32)
1220    }
1221
1222    fn count() -> u64 {
1223        (u16::MAX as u64) - (u16::MIN as u64) + 1
1224    }
1225}
1226
1227#[cfg(test)]
1228mod test {
1229    use core::cmp::Ordering;
1230    use std::{collections::HashSet, hash::Hash};
1231
1232    use super::*;
1233
1234    #[derive(PartialEq, Eq, Debug, PartialOrd, Ord, Clone, Copy)]
1235    struct EvenInts(u16);
1236
1237    impl Domain for EvenInts {
1238        fn to_u32(&self) -> u32 {
1239            self.0 as u32
1240        }
1241
1242        fn contains(value: u32) -> bool {
1243            (value % 2) == 0
1244        }
1245
1246        fn from_u32(member: InDomain) -> EvenInts {
1247            EvenInts(member.0 as u16)
1248        }
1249
1250        fn is_continuous() -> bool {
1251            false
1252        }
1253
1254        fn ordered_values() -> impl DoubleEndedIterator<Item = u32> {
1255            (u16::MIN..=u16::MAX)
1256                .filter(|v| v % 2 == 0)
1257                .map(|v| v as u32)
1258        }
1259
1260        fn ordered_values_range(
1261            range: RangeInclusive<EvenInts>,
1262        ) -> impl DoubleEndedIterator<Item = u32> {
1263            Self::ordered_values()
1264                .filter(move |v| *v >= range.start().to_u32() && *v <= range.end().to_u32())
1265        }
1266
1267        fn count() -> u64 {
1268            ((u32::MAX as u64) - (u32::MIN as u64)).div_ceil(2)
1269        }
1270    }
1271
1272    #[derive(PartialEq, Eq, Debug, PartialOrd, Ord, Hash, Clone, Copy)]
1273    struct TwoParts(u16);
1274
1275    impl Domain for TwoParts {
1276        fn to_u32(&self) -> u32 {
1277            self.0 as u32
1278        }
1279
1280        fn contains(value: u32) -> bool {
1281            (2..=5).contains(&value) || (8..=16).contains(&value)
1282        }
1283
1284        fn from_u32(member: InDomain) -> TwoParts {
1285            TwoParts(member.0 as u16)
1286        }
1287
1288        fn is_continuous() -> bool {
1289            false
1290        }
1291
1292        fn ordered_values() -> impl DoubleEndedIterator<Item = u32> {
1293            [2..=5, 8..=16].into_iter().flat_map(|it| it.into_iter())
1294        }
1295
1296        fn ordered_values_range(
1297            range: RangeInclusive<TwoParts>,
1298        ) -> impl DoubleEndedIterator<Item = u32> {
1299            Self::ordered_values()
1300                .filter(move |v| *v >= range.start().to_u32() && *v <= range.end().to_u32())
1301        }
1302
1303        fn count() -> u64 {
1304            4 + 9
1305        }
1306    }
1307
1308    #[derive(PartialEq, Eq, Debug, PartialOrd, Ord, Clone, Copy)]
1309    struct TwoPartsBounds(u32);
1310
1311    impl Domain for TwoPartsBounds {
1312        fn to_u32(&self) -> u32 {
1313            self.0
1314        }
1315
1316        fn contains(value: u32) -> bool {
1317            (0..=1).contains(&value) || (u32::MAX - 1..=u32::MAX).contains(&value)
1318        }
1319
1320        fn from_u32(member: InDomain) -> TwoPartsBounds {
1321            TwoPartsBounds(member.0)
1322        }
1323
1324        fn is_continuous() -> bool {
1325            false
1326        }
1327
1328        fn ordered_values() -> impl DoubleEndedIterator<Item = u32> {
1329            [0..=1, u32::MAX - 1..=u32::MAX]
1330                .into_iter()
1331                .flat_map(|it| it.into_iter())
1332        }
1333
1334        fn ordered_values_range(
1335            range: RangeInclusive<TwoPartsBounds>,
1336        ) -> impl DoubleEndedIterator<Item = u32> {
1337            Self::ordered_values()
1338                .filter(move |v| *v >= range.start().to_u32() && *v <= range.end().to_u32())
1339        }
1340
1341        fn count() -> u64 {
1342            4
1343        }
1344    }
1345
1346    #[test]
1347    fn from_sparse_set() {
1348        let bytes = [0b00001101, 0b00000011, 0b00110001];
1349
1350        let set = IntSet::<u32>::from_sparse_bit_set(&bytes).unwrap();
1351
1352        let mut expected: IntSet<u32> = IntSet::<u32>::empty();
1353        expected.insert_range(0..=17);
1354
1355        assert_eq!(set, expected);
1356    }
1357
1358    #[test]
1359    fn insert() {
1360        let mut empty = IntSet::<u32>::empty();
1361        let mut all = IntSet::<u32>::all();
1362
1363        assert!(!empty.contains(10));
1364        assert!(empty.insert(10));
1365        assert!(empty.contains(10));
1366        assert!(!empty.insert(10));
1367
1368        assert!(all.contains(10));
1369        assert!(!all.insert(10));
1370        assert!(all.contains(10));
1371        assert!(!all.insert(10));
1372    }
1373
1374    #[test]
1375    fn remove() {
1376        let mut empty = IntSet::<u32>::empty();
1377        empty.insert(10);
1378        let mut all = IntSet::<u32>::all();
1379
1380        assert!(empty.contains(10));
1381        assert!(empty.remove(10));
1382        assert!(!empty.contains(10));
1383        assert!(!empty.remove(10));
1384
1385        assert!(all.contains(10));
1386        assert!(all.remove(10));
1387        assert!(!all.contains(10));
1388        assert!(!all.remove(10));
1389    }
1390
1391    #[test]
1392    fn is_empty() {
1393        let mut set = IntSet::<u32>::empty();
1394
1395        assert!(set.is_empty());
1396        set.insert(13);
1397        set.insert(800);
1398        assert!(!set.is_empty());
1399
1400        set.invert();
1401        assert!(!set.is_empty());
1402
1403        let mut empty = IntSet::<u32>::empty();
1404        assert!(empty.is_empty());
1405        empty.invert();
1406        assert!(!empty.is_empty());
1407    }
1408
1409    #[test]
1410    fn first() {
1411        let set = IntSet::<u16>::empty();
1412        assert_eq!(set.first(), None);
1413
1414        let set = IntSet::<u16>::all();
1415        assert_eq!(set.first(), Some(0));
1416
1417        let mut set = IntSet::<u16>::empty();
1418        set.extend([0]);
1419        assert_eq!(set.first(), Some(0));
1420
1421        let mut set = IntSet::<u16>::empty();
1422        set.extend([u16::MAX]);
1423        assert_eq!(set.first(), Some(u16::MAX));
1424
1425        let mut set = IntSet::<u16>::empty();
1426        set.extend([100, 1000, 10000]);
1427        assert_eq!(set.first(), Some(100));
1428
1429        set.invert();
1430        assert_eq!(set.first(), Some(0));
1431
1432        set.remove_range(0..=100);
1433        assert_eq!(set.first(), Some(101));
1434    }
1435
1436    #[test]
1437    fn last() {
1438        let set = IntSet::<u16>::empty();
1439        assert_eq!(set.last(), None);
1440
1441        let set = IntSet::<u16>::all();
1442        assert_eq!(set.last(), Some(u16::MAX));
1443
1444        let mut set = IntSet::<u16>::empty();
1445        set.extend([0]);
1446        assert_eq!(set.last(), Some(0));
1447
1448        let mut set = IntSet::<u16>::empty();
1449        set.extend([u16::MAX]);
1450        assert_eq!(set.last(), Some(u16::MAX));
1451
1452        let mut set = IntSet::<u16>::empty();
1453        set.extend([5, 7, 8]);
1454        assert_eq!(set.last(), Some(8));
1455
1456        let mut set = IntSet::<u16>::empty();
1457        set.extend([100, 1000, 10000]);
1458        assert_eq!(set.last(), Some(10000));
1459
1460        set.invert();
1461        assert_eq!(set.last(), Some(u16::MAX));
1462
1463        set.remove_range(u16::MAX - 10..=u16::MAX);
1464        assert_eq!(set.last(), Some(u16::MAX - 11));
1465    }
1466
1467    #[test]
1468    fn clear() {
1469        let mut set = IntSet::<u32>::empty();
1470        set.insert(13);
1471        set.insert(800);
1472
1473        let mut set_inverted = IntSet::<u32>::empty();
1474        set_inverted.insert(13);
1475        set_inverted.insert(800);
1476        set_inverted.invert();
1477
1478        set.clear();
1479        assert!(set.is_empty());
1480        set_inverted.clear();
1481        assert!(set_inverted.is_empty());
1482    }
1483
1484    #[allow(deprecated)] // SipHasher required because of MSRV
1485    fn hash<T>(set: &IntSet<T>) -> u64
1486    where
1487        T: Domain,
1488    {
1489        use std::hash::Hasher;
1490        let mut h = std::hash::SipHasher::new();
1491        set.hash(&mut h);
1492        h.finish()
1493    }
1494
1495    #[test]
1496    fn equal_and_hash() {
1497        let mut inc1 = IntSet::<u32>::empty();
1498        inc1.insert(14);
1499        inc1.insert(670);
1500
1501        let mut inc2 = IntSet::<u32>::empty();
1502        inc2.insert(670);
1503        inc2.insert(14);
1504
1505        let mut inc3 = inc1.clone();
1506        inc3.insert(5);
1507
1508        let mut exc = inc1.clone();
1509        exc.invert();
1510
1511        assert_eq!(inc1, inc2);
1512        assert_ne!(inc1, inc3);
1513        assert_ne!(inc1, exc);
1514
1515        let set = HashSet::from([inc1.clone(), inc3.clone(), exc.clone()]);
1516        assert!(set.contains(&inc1));
1517        assert!(set.contains(&inc3));
1518        assert!(set.contains(&exc));
1519
1520        assert_ne!(hash(&inc1), hash(&exc));
1521        assert_eq!(hash(&inc1), hash(&inc2));
1522    }
1523
1524    #[test]
1525    fn equal_and_hash_mixed_membership_types() {
1526        let mut inverted_all = IntSet::<TwoParts>::all();
1527        let mut all = IntSet::<TwoParts>::empty();
1528        for v in TwoParts::ordered_values() {
1529            all.insert(TwoParts(v as u16));
1530        }
1531
1532        assert_eq!(inverted_all, all);
1533        assert_eq!(hash(&all), hash(&inverted_all));
1534
1535        inverted_all.remove(TwoParts(5));
1536        assert_ne!(inverted_all, all);
1537
1538        all.remove(TwoParts(5));
1539        assert_eq!(inverted_all, all);
1540        assert_eq!(hash(&all), hash(&inverted_all));
1541    }
1542
1543    #[test]
1544    fn iter() {
1545        let mut set = IntSet::<u32>::empty();
1546        set.insert(3);
1547        set.insert(8);
1548        set.insert(534);
1549        set.insert(700);
1550        set.insert(10000);
1551        set.insert(10001);
1552        set.insert(10002);
1553
1554        let v: Vec<u32> = set.iter().collect();
1555        assert_eq!(v, vec![3, 8, 534, 700, 10000, 10001, 10002]);
1556
1557        let v: Vec<u32> = set.inclusive_iter().unwrap().collect();
1558        assert_eq!(v, vec![3, 8, 534, 700, 10000, 10001, 10002]);
1559    }
1560
1561    #[test]
1562    fn iter_backwards() {
1563        let mut set = IntSet::<u32>::empty();
1564        set.insert_range(1..=6);
1565        {
1566            let mut it = set.iter();
1567            assert_eq!(Some(1), it.next());
1568            assert_eq!(Some(6), it.next_back());
1569            assert_eq!(Some(5), it.next_back());
1570            assert_eq!(Some(2), it.next());
1571            assert_eq!(Some(3), it.next());
1572            assert_eq!(Some(4), it.next());
1573            assert_eq!(None, it.next());
1574            assert_eq!(None, it.next_back());
1575        }
1576
1577        let mut set = IntSet::<u8>::empty();
1578        set.invert();
1579        set.remove_range(10..=255);
1580        set.remove(4);
1581        set.remove(8);
1582        {
1583            let mut it = set.iter();
1584            assert_eq!(Some(0), it.next());
1585            assert_eq!(Some(1), it.next());
1586            assert_eq!(Some(2), it.next());
1587            assert_eq!(Some(3), it.next());
1588
1589            assert_eq!(Some(9), it.next_back());
1590            assert_eq!(Some(7), it.next_back());
1591            assert_eq!(Some(6), it.next_back());
1592            assert_eq!(Some(5), it.next_back());
1593            assert_eq!(None, it.next_back());
1594
1595            assert_eq!(None, it.next());
1596        }
1597
1598        let mut set = IntSet::<u8>::empty();
1599        set.invert();
1600        set.remove_range(10..=255);
1601        set.remove(4);
1602        set.remove(8);
1603        {
1604            let mut it = set.iter();
1605            assert_eq!(Some(0), it.next());
1606            assert_eq!(Some(1), it.next());
1607            assert_eq!(Some(2), it.next());
1608            assert_eq!(Some(3), it.next());
1609            assert_eq!(Some(5), it.next());
1610
1611            assert_eq!(Some(9), it.next_back());
1612            assert_eq!(Some(7), it.next_back());
1613            assert_eq!(Some(6), it.next_back());
1614            assert_eq!(None, it.next_back());
1615
1616            assert_eq!(None, it.next());
1617        }
1618    }
1619
1620    #[test]
1621    fn exclusive_iter() {
1622        let mut set = IntSet::<u32>::all();
1623        set.remove(3);
1624        set.remove(7);
1625        set.remove(8);
1626
1627        let mut iter = set.iter();
1628
1629        assert_eq!(iter.next(), Some(0));
1630        assert_eq!(iter.next(), Some(1));
1631        assert_eq!(iter.next(), Some(2));
1632        assert_eq!(iter.next(), Some(4));
1633        assert_eq!(iter.next(), Some(5));
1634        assert_eq!(iter.next(), Some(6));
1635        assert_eq!(iter.next(), Some(9));
1636        assert_eq!(iter.next(), Some(10));
1637
1638        assert!(set.inclusive_iter().is_none());
1639
1640        // Forward skip first
1641        let mut set = IntSet::<u32>::all();
1642        set.remove_range(0..=200);
1643
1644        let mut iter = set.iter();
1645        assert_eq!(iter.next(), Some(201));
1646
1647        // Backward skip first
1648        let mut set = IntSet::<u8>::all();
1649        set.remove_range(200..=255);
1650
1651        let mut iter = set.iter();
1652        assert_eq!(iter.next_back(), Some(199));
1653    }
1654
1655    #[test]
1656    fn iter_ranges_inclusive() {
1657        let mut set = IntSet::<u32>::empty();
1658        let items: Vec<_> = set.iter_ranges().collect();
1659        assert_eq!(items, vec![]);
1660
1661        set.insert_range(200..=700);
1662        set.insert(5);
1663        let items: Vec<_> = set.iter_ranges().collect();
1664        assert_eq!(items, vec![5..=5, 200..=700]);
1665
1666        let mut set = IntSet::<u32>::empty();
1667        set.insert_range(0..=0);
1668        set.insert_range(u32::MAX..=u32::MAX);
1669        let items: Vec<_> = set.iter_ranges().collect();
1670        assert_eq!(items, vec![0..=0, u32::MAX..=u32::MAX]);
1671
1672        let mut set = IntSet::<u32>::empty();
1673        set.insert_range(0..=5);
1674        set.insert_range(u32::MAX - 5..=u32::MAX);
1675        let items: Vec<_> = set.iter_ranges().collect();
1676        assert_eq!(items, vec![0..=5, u32::MAX - 5..=u32::MAX]);
1677
1678        let mut inverted = set.clone();
1679        inverted.invert();
1680        assert_eq!(
1681            set.iter_ranges().collect::<Vec<_>>(),
1682            inverted.iter_excluded_ranges().collect::<Vec<_>>()
1683        );
1684    }
1685
1686    #[test]
1687    fn iter_ranges_inclusive_discontinuous() {
1688        let mut set = IntSet::<EvenInts>::empty();
1689        let items: Vec<_> = set.iter_ranges().collect();
1690        assert_eq!(items, vec![]);
1691
1692        set.insert_range(EvenInts(4)..=EvenInts(12));
1693        set.insert(EvenInts(16));
1694
1695        let items: Vec<_> = set.iter_ranges().collect();
1696        assert_eq!(
1697            items,
1698            vec![EvenInts(4)..=EvenInts(12), EvenInts(16)..=EvenInts(16)]
1699        );
1700
1701        let mut inverted = set.clone();
1702        inverted.invert();
1703        assert_eq!(
1704            set.iter_ranges().collect::<Vec<_>>(),
1705            inverted.iter_excluded_ranges().collect::<Vec<_>>()
1706        );
1707    }
1708
1709    #[test]
1710    fn iter_ranges_exclusive() {
1711        let mut set = IntSet::<u32>::all();
1712        set.remove_range(200..=700);
1713        set.remove(5);
1714        let items: Vec<_> = set.iter_ranges().collect();
1715        assert_eq!(items, vec![0..=4, 6..=199, 701..=u32::MAX]);
1716
1717        let mut set = IntSet::<u32>::all();
1718        set.remove_range(0..=700);
1719        let items: Vec<_> = set.iter_ranges().collect();
1720        assert_eq!(items, vec![701..=u32::MAX]);
1721
1722        let mut inverted = set.clone();
1723        inverted.invert();
1724        assert_eq!(
1725            set.iter_ranges().collect::<Vec<_>>(),
1726            inverted.iter_excluded_ranges().collect::<Vec<_>>()
1727        );
1728
1729        let mut set = IntSet::<u32>::all();
1730        set.remove_range(u32::MAX - 10..=u32::MAX);
1731        let items: Vec<_> = set.iter_ranges().collect();
1732        assert_eq!(items, vec![0..=u32::MAX - 11]);
1733
1734        let mut set = IntSet::<u16>::all();
1735        set.remove_range(0..=u16::MAX);
1736        let items: Vec<_> = set.iter_ranges().collect();
1737        assert_eq!(items, vec![]);
1738
1739        let mut set = IntSet::<u16>::all();
1740        set.remove_range(0..=u16::MAX - 1);
1741        let items: Vec<_> = set.iter_ranges().collect();
1742        assert_eq!(items, vec![u16::MAX..=u16::MAX]);
1743
1744        let mut set = IntSet::<u16>::all();
1745        set.remove_range(1..=u16::MAX);
1746        let items: Vec<_> = set.iter_ranges().collect();
1747        assert_eq!(items, vec![0..=0]);
1748
1749        let set = IntSet::<u32>::all();
1750        let items: Vec<_> = set.iter_ranges().collect();
1751        assert_eq!(items, vec![0..=u32::MAX]);
1752    }
1753
1754    #[test]
1755    fn iter_ranges_exclusive_discontinuous() {
1756        let mut set = IntSet::<EvenInts>::all();
1757        set.remove_range(EvenInts(0)..=EvenInts(8));
1758        set.remove_range(EvenInts(16)..=EvenInts(u16::MAX - 1));
1759        let items: Vec<_> = set.iter_ranges().collect();
1760        assert_eq!(items, vec![EvenInts(10)..=EvenInts(14),]);
1761
1762        let mut set = IntSet::<TwoParts>::all();
1763        set.remove_range(TwoParts(11)..=TwoParts(13));
1764        let items: Vec<_> = set.iter_ranges().collect();
1765        assert_eq!(
1766            items,
1767            vec![TwoParts(2)..=TwoParts(10), TwoParts(14)..=TwoParts(16),]
1768        );
1769
1770        let mut inverted = set.clone();
1771        inverted.invert();
1772        assert_eq!(
1773            set.iter_ranges().collect::<Vec<_>>(),
1774            inverted.iter_excluded_ranges().collect::<Vec<_>>()
1775        );
1776
1777        let mut set = IntSet::<TwoParts>::all();
1778        set.remove_range(TwoParts(2)..=TwoParts(16));
1779        let items: Vec<_> = set.iter_ranges().collect();
1780        assert_eq!(items, vec![]);
1781
1782        let mut set = IntSet::<TwoParts>::all();
1783        set.remove_range(TwoParts(2)..=TwoParts(5));
1784        let items: Vec<_> = set.iter_ranges().collect();
1785        assert_eq!(items, vec![TwoParts(8)..=TwoParts(16),]);
1786
1787        let mut set = IntSet::<TwoParts>::all();
1788        set.remove_range(TwoParts(6)..=TwoParts(16));
1789        let items: Vec<_> = set.iter_ranges().collect();
1790        assert_eq!(items, vec![TwoParts(2)..=TwoParts(5),]);
1791
1792        // Check we can safely iterate to the limits of u32.
1793        let set = IntSet::<TwoPartsBounds>::all();
1794        let items: Vec<_> = set.iter_ranges().collect();
1795        assert_eq!(items, vec![TwoPartsBounds(0)..=TwoPartsBounds(u32::MAX),]);
1796    }
1797
1798    #[test]
1799    fn iter_range() {
1800        let mut set = IntSet::<u32>::empty();
1801        assert_eq!(set.iter_after(0).count(), 0);
1802
1803        set.extend([5, 7, 10, 1250, 1300, 3001]);
1804
1805        assert_eq!(
1806            set.iter_after(0).collect::<Vec<u32>>(),
1807            vec![5, 7, 10, 1250, 1300, 3001]
1808        );
1809        assert_eq!(
1810            set.range(0..).collect::<Vec<u32>>(),
1811            vec![5, 7, 10, 1250, 1300, 3001]
1812        );
1813
1814        assert_eq!(
1815            set.iter_after(5).collect::<Vec<u32>>(),
1816            vec![7, 10, 1250, 1300, 3001]
1817        );
1818        assert_eq!(
1819            set.range(5..).collect::<Vec<u32>>(),
1820            vec![5, 7, 10, 1250, 1300, 3001]
1821        );
1822
1823        assert_eq!(
1824            set.iter_after(700).collect::<Vec<u32>>(),
1825            vec![1250, 1300, 3001]
1826        );
1827        assert_eq!(
1828            set.range(700..).collect::<Vec<u32>>(),
1829            vec![1250, 1300, 3001]
1830        );
1831    }
1832
1833    #[test]
1834    fn iter_after_from_exclusive() {
1835        let mut set = IntSet::<u32>::empty();
1836        set.extend([5, 7, 10, 1250, 1300, 3001]);
1837        set.invert();
1838
1839        assert_eq!(
1840            set.iter_after(3).take(5).collect::<Vec<u32>>(),
1841            vec![4, 6, 8, 9, 11]
1842        );
1843        assert_eq!(
1844            set.range(3..).take(5).collect::<Vec<u32>>(),
1845            vec![3, 4, 6, 8, 9]
1846        );
1847
1848        assert_eq!(
1849            set.iter_after(0).take(5).collect::<Vec<u32>>(),
1850            vec![1, 2, 3, 4, 6]
1851        );
1852        assert_eq!(
1853            set.range(0..).take(5).collect::<Vec<u32>>(),
1854            vec![0, 1, 2, 3, 4]
1855        );
1856
1857        assert_eq!(
1858            set.iter_after(u32::MAX - 1).take(1).collect::<Vec<u32>>(),
1859            vec![u32::MAX]
1860        );
1861        assert_eq!(
1862            set.range(u32::MAX - 1..).take(2).collect::<Vec<u32>>(),
1863            vec![u32::MAX - 1, u32::MAX]
1864        );
1865
1866        assert_eq!(set.iter_after(u32::MAX).take(1).count(), 0);
1867        set.remove(u32::MAX);
1868        assert_eq!(set.range(u32::MAX..).take(1).count(), 0);
1869        assert_eq!(set.iter_after(u32::MAX - 1).take(1).count(), 0);
1870    }
1871
1872    #[test]
1873    fn iter_after_discontinuous() {
1874        let mut set = IntSet::<EvenInts>::empty();
1875        set.extend([EvenInts(6), EvenInts(10)]);
1876        set.invert();
1877
1878        assert_eq!(
1879            set.iter_after(EvenInts(2))
1880                .take(5)
1881                .collect::<Vec<EvenInts>>(),
1882            vec![
1883                EvenInts(4),
1884                EvenInts(8),
1885                EvenInts(12),
1886                EvenInts(14),
1887                EvenInts(16)
1888            ]
1889        );
1890        assert_eq!(
1891            set.range(EvenInts(2)..).take(5).collect::<Vec<EvenInts>>(),
1892            vec![
1893                EvenInts(2),
1894                EvenInts(4),
1895                EvenInts(8),
1896                EvenInts(12),
1897                EvenInts(14)
1898            ]
1899        );
1900
1901        assert_eq!(
1902            set.iter_after(EvenInts(4))
1903                .take(5)
1904                .collect::<Vec<EvenInts>>(),
1905            vec![
1906                EvenInts(8),
1907                EvenInts(12),
1908                EvenInts(14),
1909                EvenInts(16),
1910                EvenInts(18)
1911            ]
1912        );
1913
1914        assert_eq!(
1915            set.iter_after(EvenInts(u16::MAX - 1))
1916                .collect::<Vec<EvenInts>>(),
1917            vec![]
1918        );
1919        assert_eq!(
1920            set.range(EvenInts(u16::MAX - 1)..)
1921                .collect::<Vec<EvenInts>>(),
1922            vec![EvenInts(u16::MAX - 1)]
1923        );
1924
1925        assert_eq!(
1926            set.iter_after(EvenInts(u16::MAX - 5))
1927                .collect::<Vec<EvenInts>>(),
1928            vec![EvenInts(u16::MAX - 3), EvenInts(u16::MAX - 1)]
1929        );
1930
1931        set.remove(EvenInts(u16::MAX - 1));
1932        assert_eq!(
1933            set.iter_after(EvenInts(u16::MAX - 5))
1934                .collect::<Vec<EvenInts>>(),
1935            vec![EvenInts(u16::MAX - 3),]
1936        );
1937        assert_eq!(
1938            set.range(EvenInts(u16::MAX - 5)..)
1939                .collect::<Vec<EvenInts>>(),
1940            vec![EvenInts(u16::MAX - 5), EvenInts(u16::MAX - 3),]
1941        );
1942    }
1943
1944    #[test]
1945    #[allow(clippy::reversed_empty_ranges)]
1946    fn range() {
1947        let mut set = IntSet::<u32>::empty();
1948        assert_eq!(set.range(0..=5).count(), 0);
1949
1950        set.extend([5, 7, 10, 1250, 1300, 3001]);
1951
1952        assert_eq!(set.range(0..=5).collect::<Vec<u32>>(), vec![5]);
1953        assert_eq!(set.range(5..=11).collect::<Vec<u32>>(), vec![5, 7, 10]);
1954        assert_eq!(set.range(5..10).collect::<Vec<u32>>(), vec![5, 7]);
1955        assert_eq!(set.range(..10).collect::<Vec<u32>>(), vec![5, 7]);
1956        assert_eq!(set.range(..=10).collect::<Vec<u32>>(), vec![5, 7, 10]);
1957        assert_eq!(set.range(6..=11).collect::<Vec<u32>>(), vec![7, 10]);
1958
1959        assert!(set.range(7..6).collect::<Vec<u32>>().is_empty());
1960        assert!(set.range(7..7).collect::<Vec<u32>>().is_empty());
1961        assert_eq!(set.range(7..=7).collect::<Vec<u32>>(), vec![7]);
1962
1963        assert!(set.range(5..=0).collect::<Vec<u32>>().is_empty());
1964    }
1965
1966    #[test]
1967    fn from_iterator() {
1968        let s: IntSet<u32> = [3, 8, 12, 589].into_iter().collect();
1969        let mut expected = IntSet::<u32>::empty();
1970        expected.insert(3);
1971        expected.insert(8);
1972        expected.insert(12);
1973        expected.insert(589);
1974
1975        assert_eq!(s, expected);
1976    }
1977
1978    #[test]
1979    fn from_int_set_iterator() {
1980        let s1: IntSet<u32> = [3, 8, 12, 589].into_iter().collect();
1981        let s2: IntSet<u32> = s1.iter().collect();
1982        assert_eq!(s1, s2);
1983    }
1984
1985    #[test]
1986    fn extend() {
1987        let mut s = IntSet::<u32>::empty();
1988        s.extend([3, 12]);
1989        s.extend([8, 10, 589]);
1990
1991        let mut expected = IntSet::<u32>::empty();
1992        expected.insert(3);
1993        expected.insert(8);
1994        expected.insert(10);
1995        expected.insert(12);
1996        expected.insert(589);
1997
1998        assert_eq!(s, expected);
1999    }
2000
2001    #[test]
2002    fn extend_on_inverted() {
2003        let mut s = IntSet::<u32>::all();
2004        for i in 10..=20 {
2005            s.remove(i);
2006        }
2007
2008        s.extend([12, 17, 18]);
2009
2010        assert!(!s.contains(11));
2011        assert!(s.contains(12));
2012        assert!(!s.contains(13));
2013
2014        assert!(!s.contains(16));
2015        assert!(s.contains(17));
2016        assert!(s.contains(18));
2017        assert!(!s.contains(19));
2018        assert!(s.contains(100));
2019    }
2020
2021    #[test]
2022    fn remove_all() {
2023        let mut empty = IntSet::<u32>::empty();
2024        let mut all = IntSet::<u32>::all();
2025
2026        empty.extend([1, 2, 3, 4]);
2027
2028        empty.remove_all([2, 3]);
2029        all.remove_all([2, 3]);
2030
2031        assert!(empty.contains(1));
2032        assert!(!empty.contains(2));
2033        assert!(!empty.contains(3));
2034        assert!(empty.contains(4));
2035
2036        assert!(all.contains(1));
2037        assert!(!all.contains(2));
2038        assert!(!all.contains(3));
2039        assert!(all.contains(4));
2040    }
2041
2042    #[test]
2043    fn remove_range() {
2044        let mut empty = IntSet::<u32>::empty();
2045        let mut all = IntSet::<u32>::all();
2046
2047        empty.extend([1, 2, 3, 4]);
2048
2049        empty.remove_range(2..=3);
2050        all.remove_range(2..=3);
2051
2052        assert!(empty.contains(1));
2053        assert!(!empty.contains(2));
2054        assert!(!empty.contains(3));
2055        assert!(empty.contains(4));
2056
2057        assert!(all.contains(1));
2058        assert!(!all.contains(2));
2059        assert!(!all.contains(3));
2060        assert!(all.contains(4));
2061    }
2062
2063    #[test]
2064    fn insert_remove_range_boundary() {
2065        let mut set = IntSet::<u32>::empty();
2066
2067        set.remove_range(u32::MAX - 10..=u32::MAX);
2068        assert!(!set.contains(u32::MAX));
2069        set.insert_range(u32::MAX - 10..=u32::MAX);
2070        assert!(set.contains(u32::MAX));
2071        set.remove_range(u32::MAX - 10..=u32::MAX);
2072        assert!(!set.contains(u32::MAX));
2073
2074        set.remove_range(0..=10);
2075        assert!(!set.contains(0));
2076        set.insert_range(0..=10);
2077        assert!(set.contains(0));
2078        set.remove_range(0..=10);
2079        assert!(!set.contains(0));
2080    }
2081
2082    #[test]
2083    fn insert_remove_range_exclusive_boundary() {
2084        let mut set = IntSet::<u32>::all();
2085
2086        set.remove_range(u32::MAX - 10..=u32::MAX);
2087        assert!(!set.contains(u32::MAX));
2088        set.insert_range(u32::MAX - 10..=u32::MAX);
2089        assert!(set.contains(u32::MAX));
2090        set.remove_range(u32::MAX - 10..=u32::MAX);
2091        assert!(!set.contains(u32::MAX));
2092
2093        set.remove_range(0..=10);
2094        assert!(!set.contains(0));
2095        set.insert_range(0..=10);
2096        assert!(set.contains(0));
2097        set.remove_range(0..=10);
2098        assert!(!set.contains(0));
2099    }
2100
2101    struct SetOpInput {
2102        has_x: bool,
2103        inverted: bool,
2104        has_page: bool,
2105    }
2106
2107    impl SetOpInput {
2108        fn get_all_inputs() -> Vec<SetOpInput> {
2109            let mut result: Vec<SetOpInput> = vec![];
2110            for has_x in [true, false] {
2111                for inverted in [true, false] {
2112                    result.push(SetOpInput {
2113                        has_x,
2114                        inverted,
2115                        has_page: false,
2116                    });
2117                    let can_have_empty_page = has_x == inverted;
2118                    if can_have_empty_page {
2119                        result.push(SetOpInput {
2120                            has_x,
2121                            inverted,
2122                            has_page: true,
2123                        });
2124                    }
2125                }
2126            }
2127            result
2128        }
2129
2130        fn to_set(&self, x: u32) -> IntSet<u32> {
2131            let mut s = IntSet::<u32>::empty();
2132            if self.inverted {
2133                s.invert();
2134            }
2135            if self.has_page {
2136                // Ensure a page exists for x.
2137                if self.inverted {
2138                    s.remove(x);
2139                } else {
2140                    s.insert(x);
2141                }
2142            }
2143            if self.has_x {
2144                s.insert(x);
2145            } else {
2146                s.remove(x);
2147            }
2148            s
2149        }
2150    }
2151
2152    fn set_operation_test_message(
2153        a: &SetOpInput,
2154        b: &SetOpInput,
2155        op_name: &str,
2156        should_contain_x: bool,
2157    ) -> String {
2158        format!(
2159            "{}{}{} {} {}{}{} failed. {}",
2160            if a.inverted { "i" } else { "" },
2161            if a.has_page { "p" } else { "" },
2162            if a.has_x { "13" } else { "" },
2163            op_name,
2164            if b.inverted { "i" } else { "" },
2165            if b.has_page { "p" } else { "" },
2166            if b.has_x { "13" } else { "" },
2167            if should_contain_x {
2168                "Result did not have 13."
2169            } else {
2170                "Result should not have 13."
2171            }
2172        )
2173    }
2174
2175    fn check_union(a: &SetOpInput, b: &SetOpInput) {
2176        let x = 13;
2177        let mut set_a = a.to_set(x);
2178        let set_b = b.to_set(x);
2179
2180        let should_contain_x = a.has_x || b.has_x;
2181        set_a.union(&set_b);
2182
2183        assert_eq!(
2184            set_a.contains(x),
2185            should_contain_x,
2186            "{}",
2187            set_operation_test_message(a, b, "union", should_contain_x)
2188        );
2189    }
2190
2191    fn check_intersect(a: &SetOpInput, b: &SetOpInput) {
2192        let x = 13;
2193        let mut set_a = a.to_set(x);
2194        let set_b = b.to_set(x);
2195
2196        let should_contain_x = a.has_x && b.has_x;
2197        set_a.intersect(&set_b);
2198
2199        assert_eq!(
2200            set_a.contains(x),
2201            should_contain_x,
2202            "{}",
2203            set_operation_test_message(a, b, "intersect", should_contain_x)
2204        );
2205    }
2206
2207    fn check_subtract(a: &SetOpInput, b: &SetOpInput) {
2208        let x = 13;
2209        let mut set_a = a.to_set(x);
2210        let set_b = b.to_set(x);
2211
2212        let should_contain_x = a.has_x && (!b.has_x);
2213        set_a.subtract(&set_b);
2214
2215        assert_eq!(
2216            set_a.contains(x),
2217            should_contain_x,
2218            "{}",
2219            set_operation_test_message(a, b, "subtract", should_contain_x)
2220        );
2221    }
2222
2223    #[test]
2224    fn set_operations() {
2225        for a in SetOpInput::get_all_inputs() {
2226            for b in SetOpInput::get_all_inputs() {
2227                check_union(&a, &b);
2228                check_intersect(&a, &b);
2229                check_subtract(&a, &b);
2230            }
2231        }
2232    }
2233
2234    #[test]
2235    fn inverted() {
2236        let mut set = IntSet::<u32>::empty();
2237
2238        set.insert(13);
2239        set.insert(800);
2240        assert!(set.contains(13));
2241        assert!(set.contains(800));
2242        assert_eq!(set.len(), 2);
2243        assert!(!set.is_inverted());
2244
2245        set.invert();
2246        assert_eq!(set.len(), u32::MAX as u64 - 1);
2247        assert!(!set.contains(13));
2248        assert!(set.contains(80));
2249        assert!(!set.contains(800));
2250        assert!(set.is_inverted());
2251
2252        set.remove(80);
2253        assert!(!set.contains(80));
2254
2255        set.insert(13);
2256        assert!(set.contains(13));
2257
2258        set.invert();
2259        assert!(set.contains(80));
2260        assert!(set.contains(800));
2261    }
2262
2263    #[test]
2264    fn limited_domain_type() {
2265        let mut set = IntSet::<EvenInts>::empty();
2266
2267        set.insert(EvenInts(2));
2268        set.insert(EvenInts(8));
2269        set.insert(EvenInts(12));
2270        set.insert_range(EvenInts(20)..=EvenInts(34));
2271        set.remove_range(EvenInts(30)..=EvenInts(34));
2272
2273        assert!(set.contains(EvenInts(2)));
2274        assert!(!set.contains(EvenInts(4)));
2275
2276        assert!(!set.contains(EvenInts(18)));
2277        assert!(!set.contains(EvenInts(19)));
2278        assert!(set.contains(EvenInts(20)));
2279        assert!(!set.contains(EvenInts(21)));
2280        assert!(set.contains(EvenInts(28)));
2281        assert!(!set.contains(EvenInts(29)));
2282        assert!(!set.contains(EvenInts(30)));
2283
2284        let copy: IntSet<EvenInts> = set.iter().collect();
2285        assert_eq!(set, copy);
2286
2287        set.invert();
2288
2289        assert!(!set.contains(EvenInts(2)));
2290        assert!(set.contains(EvenInts(4)));
2291
2292        let Some(max) = set.iter().max() else {
2293            panic!("should have a max");
2294        };
2295
2296        assert_eq!(max.0, u16::MAX - 1);
2297
2298        {
2299            let mut it = set.iter();
2300            assert_eq!(it.next(), Some(EvenInts(0)));
2301            assert_eq!(it.next(), Some(EvenInts(4)));
2302            assert_eq!(it.next(), Some(EvenInts(6)));
2303            assert_eq!(it.next(), Some(EvenInts(10)));
2304            assert_eq!(it.next(), Some(EvenInts(14)));
2305        }
2306
2307        set.insert_range(EvenInts(6)..=EvenInts(10));
2308        {
2309            let mut it = set.iter();
2310            assert_eq!(it.next(), Some(EvenInts(0)));
2311            assert_eq!(it.next(), Some(EvenInts(4)));
2312            assert_eq!(it.next(), Some(EvenInts(6)));
2313            assert_eq!(it.next(), Some(EvenInts(8)));
2314            assert_eq!(it.next(), Some(EvenInts(10)));
2315            assert_eq!(it.next(), Some(EvenInts(14)));
2316        }
2317
2318        set.remove_range(EvenInts(6)..=EvenInts(10));
2319        {
2320            let mut it = set.iter();
2321            assert_eq!(it.next(), Some(EvenInts(0)));
2322            assert_eq!(it.next(), Some(EvenInts(4)));
2323            assert_eq!(it.next(), Some(EvenInts(14)));
2324        }
2325    }
2326
2327    #[test]
2328    fn with_u16() {
2329        let mut set = IntSet::<u16>::empty();
2330
2331        set.insert(5);
2332        set.insert(8);
2333        set.insert(12);
2334        set.insert_range(200..=210);
2335
2336        assert!(set.contains(5));
2337        assert!(!set.contains(6));
2338        assert!(!set.contains(199));
2339        assert!(set.contains(200));
2340        assert!(set.contains(210));
2341        assert!(!set.contains(211));
2342
2343        let copy: IntSet<u16> = set.iter().collect();
2344        assert_eq!(set, copy);
2345
2346        set.invert();
2347
2348        assert!(!set.contains(5));
2349        assert!(set.contains(6));
2350
2351        let Some(max) = set.iter().max() else {
2352            panic!("should have a max");
2353        };
2354
2355        assert_eq!(max, u16::MAX);
2356
2357        let mut it = set.iter();
2358        assert_eq!(it.next(), Some(0));
2359        assert_eq!(it.next(), Some(1));
2360        assert_eq!(it.next(), Some(2));
2361        assert_eq!(it.next(), Some(3));
2362        assert_eq!(it.next(), Some(4));
2363        assert_eq!(it.next(), Some(6));
2364    }
2365
2366    #[test]
2367    fn with_glyph_id_16() {
2368        let mut set = IntSet::<font_types::GlyphId16>::empty();
2369
2370        set.insert(GlyphId16::new(5));
2371        set.insert(GlyphId16::new(8));
2372        set.insert(GlyphId16::new(12));
2373        set.insert_range(GlyphId16::new(200)..=GlyphId16::new(210));
2374
2375        assert!(set.contains(GlyphId16::new(5)));
2376        assert!(!set.contains(GlyphId16::new(6)));
2377        assert!(!set.contains(GlyphId16::new(199)));
2378        assert!(set.contains(GlyphId16::new(200)));
2379        assert!(set.contains(GlyphId16::new(210)));
2380        assert!(!set.contains(GlyphId16::new(211)));
2381
2382        let copy: IntSet<GlyphId16> = set.iter().collect();
2383        assert_eq!(set, copy);
2384
2385        set.invert();
2386
2387        assert!(!set.contains(GlyphId16::new(5)));
2388        assert!(set.contains(GlyphId16::new(6)));
2389
2390        let Some(max) = set.iter().max() else {
2391            panic!("should have a max");
2392        };
2393
2394        assert_eq!(max, GlyphId16::new(u16::MAX));
2395
2396        let mut it = set.iter();
2397        assert_eq!(it.next(), Some(GlyphId16::new(0)));
2398        assert_eq!(it.next(), Some(GlyphId16::new(1)));
2399        assert_eq!(it.next(), Some(GlyphId16::new(2)));
2400        assert_eq!(it.next(), Some(GlyphId16::new(3)));
2401        assert_eq!(it.next(), Some(GlyphId16::new(4)));
2402        assert_eq!(it.next(), Some(GlyphId16::new(6)));
2403    }
2404
2405    #[test]
2406    fn with_glyph_id() {
2407        let mut set = IntSet::<font_types::GlyphId>::empty();
2408
2409        set.insert(GlyphId::new(5));
2410        set.insert(GlyphId::new(8));
2411        set.insert(GlyphId::new(12));
2412        set.insert_range(GlyphId::new(200)..=GlyphId::new(210));
2413
2414        assert!(set.contains(GlyphId::new(5)));
2415        assert!(!set.contains(GlyphId::new(6)));
2416        assert!(!set.contains(GlyphId::new(199)));
2417        assert!(set.contains(GlyphId::new(200)));
2418        assert!(set.contains(GlyphId::new(210)));
2419        assert!(!set.contains(GlyphId::new(211)));
2420
2421        let copy: IntSet<GlyphId> = set.iter().collect();
2422        assert_eq!(set, copy);
2423
2424        set.invert();
2425
2426        assert!(!set.contains(GlyphId::new(5)));
2427        assert!(set.contains(GlyphId::new(6)));
2428
2429        let mut it = set.iter();
2430        assert_eq!(it.next(), Some(GlyphId::new(0)));
2431        assert_eq!(it.next(), Some(GlyphId::new(1)));
2432        assert_eq!(it.next(), Some(GlyphId::new(2)));
2433        assert_eq!(it.next(), Some(GlyphId::new(3)));
2434        assert_eq!(it.next(), Some(GlyphId::new(4)));
2435        assert_eq!(it.next(), Some(GlyphId::new(6)));
2436    }
2437
2438    #[test]
2439    fn with_tag() {
2440        let mut set = IntSet::<Tag>::empty();
2441
2442        set.insert(Tag::new(b"GSUB"));
2443        set.insert(Tag::new(b"CFF "));
2444        set.insert(Tag::new(b"OS/2"));
2445
2446        assert!(set.contains(Tag::new(b"GSUB")));
2447        assert!(!set.contains(Tag::new(b"GSU ")));
2448        assert!(set.contains(Tag::new(b"CFF ")));
2449        assert!(set.contains(Tag::new(b"OS/2")));
2450
2451        let copy: IntSet<Tag> = set.iter().collect();
2452        assert_eq!(set, copy);
2453
2454        set.invert();
2455
2456        assert!(!set.contains(Tag::new(b"GSUB")));
2457        assert!(set.contains(Tag::new(b"GSU ")));
2458        assert!(!set.contains(Tag::new(b"CFF ")));
2459        assert!(!set.contains(Tag::new(b"OS/2")));
2460    }
2461
2462    #[test]
2463    fn intersects_range() {
2464        let mut set = IntSet::<u32>::empty();
2465        assert!(!set.intersects_range(0..=0));
2466        assert!(!set.intersects_range(0..=100));
2467        assert!(!set.intersects_range(0..=u32::MAX));
2468        assert!(!set.intersects_range(u32::MAX..=u32::MAX));
2469
2470        set.insert(1234);
2471        assert!(!set.intersects_range(0..=1233));
2472        assert!(!set.intersects_range(1235..=1240));
2473
2474        assert!(set.intersects_range(1234..=1234));
2475        assert!(set.intersects_range(1230..=1240));
2476        assert!(set.intersects_range(0..=1234));
2477        assert!(set.intersects_range(1234..=u32::MAX));
2478
2479        set.insert(0);
2480        assert!(set.intersects_range(0..=0));
2481        assert!(!set.intersects_range(1..=1));
2482    }
2483
2484    #[test]
2485    fn intersects_set() {
2486        macro_rules! assert_intersects {
2487            ($lhs:path, $rhs:path, $expected:expr) => {
2488                assert_eq!($lhs.intersects_set(&$rhs), $expected);
2489                assert_eq!($rhs.intersects_set(&$lhs), $expected);
2490            };
2491        }
2492
2493        assert!(!IntSet::<u32>::empty().intersects_set(&IntSet::<u32>::empty()));
2494
2495        let empty = IntSet::<u32>::empty();
2496        let a = IntSet::from([1u32, 5, 6, 7, 8, 12]);
2497        let b = IntSet::from([2u32, 13]);
2498        let c = IntSet::from([8u32, 14]);
2499        let mut d = IntSet::all();
2500        d.remove_range(0u32..=13);
2501        let mut e = IntSet::all();
2502        e.remove_range(0u32..=100);
2503
2504        assert_intersects!(a, b, false);
2505        assert_intersects!(a, c, true);
2506        assert_intersects!(a, d, false);
2507
2508        assert_intersects!(b, c, false);
2509        assert_intersects!(b, d, false);
2510        assert_intersects!(b, e, false);
2511
2512        assert_intersects!(c, d, true);
2513        assert_intersects!(c, e, false);
2514
2515        assert_intersects!(d, e, true);
2516
2517        assert_intersects!(a, empty, false);
2518        assert_intersects!(b, empty, false);
2519        assert_intersects!(c, empty, false);
2520        assert_intersects!(d, empty, false);
2521        assert_intersects!(e, empty, false);
2522    }
2523
2524    #[test]
2525    fn intersects_range_discontinuous() {
2526        let mut set = IntSet::<EvenInts>::empty();
2527        assert!(!set.intersects_range(EvenInts(0)..=EvenInts(0)));
2528        assert!(!set.intersects_range(EvenInts(0)..=EvenInts(100)));
2529        assert!(!set.intersects_range(EvenInts(0)..=EvenInts(u16::MAX - 1)));
2530        assert!(!set.intersects_range(EvenInts(u16::MAX - 1)..=EvenInts(u16::MAX - 1)));
2531
2532        set.insert(EvenInts(1234));
2533        assert!(!set.intersects_range(EvenInts(0)..=EvenInts(1232)));
2534        assert!(!set.intersects_range(EvenInts(1236)..=EvenInts(1240)));
2535
2536        assert!(set.intersects_range(EvenInts(1234)..=EvenInts(1234)));
2537        assert!(set.intersects_range(EvenInts(1230)..=EvenInts(1240)));
2538        assert!(set.intersects_range(EvenInts(0)..=EvenInts(1234)));
2539        assert!(set.intersects_range(EvenInts(1234)..=EvenInts(u16::MAX - 1)));
2540
2541        set.insert(EvenInts(0));
2542        assert!(set.intersects_range(EvenInts(0)..=EvenInts(0)));
2543        assert!(!set.intersects_range(EvenInts(2)..=EvenInts(2)));
2544    }
2545
2546    #[test]
2547    fn intersects_range_exclusive() {
2548        let mut set = IntSet::<u32>::all();
2549        assert!(set.intersects_range(0..=0));
2550        assert!(set.intersects_range(0..=100));
2551        assert!(set.intersects_range(0..=u32::MAX));
2552        assert!(set.intersects_range(u32::MAX..=u32::MAX));
2553
2554        set.remove(1234);
2555        assert!(set.intersects_range(0..=1233));
2556        assert!(set.intersects_range(1235..=1240));
2557
2558        assert!(!set.intersects_range(1234..=1234));
2559        assert!(set.intersects_range(1230..=1240));
2560        assert!(set.intersects_range(0..=1234));
2561        assert!(set.intersects_range(1234..=u32::MAX));
2562
2563        set.remove(0);
2564        assert!(!set.intersects_range(0..=0));
2565        assert!(set.intersects_range(1..=1));
2566
2567        set.remove_range(5000..=5200);
2568        assert!(!set.intersects_range(5000..=5200));
2569        assert!(!set.intersects_range(5100..=5150));
2570        assert!(set.intersects_range(4999..=5200));
2571        assert!(set.intersects_range(5000..=5201));
2572    }
2573
2574    #[test]
2575    fn intersects_range_exclusive_discontinuous() {
2576        let mut set = IntSet::<EvenInts>::all();
2577        assert!(set.intersects_range(EvenInts(0)..=EvenInts(0)));
2578        assert!(set.intersects_range(EvenInts(0)..=EvenInts(100)));
2579        assert!(set.intersects_range(EvenInts(0)..=EvenInts(u16::MAX - 1)));
2580        assert!(set.intersects_range(EvenInts(u16::MAX - 1)..=EvenInts(u16::MAX - 1)));
2581
2582        set.remove(EvenInts(1234));
2583        assert!(set.intersects_range(EvenInts(0)..=EvenInts(1232)));
2584        assert!(set.intersects_range(EvenInts(1236)..=EvenInts(1240)));
2585
2586        assert!(!set.intersects_range(EvenInts(1234)..=EvenInts(1234)));
2587        assert!(set.intersects_range(EvenInts(1230)..=EvenInts(1240)));
2588        assert!(set.intersects_range(EvenInts(0)..=EvenInts(1234)));
2589        assert!(set.intersects_range(EvenInts(1234)..=EvenInts(u16::MAX - 1)));
2590
2591        set.remove(EvenInts(0));
2592        assert!(!set.intersects_range(EvenInts(0)..=EvenInts(0)));
2593        assert!(set.intersects_range(EvenInts(2)..=EvenInts(2)));
2594
2595        set.remove_range(EvenInts(5000)..=EvenInts(5200));
2596        assert!(!set.intersects_range(EvenInts(5000)..=EvenInts(5200)));
2597        assert!(!set.intersects_range(EvenInts(5100)..=EvenInts(5150)));
2598        assert!(set.intersects_range(EvenInts(4998)..=EvenInts(5200)));
2599        assert!(set.intersects_range(EvenInts(5000)..=EvenInts(5202)));
2600    }
2601
2602    #[test]
2603    fn length() {
2604        let mut s = IntSet::<u32>::empty();
2605        assert_eq!(s.len(), 0);
2606        s.insert(5);
2607        s.insert(5);
2608        s.insert(100);
2609        assert_eq!(s.len(), 2);
2610
2611        s.invert();
2612        assert_eq!(s.len(), (u32::MAX - 1) as u64);
2613
2614        assert_eq!(IntSet::<u32>::all().len(), (u32::MAX as u64) + 1);
2615
2616        let mut s = IntSet::<TwoParts>::all();
2617        assert_eq!(s.len(), 13);
2618        s.remove(TwoParts::from_u32(InDomain(5)));
2619        assert_eq!(s.len(), 12);
2620
2621        for v in TwoParts::ordered_values() {
2622            s.remove(TwoParts::from_u32(InDomain(v)));
2623        }
2624        assert_eq!(s.len(), 0);
2625    }
2626
2627    #[test]
2628    fn ordering() {
2629        macro_rules! assert_ord {
2630            ($lhs:expr, $rhs:expr, $ord:path) => {
2631                assert_eq!(
2632                    IntSet::from($lhs.clone()).cmp(&IntSet::from($rhs.clone())),
2633                    $ord,
2634                    "{:?}, {:?}",
2635                    $lhs,
2636                    $rhs
2637                )
2638            };
2639        }
2640
2641        const EMPTY: [u16; 0] = [];
2642        assert_ord!(EMPTY, EMPTY, Ordering::Equal);
2643        assert_ord!(EMPTY, [0], Ordering::Less);
2644        assert_ord!([0u16], [0], Ordering::Equal);
2645        assert_ord!([0u16, 1, 2], [1, 2, 3], Ordering::Less);
2646        assert_ord!([0u16, 1, 4], [1, 2, 3], Ordering::Less);
2647        assert_ord!([1u16, 2, 3], [0, 2, 4], Ordering::Greater);
2648        assert_ord!([5u16, 4, 0], [1, 2, 3], Ordering::Less); // out of order
2649        assert_ord!([1u16, 2, 3], [1, 2, 3, 4], Ordering::Less); // out of order
2650        assert_ord!([2u16, 3, 4], [1, 2, 3, 4, 5], Ordering::Greater); // out of order
2651
2652        // Exclusive - Exclusive
2653        let all = IntSet::<u16>::all();
2654        let mut all_but_0 = all.clone();
2655        all_but_0.remove(0);
2656        let mut all_but_5 = all.clone();
2657        all_but_5.remove(5);
2658
2659        assert_eq!(all.cmp(&all), Ordering::Equal);
2660        assert_eq!(all.cmp(&all_but_0), Ordering::Less);
2661        assert_eq!(all_but_0.cmp(&all), Ordering::Greater);
2662
2663        let mut a = IntSet::<u16>::all();
2664        a.remove_range(0..=5);
2665        a.remove_range(221..=1693);
2666        let mut b = IntSet::<u16>::all();
2667        b.remove_range(0..=1693);
2668        assert_eq!(a.cmp(&b), Ordering::Less);
2669
2670        // Mixed
2671        let mut inc_all_but_0 = IntSet::<u16>::empty();
2672        inc_all_but_0.insert_range(1..=u16::MAX);
2673        let mut inc_all_but_5 = IntSet::<u16>::empty();
2674        inc_all_but_5.insert_range(0..=4);
2675        inc_all_but_5.insert_range(6..=u16::MAX);
2676
2677        assert_eq!(all.cmp(&all), Ordering::Equal);
2678        assert_eq!(all.cmp(&inc_all_but_0), Ordering::Less);
2679        assert_eq!(inc_all_but_0.cmp(&all), Ordering::Greater);
2680        assert_eq!(inc_all_but_5.cmp(&all_but_0), Ordering::Less);
2681
2682        let mut a = IntSet::<u16>::all();
2683        a.remove_range(8..=1160);
2684        let mut b = IntSet::<u16>::empty();
2685        b.insert_range(0..=259);
2686
2687        assert_eq!(a.cmp(&b), Ordering::Greater);
2688
2689        let mut a = IntSet::<u16>::all();
2690        a.remove_range(8..=u16::MAX);
2691        let mut b = IntSet::<u16>::empty();
2692        b.insert_range(0..=259);
2693
2694        assert_eq!(a.cmp(&b), Ordering::Less);
2695    }
2696
2697    #[cfg(feature = "serde")]
2698    fn roundtrip_json<T: Domain>(set: &IntSet<T>) -> Result<IntSet<T>, serde_json::Error> {
2699        let json = serde_json::to_vec(&set).unwrap();
2700        serde_json::from_slice(&json)
2701    }
2702
2703    #[test]
2704    #[cfg(feature = "serde")]
2705    fn simple_serde() {
2706        let mut set = IntSet::empty();
2707        set.insert(0u32);
2708        set.insert(u32::MAX);
2709        assert_eq!(roundtrip_json(&set).unwrap(), set);
2710    }
2711
2712    #[test]
2713    #[cfg(feature = "serde")]
2714    fn serde_non_contiguous() {
2715        fn ev(val: u16) -> EvenInts {
2716            assert!(val % 2 == 0);
2717            EvenInts(val)
2718        }
2719        let set = IntSet::<EvenInts>::from([ev(2), ev(166), ev(u16::MAX - 1)]);
2720        assert_eq!(roundtrip_json(&set).unwrap(), set);
2721    }
2722
2723    #[test]
2724    #[cfg(feature = "serde")]
2725    #[should_panic(expected = "out of range for domain")]
2726    fn serde_non_contiguous_out_of_domain() {
2727        let set = IntSet::from([1u16, 2, 3, 4, 5, 6, 7]);
2728        let bytes = serde_json::to_vec(&set).unwrap();
2729        serde_json::from_slice::<IntSet<EvenInts>>(&bytes).unwrap();
2730    }
2731
2732    #[test]
2733    #[cfg(feature = "serde")]
2734    fn non_contiguous_inverted() {
2735        let all = IntSet::<u16>::all();
2736        let bytes = serde_json::to_vec(&all).unwrap();
2737        let readback: IntSet<EvenInts> = serde_json::from_slice(&bytes).unwrap();
2738        let mut iter = readback.iter().map(|v| v.0);
2739        let mut values = (&mut iter).take(5).collect::<Vec<_>>();
2740        values.extend(iter.rev().take(5));
2741
2742        assert_eq!(values, [0, 2, 4, 6, 8, 65534, 65532, 65530, 65528, 65526])
2743    }
2744
2745    #[test]
2746    #[cfg(feature = "serde")]
2747    fn serde_inverted() {
2748        let mut set = IntSet::all();
2749        set.remove_range(0u16..=420);
2750        let bytes = serde_json::to_string(&set).unwrap();
2751        assert!(bytes.len() < 5000, "sanity check serialization");
2752        assert_eq!(roundtrip_json(&set).unwrap(), set)
2753    }
2754
2755    #[test]
2756    #[cfg(feature = "serde")]
2757    fn serde_inverted_out_of_domain() {
2758        let mut set = IntSet::all();
2759        set.remove_range(0u16..=250);
2760        let bytes = serde_json::to_string(&set).unwrap();
2761        let readback: IntSet<u8> = serde_json::from_str(&bytes).unwrap();
2762        assert_eq!(readback.len(), 5);
2763        assert_eq!(
2764            readback.iter().collect::<Vec<_>>(),
2765            [251, 252, 253, 254, 255]
2766        );
2767    }
2768
2769    #[test]
2770    #[cfg(feature = "serde")]
2771    #[should_panic(expected = "out of range for domain")]
2772    fn serde_out_of_domain() {
2773        let set = IntSet::from([u32::MAX]);
2774        let json = serde_json::to_vec(&set).unwrap();
2775        serde_json::from_slice::<IntSet<GlyphId16>>(&json).unwrap();
2776    }
2777}