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
//! Conversion methods between [`BitSet`] and [`Vec`].
extern crate alloc;
use crate::*;
use alloc::vec::Vec;
impl<W: Word> BitSet<W> {
/// The elements as a sorted vector of type [`Vec<Element>`].
///
/// Available with the `alloc` feature, which is enabled by default.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// assert_eq!(set![3, 2, 1].to_vec(), vec![1, 2, 3]);
/// ```
///
/// # Alternatives
///
/// To produce a [`Vec<T>`] for another builtin integer type `T`, use [`into`](Into::into) or
/// [`from`](From::from) with a type hint. These infallible conversions are only implemented for
/// [`BitSet<W>`] when `W` is itself a builtin unsigned integer type. For other [`Word`] types,
/// use [`to_vec`](BitSet::to_vec) and convert.
///
/// ```
/// # use pibs::prelude::*;
/// let set = set128![127, 5, 23];
///
/// // Via BitSet::into.
/// let vec: Vec<i8> = set.into();
/// assert_eq!(vec, vec![5, 23, 127]);
///
/// // Via Vec::from.
/// let vec = Vec::<i8>::from(set);
/// assert_eq!(vec, vec![5, 23, 127]);
/// ```
#[inline]
pub fn to_vec(self) -> Vec<Element> {
self.iter().collect()
}
}
impl<W: Word, T> TryFrom<Vec<T>> for BitSet<W>
where
T: PrimInt + TryInto<Element>,
{
type Error = Error;
/// Try to create a [`BitSet`] from a vector.
///
/// Available with the `alloc` feature, which is enabled by default.
///
/// # Errors
///
/// If any vector element fails to convert to an [`Element`] or is greater than [`Self::MAX`].
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// use pibs::Error::Irrepresentable;
///
/// assert_eq!(Set::try_from(vec![2, 4, 6]), Ok(set![2, 4, 6]));
/// assert_eq!(Set::try_from(vec![-2, 4, 6]), Err(Irrepresentable));
/// assert_eq!(Set::try_from(vec![10_000]), Err(Irrepresentable));
/// ```
#[inline]
fn try_from(vec: Vec<T>) -> Result<Self, Self::Error> {
Self::try_from_iter(vec)
}
}
impl<W: Word, T> TryFrom<&Vec<T>> for BitSet<W>
where
T: PrimInt + TryInto<Element>,
{
type Error = Error;
/// Try to create a [`BitSet`] from a vector by reference.
///
/// Available with the `alloc` feature, which is enabled by default.
///
/// # Errors
///
/// If any vector element fails to convert to an [`Element`] or is greater than [`Self::MAX`].
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// use pibs::Error::Irrepresentable;
///
/// assert_eq!(Set::try_from(&vec![2, 4, 6]), Ok(set![2, 4, 6]));
/// assert_eq!(Set::try_from(&vec![-2, 4, 6]), Err(Irrepresentable));
/// assert_eq!(Set::try_from(&vec![10_000]), Err(Irrepresentable));
/// ```
#[inline]
fn try_from(vec: &Vec<T>) -> Result<Self, Self::Error> {
Self::try_from_iter(vec.iter().copied())
}
}
macro_rules! impl_vec_from_bitset {
(@to $word:ty; $($target:ty),+) => {
$(
#[doc(hidden)]
impl From<BitSet<$word>> for Vec<$target> {
/// Create a sorted [`Vec`] from a [`BitSet`].
#[inline]
fn from(set: BitSet<$word>) -> Self {
// This is lossless as any element in a BitSet<u128> can fit in a i8.
set.into_iter().map(|e| e as $target).collect()
}
}
)+
};
(@from $word:ty) => {
impl_vec_from_bitset!(
@to $word;
u8, u16, u32, u64, u128, usize,
i8, i16, i32, i64, i128, isize
);
};
($($word:ty),+) => {
$(impl_vec_from_bitset!(@from $word);)+
};
}
impl_vec_from_bitset!(u8, u16, u32, u64, u128, usize);