1use alloc::{
4 borrow::{
5 Cow,
6 ToOwned,
7 },
8 vec::Vec,
9};
10use core::{
11 borrow::{
12 Borrow,
13 BorrowMut,
14 },
15 cmp,
16 convert::TryFrom,
17 fmt::{
18 self,
19 Debug,
20 Display,
21 Formatter,
22 },
23 hash::{
24 Hash,
25 Hasher,
26 },
27 marker::Unpin,
28};
29
30use super::BitVec;
31use crate::{
32 array::BitArray,
33 boxed::BitBox,
34 order::BitOrder,
35 slice::BitSlice,
36 store::BitStore,
37 view::BitViewSized,
38};
39
40#[cfg(not(tarpaulin_include))]
41impl<T, O> Borrow<BitSlice<T, O>> for BitVec<T, O>
42where
43 T: BitStore,
44 O: BitOrder,
45{
46 #[inline]
47 fn borrow(&self) -> &BitSlice<T, O> {
48 self.as_bitslice()
49 }
50}
51
52#[cfg(not(tarpaulin_include))]
53impl<T, O> BorrowMut<BitSlice<T, O>> for BitVec<T, O>
54where
55 T: BitStore,
56 O: BitOrder,
57{
58 #[inline]
59 fn borrow_mut(&mut self) -> &mut BitSlice<T, O> {
60 self.as_mut_bitslice()
61 }
62}
63
64#[cfg(not(tarpaulin_include))]
65impl<T, O> Clone for BitVec<T, O>
66where
67 T: BitStore,
68 O: BitOrder,
69{
70 #[inline]
71 fn clone(&self) -> Self {
72 Self::from_bitslice(self.as_bitslice())
73 }
74}
75
76impl<T, O> Eq for BitVec<T, O>
77where
78 T: BitStore,
79 O: BitOrder,
80{
81}
82
83#[cfg(not(tarpaulin_include))]
84impl<T, O> Ord for BitVec<T, O>
85where
86 T: BitStore,
87 O: BitOrder,
88{
89 #[inline]
90 fn cmp(&self, other: &Self) -> cmp::Ordering {
91 self.as_bitslice().cmp(other.as_bitslice())
92 }
93}
94
95#[cfg(not(tarpaulin_include))]
96impl<T1, T2, O1, O2> PartialEq<BitVec<T2, O2>> for BitSlice<T1, O1>
97where
98 T1: BitStore,
99 T2: BitStore,
100 O1: BitOrder,
101 O2: BitOrder,
102{
103 #[inline]
104 fn eq(&self, other: &BitVec<T2, O2>) -> bool {
105 self == other.as_bitslice()
106 }
107}
108
109#[cfg(not(tarpaulin_include))]
110impl<T1, T2, O1, O2> PartialEq<BitVec<T2, O2>> for &BitSlice<T1, O1>
111where
112 T1: BitStore,
113 T2: BitStore,
114 O1: BitOrder,
115 O2: BitOrder,
116{
117 #[inline]
118 fn eq(&self, other: &BitVec<T2, O2>) -> bool {
119 *self == other.as_bitslice()
120 }
121}
122
123#[cfg(not(tarpaulin_include))]
124impl<T1, T2, O1, O2> PartialEq<BitVec<T2, O2>> for &mut BitSlice<T1, O1>
125where
126 T1: BitStore,
127 T2: BitStore,
128 O1: BitOrder,
129 O2: BitOrder,
130{
131 #[inline]
132 fn eq(&self, other: &BitVec<T2, O2>) -> bool {
133 **self == other.as_bitslice()
134 }
135}
136
137#[cfg(not(tarpaulin_include))]
138impl<T, O, Rhs> PartialEq<Rhs> for BitVec<T, O>
139where
140 T: BitStore,
141 O: BitOrder,
142 Rhs: ?Sized + PartialEq<BitSlice<T, O>>,
143{
144 #[inline]
145 fn eq(&self, other: &Rhs) -> bool {
146 other == self.as_bitslice()
147 }
148}
149
150#[cfg(not(tarpaulin_include))]
151impl<T1, T2, O1, O2> PartialOrd<BitVec<T2, O2>> for BitSlice<T1, O1>
152where
153 T1: BitStore,
154 T2: BitStore,
155 O1: BitOrder,
156 O2: BitOrder,
157{
158 #[inline]
159 fn partial_cmp(&self, other: &BitVec<T2, O2>) -> Option<cmp::Ordering> {
160 self.partial_cmp(other.as_bitslice())
161 }
162}
163
164#[cfg(not(tarpaulin_include))]
165impl<'a, T1, T2, O1, O2> PartialOrd<BitVec<T2, O2>> for &'a BitSlice<T1, O1>
166where
167 T1: BitStore,
168 T2: BitStore,
169 O1: BitOrder,
170 O2: BitOrder,
171{
172 #[inline]
173 fn partial_cmp(&self, other: &BitVec<T2, O2>) -> Option<cmp::Ordering> {
174 self.partial_cmp(other.as_bitslice())
175 }
176}
177
178#[cfg(not(tarpaulin_include))]
179impl<'a, T1, T2, O1, O2> PartialOrd<BitVec<T2, O2>> for &'a mut BitSlice<T1, O1>
180where
181 T1: BitStore,
182 T2: BitStore,
183 O1: BitOrder,
184 O2: BitOrder,
185{
186 #[inline]
187 fn partial_cmp(&self, other: &BitVec<T2, O2>) -> Option<cmp::Ordering> {
188 self.partial_cmp(other.as_bitslice())
189 }
190}
191
192#[cfg(not(tarpaulin_include))]
193impl<T, O, Rhs> PartialOrd<Rhs> for BitVec<T, O>
194where
195 T: BitStore,
196 O: BitOrder,
197 Rhs: ?Sized + PartialOrd<BitSlice<T, O>>,
198{
199 #[inline]
200 fn partial_cmp(&self, other: &Rhs) -> Option<cmp::Ordering> {
201 other.partial_cmp(self.as_bitslice())
202 }
203}
204
205#[cfg(not(tarpaulin_include))]
206impl<T, O> AsRef<BitSlice<T, O>> for BitVec<T, O>
207where
208 T: BitStore,
209 O: BitOrder,
210{
211 #[inline]
212 fn as_ref(&self) -> &BitSlice<T, O> {
213 self.as_bitslice()
214 }
215}
216
217#[cfg(not(tarpaulin_include))]
218impl<T, O> AsMut<BitSlice<T, O>> for BitVec<T, O>
219where
220 T: BitStore,
221 O: BitOrder,
222{
223 #[inline]
224 fn as_mut(&mut self) -> &mut BitSlice<T, O> {
225 self.as_mut_bitslice()
226 }
227}
228
229#[cfg(not(tarpaulin_include))]
230impl<T, O> AsRef<BitVec<T, O>> for BitVec<T, O>
231where
232 T: BitStore,
233 O: BitOrder,
234{
235 #[inline]
236 fn as_ref(&self) -> &Self {
237 self
238 }
239}
240
241#[cfg(not(tarpaulin_include))]
242impl<T, O> AsMut<BitVec<T, O>> for BitVec<T, O>
243where
244 T: BitStore,
245 O: BitOrder,
246{
247 #[inline]
248 fn as_mut(&mut self) -> &mut Self {
249 self
250 }
251}
252
253#[cfg(not(tarpaulin_include))]
254impl<T, O> From<&'_ BitSlice<T, O>> for BitVec<T, O>
255where
256 T: BitStore,
257 O: BitOrder,
258{
259 #[inline]
260 fn from(slice: &BitSlice<T, O>) -> Self {
261 Self::from_bitslice(slice)
262 }
263}
264
265#[cfg(not(tarpaulin_include))]
266impl<T, O> From<&'_ mut BitSlice<T, O>> for BitVec<T, O>
267where
268 T: BitStore,
269 O: BitOrder,
270{
271 #[inline]
272 fn from(slice: &mut BitSlice<T, O>) -> Self {
273 Self::from_bitslice(slice)
274 }
275}
276
277#[cfg(not(tarpaulin_include))]
278impl<A, O> From<BitArray<A, O>> for BitVec<A::Store, O>
279where
280 O: BitOrder,
281 A: BitViewSized,
282{
283 #[inline]
284 fn from(array: BitArray<A, O>) -> Self {
285 array.as_bitslice().to_owned()
286 }
287}
288
289#[cfg(not(tarpaulin_include))]
290impl<T, O> From<BitBox<T, O>> for BitVec<T, O>
291where
292 T: BitStore,
293 O: BitOrder,
294{
295 #[inline]
296 fn from(boxed: BitBox<T, O>) -> Self {
297 boxed.into_bitvec()
298 }
299}
300
301#[cfg(not(tarpaulin_include))]
302impl<T, O> From<BitVec<T, O>> for Vec<T>
303where
304 T: BitStore,
305 O: BitOrder,
306{
307 #[inline]
308 fn from(bv: BitVec<T, O>) -> Self {
309 bv.into_vec()
310 }
311}
312
313#[cfg(not(tarpaulin_include))]
314impl<'a, T, O> From<Cow<'a, BitSlice<T, O>>> for BitVec<T, O>
315where
316 O: BitOrder,
317 T: 'a + BitStore,
318{
319 #[inline]
320 fn from(cow: Cow<'a, BitSlice<T, O>>) -> Self {
321 cow.into_owned()
322 }
323}
324
325#[cfg(not(tarpaulin_include))]
326impl<T, O> TryFrom<Vec<T>> for BitVec<T, O>
327where
328 T: BitStore,
329 O: BitOrder,
330{
331 type Error = Vec<T>;
332
333 #[inline]
334 fn try_from(vec: Vec<T>) -> Result<Self, Self::Error> {
335 Self::try_from_vec(vec)
336 }
337}
338
339#[cfg(not(tarpaulin_include))]
340impl<T, O> Default for BitVec<T, O>
341where
342 T: BitStore,
343 O: BitOrder,
344{
345 #[inline]
346 fn default() -> Self {
347 Self::new()
348 }
349}
350
351impl<T, O> Debug for BitVec<T, O>
352where
353 T: BitStore,
354 O: BitOrder,
355{
356 #[inline]
357 fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
358 self.as_bitspan().render(fmt, "Vec", &[(
359 "capacity",
360 &self.capacity() as &dyn Debug,
361 )])?;
362 fmt.write_str(" ")?;
363 Display::fmt(self, fmt)
364 }
365}
366
367easy_fmt! {
368 impl Binary
369 impl Display
370 impl LowerHex
371 impl Octal
372 impl Pointer
373 impl UpperHex
374 for BitVec
375}
376
377#[cfg(not(tarpaulin_include))]
378impl<T, O> Hash for BitVec<T, O>
379where
380 T: BitStore,
381 O: BitOrder,
382{
383 #[inline]
384 fn hash<H>(&self, state: &mut H)
385 where H: Hasher {
386 self.as_bitslice().hash(state)
387 }
388}
389
390unsafe impl<T, O> Send for BitVec<T, O>
391where
392 T: BitStore,
393 O: BitOrder,
394{
395}
396
397unsafe impl<T, O> Sync for BitVec<T, O>
398where
399 T: BitStore,
400 O: BitOrder,
401{
402}
403
404impl<T, O> Unpin for BitVec<T, O>
405where
406 T: BitStore,
407 O: BitOrder,
408{
409}