1mod 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#[derive(Clone)]
39pub struct IntSet<T>(Membership, PhantomData<T>);
40
41pub trait Domain: Sized + Copy {
57 fn to_u32(&self) -> u32;
61
62 fn contains(value: u32) -> bool;
64
65 fn from_u32(member: InDomain) -> Self;
69
70 fn is_continuous() -> bool;
72
73 fn ordered_values() -> impl DoubleEndedIterator<Item = u32>;
78
79 fn ordered_values_range(range: RangeInclusive<Self>) -> impl DoubleEndedIterator<Item = u32>;
84
85 fn count() -> u64;
87}
88
89pub struct InDomain(u32);
93
94#[derive(Clone, Debug, Hash, PartialEq, Eq)]
95#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
96enum Membership {
97 Inclusive(U32Set),
99
100 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 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 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 let mut it = Iter::new(s.iter_from(u32::MAX), None);
158 it.next();
159 it
160 }
161 }
162 }
163 }
164
165 pub fn iter_after(&self, value: T) -> impl Iterator<Item = T> + '_ {
170 self.range((Bound::Excluded(value), Bound::Unbounded))
171 }
172
173 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 pub fn iter_ranges(&self) -> impl Iterator<Item = RangeInclusive<T>> + '_ {
200 self.iter_ranges_invertible(false)
201 }
202
203 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 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 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 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 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 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 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 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 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 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 pub fn intersects_range(&self, range: RangeInclusive<T>) -> bool {
364 self.range(range).next().is_some()
365 }
366
367 pub fn intersects_set(&self, other: &IntSet<T>) -> bool {
369 let (a, b) = match (&self.0, &other.0) {
372 (Membership::Inclusive(us), Membership::Inclusive(them)) => {
373 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 pub fn first(&self) -> Option<T> {
399 return self.iter().next();
400 }
401
402 pub fn last(&self) -> Option<T> {
404 return self.iter().next_back();
405 }
406
407 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 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 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 pub const fn new() -> Self {
441 Self::empty()
442 }
443
444 pub const fn empty() -> Self {
446 IntSet(Membership::Inclusive(U32Set::empty()), PhantomData::<T>)
447 }
448
449 pub const fn all() -> Self {
451 IntSet(Membership::Exclusive(U32Set::empty()), PhantomData::<T>)
452 }
453
454 pub fn is_inverted(&self) -> bool {
456 match &self.0 {
457 Membership::Inclusive(_) => false,
458 Membership::Exclusive(_) => true,
459 }
460 }
461
462 pub fn invert(&mut self) {
464 let reuse_storage = match &mut self.0 {
465 Membership::Inclusive(s) | Membership::Exclusive(s) => {
468 std::mem::replace(s, U32Set::empty())
469 }
470 };
471
472 self.0 = match &mut self.0 {
474 Membership::Inclusive(_) => Membership::Exclusive(reuse_storage),
475 Membership::Exclusive(_) => Membership::Inclusive(reuse_storage),
476 };
477 }
478
479 pub fn clear(&mut self) {
481 let mut reuse_storage = match &mut self.0 {
482 Membership::Inclusive(s) => {
484 s.clear();
485 return;
486 }
487 Membership::Exclusive(s) => std::mem::replace(s, U32Set::empty()),
490 };
491 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 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 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 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 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 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 if let Some(skip) = self.next_skipped_backward {
758 if skip == index {
759 break;
761 }
762 }
763 return Some(index);
765 };
766
767 if index < skip {
768 return Some(index);
770 }
771
772 self.next_skipped_forward = self.set_values.next();
773 if index > skip {
774 continue;
776 }
777
778 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 if let Some(skip) = self.next_skipped_forward {
803 if skip == index {
804 break;
806 }
807 }
808 return Some(index);
810 };
811
812 if index > skip {
813 return Some(index);
815 }
816
817 self.next_skipped_backward = self.set_values.next_back();
818 if index < skip {
819 continue;
821 }
822
823 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 let Some(next_range) = ranges.next() else {
880 return current_range.take();
882 };
883
884 let Some(range) = current_range.clone() else {
885 *current_range = Some(next_range);
887 continue;
888 };
889
890 if RangeIter::<InclusiveRangeIter, AllValuesIter, T>::are_values_adjacent(
892 *range.end(),
893 *next_range.start(),
894 ) {
895 *current_range = Some(*range.start()..=*next_range.end());
897 continue;
898 }
899
900 *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 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 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 return current_range;
983 };
984
985 if set.contains(next) {
986 if let Some(range) = current_range {
987 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(); if let Some(second) = it.next() {
1006 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)] 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 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 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 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 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); assert_ord!([1u16, 2, 3], [1, 2, 3, 4], Ordering::Less); assert_ord!([2u16, 3, 4], [1, 2, 3, 4, 5], Ordering::Greater); 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 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}