1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
//! Miscellaneous foreign trait implementations for [`BitSet`].
use crate::*;
use core::{any::type_name, cmp::Ordering, fmt};
impl<W: Word> Default for BitSet<W> {
#[inline]
fn default() -> Self {
Self(W::ZERO)
}
}
impl<W: Word> PartialOrd for BitSet<W> {
/// Test for a subset relation.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// assert_eq!(set![1, 2] <= set![1, 2], true);
/// assert_eq!(set![1, 2] < set![1, 2], false);
/// assert_eq!(set![1, 2] <= set![1, 2, 3], true);
/// assert_eq!(set![1, 2] < set![1, 2, 3], true);
/// ```
#[inline]
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
if self == other {
Some(Ordering::Equal)
} else if self.is_subset(*other) {
Some(Ordering::Less)
} else if self.is_superset(*other) {
Some(Ordering::Greater)
} else {
None
}
}
}
impl<W: Word> Extend<Element> for BitSet<W> {
/// Extend the set with elements from an iterator.
///
/// # Panics
///
/// If any element is greater than [`Self::MAX`].
#[inline]
fn extend<I: IntoIterator<Item = Element>>(&mut self, iter: I) {
self.union_update(
Self::try_from_iter(iter).expect("cannot extend with an irrepresentable element"),
);
}
}
impl<W: Word> IntoIterator for BitSet<W> {
type Item = Element;
type IntoIter = BitSetIter<W>;
/// An iterator over the elements in ascending order.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// let set = set![7, 3..=5, 1];
/// assert!(set.into_iter().eq([1, 3, 4, 5, 7]));
/// ```
#[inline]
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
impl<W: Word> IntoIterator for &BitSet<W> {
type Item = Element;
type IntoIter = BitSetIter<W>;
/// An iterator over the elements in ascending order.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// let set = set![7, 3..=5, 1];
/// assert!((&set).into_iter().eq([1, 3, 4, 5, 7])); // Still yields elements by value.
/// ```
#[inline]
fn into_iter(self) -> Self::IntoIter {
(*self).iter()
}
}
impl<W: Word> fmt::Display for BitSet<W> {
/// Pretty-format a bitset.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// let set = set![0, 10, 1, 20];
/// assert_eq!(format!("{}", set), "{0, 1, 10, 20}");
/// ```
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_set().entries(self.iter()).finish()
}
}
struct DebugElements<W: Word>(BitSet<W>);
impl<W: Word> fmt::Debug for DebugElements<W> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&self.0, f)
}
}
impl<W: Word> fmt::Debug for BitSet<W> {
/// Debug-format a bitset.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// let set = set![0, 10, 1, 20];
/// assert_eq!(format!("{:?}", set), "BitSet<usize>({0, 1, 10, 20})");
/// ```
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let name = type_name::<Self>();
let cut = name[..name.find('<').unwrap_or(name.len())]
.rfind("::")
.map_or(0, |index| index + 2);
f.debug_tuple(&name[cut..])
.field(&DebugElements(*self))
.finish()
}
}