bittle/bits.rs
1//! Traits which define the behaviors of a bit set.
2
3mod join_ones;
4use crate::endian::{BigEndian, DefaultEndian, Endian, LittleEndian};
5
6pub use self::join_ones::JoinOnes;
7
8mod sealed {
9 pub trait Sealed {}
10
11 impl<T> Sealed for &mut T where T: ?Sized + crate::Bits {}
12 impl<T> Sealed for &T where T: ?Sized + crate::Bits {}
13 impl<T> Sealed for [T] {}
14 impl<T, const N: usize> Sealed for [T; N] {}
15 impl<T, E> Sealed for crate::set::Set<T, E> where T: ?Sized {}
16}
17
18pub(crate) use self::sealed::Sealed;
19
20/// Bitset immutable operations.
21///
22/// This is implemented for primitive types such as:
23/// * [`usize`], [`u32`], [`u64`], and other signed numbers.
24/// * Arrays made up of numerical primitives, such as `[u32; 32]`.
25/// * Slices of numerical primitives, such as `&[u32]`.
26///
27/// Also see the associated sibling traits:
28///
29/// * [`BitsMut`] for mutable operations.
30/// * [`BitsOwned`] for owned operations.
31///
32/// [`BitsMut`]: crate::BitsMut
33/// [`BitsOwned`]: crate::BitsOwned
34///
35/// # Examples
36///
37/// We can use the iterator of each set to compare bit sets of different kinds.
38/// The [`Bits::iter_ones`] iterator is guaranteed to iterate elements in the
39/// same order:
40///
41/// ```
42/// use bittle::{Bits, BitsMut};
43///
44/// let a: [u64; 2] = bittle::set![111];
45/// let mut b = 0u128;
46///
47/// assert!(!a.iter_ones().eq(b.iter_ones()));
48/// b.set_bit(111);
49/// assert!(a.iter_ones().eq(b.iter_ones()));
50/// ```
51pub trait Bits: Sealed {
52 /// The iterator over zeros in this bit pattern using [`DefaultEndian`]
53 /// indexing.
54 ///
55 /// See [`Bits::iter_ones`].
56 ///
57 /// [`DefaultEndian`]: crate::DefaultEndian
58 type IterOnes<'a>: Iterator<Item = u32>
59 where
60 Self: 'a;
61
62 /// The iterator over ones in this bit pattern using custom [`Endian`]
63 /// indexing.
64 ///
65 /// See [`Bits::iter_ones_in`].
66 type IterOnesIn<'a, E>: Iterator<Item = u32>
67 where
68 Self: 'a,
69 E: Endian;
70
71 /// The iterator over zeros in this bit pattern using [`DefaultEndian`]
72 /// indexing.
73 ///
74 /// See [`Bits::iter_zeros`].
75 ///
76 /// [`DefaultEndian`]: crate::DefaultEndian
77 type IterZeros<'a>: Iterator<Item = u32>
78 where
79 Self: 'a;
80
81 /// The iterator over zeros in this bit pattern using custom [`Endian`]
82 /// indexing.
83 ///
84 /// See [`Bits::iter_zeros_in`].
85 type IterZerosIn<'a, E>: Iterator<Item = u32>
86 where
87 Self: 'a,
88 E: Endian;
89
90 /// Get the number of ones in the set.
91 ///
92 /// # Examples
93 ///
94 /// ```
95 /// use bittle::{Bits, BitsMut};
96 ///
97 /// let mut a = 0u128;
98 /// assert_eq!(a.count_ones(), 0);
99 /// a.set_bit(4);
100 /// assert_eq!(a.count_ones(), 1);
101 /// ```
102 ///
103 /// Using a larger set:
104 ///
105 /// ```
106 /// use bittle::{Bits, BitsMut};
107 ///
108 /// let mut a = [0u128, 0];
109 /// assert_eq!(a.count_ones(), 0);
110 /// a.set_bit(240);
111 /// assert_eq!(a.count_ones(), 1);
112 /// ```
113 fn count_ones(&self) -> u32;
114
115 /// Get the number of ones in the set.
116 ///
117 /// # Examples
118 ///
119 /// ```
120 /// use bittle::{Bits, BitsMut};
121 ///
122 /// let mut a = 0u128;
123 /// assert_eq!(a.count_zeros(), 128);
124 /// a.set_bit(4);
125 /// assert_eq!(a.count_zeros(), 127);
126 /// ```
127 ///
128 /// Using a larger set:
129 ///
130 /// ```
131 /// use bittle::{Bits, BitsMut};
132 ///
133 /// let mut a = [0u128, 0];
134 /// assert_eq!(a.count_zeros(), 256);
135 /// a.set_bit(240);
136 /// assert_eq!(a.count_zeros(), 255);
137 /// ```
138 fn count_zeros(&self) -> u32;
139
140 /// Get the capacity of the underlying set.
141 ///
142 /// # Examples
143 ///
144 /// ```
145 /// use bittle::Bits;
146 ///
147 /// let mut set = 0u128;
148 /// assert_eq!(set.bits_capacity(), 128);
149 /// ```
150 ///
151 /// Using a larger set:
152 ///
153 /// ```
154 /// use bittle::Bits;
155 ///
156 /// let mut set = [0u128, 0];
157 /// assert_eq!(set.bits_capacity(), 256);
158 /// ```
159 fn bits_capacity(&self) -> u32;
160
161 /// Test if this set is empty, or all zeros.
162 ///
163 /// # Examples
164 ///
165 /// ```
166 /// use bittle::Bits;
167 ///
168 /// let a: u32 = bittle::set![];
169 /// assert!(a.all_zeros());
170 ///
171 /// let a: u32 = bittle::set![1];
172 /// assert!(!a.all_zeros());
173 /// ```
174 ///
175 /// Using a larger set:
176 ///
177 /// ```
178 /// use bittle::Bits;
179 ///
180 /// let a: [u32; 2] = bittle::set![];
181 /// assert!(a.all_zeros());
182 ///
183 /// let a: [u32; 2] = bittle::set![55];
184 /// assert!(!a.all_zeros());
185 /// ```
186 fn all_zeros(&self) -> bool;
187
188 /// Test if bit set is full, or all ones.
189 ///
190 /// # Examples
191 ///
192 /// ```
193 /// use bittle::{Bits, BitsMut, BitsOwned};
194 ///
195 /// let mut set = u128::ones();
196 /// assert!(set.all_ones());
197 /// set.clear_bit(4);
198 /// assert!(!set.all_ones());
199 /// ```
200 fn all_ones(&self) -> bool;
201
202 /// Test if the given bit is set using [`DefaultEndian`] indexing.
203 ///
204 /// Indexes which are out of bounds will wrap around in the bitset.
205 ///
206 /// [`DefaultEndian`]: crate::DefaultEndian
207 ///
208 /// # Examples
209 ///
210 /// ```
211 /// use bittle::Bits;
212 ///
213 /// let a: u32 = bittle::set![];
214 /// assert!(!a.test_bit(32));
215 ///
216 /// let a: u32 = bittle::set![32];
217 /// assert!(a.test_bit(32));
218 /// ```
219 ///
220 /// Using a larger set:
221 ///
222 /// ```
223 /// use bittle::Bits;
224 ///
225 /// let a: [u32; 2] = bittle::set![];
226 /// assert!(!a.test_bit(55));
227 ///
228 /// let a: [u32; 2] = bittle::set![55];
229 /// assert!(a.test_bit(55));
230 /// ```
231 fn test_bit(&self, index: u32) -> bool;
232
233 /// Test if the given bit is set using custom [`Endian`] indexing.
234 ///
235 /// Indexes which are out of bounds will wrap around in the bitset.
236 ///
237 /// # Examples
238 ///
239 /// ```
240 /// use bittle::{Bits, LittleEndian};
241 ///
242 /// let a: u32 = bittle::set_le![];
243 /// assert!(!a.test_bit_in::<LittleEndian>(32));
244 ///
245 /// let a: u32 = bittle::set_le![32];
246 /// assert!(a.test_bit_in::<LittleEndian>(32));
247 /// ```
248 ///
249 /// Using a larger set:
250 ///
251 /// ```
252 /// use bittle::{Bits, LittleEndian};
253 ///
254 /// let a: [u32; 2] = bittle::set_le![];
255 /// assert!(!a.test_bit_in::<LittleEndian>(55));
256 ///
257 /// let a: [u32; 2] = bittle::set_le![55];
258 /// assert!(a.test_bit_in::<LittleEndian>(55));
259 /// ```
260 fn test_bit_in<E>(&self, index: u32) -> bool
261 where
262 E: Endian;
263
264 /// Test if the given bit is set using [`LittleEndian`] indexing.
265 ///
266 /// Indexes which are out of bounds will wrap around in the bitset.
267 ///
268 /// # Examples
269 ///
270 /// ```
271 /// use bittle::Bits;
272 ///
273 /// let a: u32 = bittle::set_le![];
274 /// assert!(!a.test_bit_le(32));
275 ///
276 /// let a: u32 = bittle::set_le![32];
277 /// assert!(a.test_bit_le(32));
278 /// ```
279 ///
280 /// Using a larger set:
281 ///
282 /// ```
283 /// use bittle::Bits;
284 ///
285 /// let a: [u32; 2] = bittle::set_le![];
286 /// assert!(!a.test_bit_le(55));
287 ///
288 /// let a: [u32; 2] = bittle::set_le![55];
289 /// assert!(a.test_bit_le(55));
290 /// ```
291 #[inline]
292 fn test_bit_le(&self, index: u32) -> bool {
293 self.test_bit_in::<LittleEndian>(index)
294 }
295
296 /// Test if the given bit is set using [`BigEndian`] indexing.
297 ///
298 /// Indexes which are out of bounds will wrap around in the bitset.
299 ///
300 /// # Examples
301 ///
302 /// ```
303 /// use bittle::Bits;
304 ///
305 /// let a: u32 = bittle::set_be![];
306 /// assert!(!a.test_bit_be(32));
307 ///
308 /// let a: u32 = bittle::set_be![32];
309 /// assert!(a.test_bit_be(32));
310 /// ```
311 ///
312 /// Using a larger set:
313 ///
314 /// ```
315 /// use bittle::Bits;
316 ///
317 /// let a: [u32; 2] = bittle::set_be![];
318 /// assert!(!a.test_bit_be(55));
319 ///
320 /// let a: [u32; 2] = bittle::set_be![55];
321 /// assert!(a.test_bit_be(55));
322 /// ```
323 #[inline]
324 fn test_bit_be(&self, index: u32) -> bool {
325 self.test_bit_in::<BigEndian>(index)
326 }
327
328 /// Construct an iterator over ones in the bit set using [`DefaultEndian`]
329 /// indexing.
330 ///
331 /// Will iterate through elements from smallest to largest index.
332 ///
333 /// [`DefaultEndian`]: crate::DefaultEndian
334 ///
335 /// # Examples
336 ///
337 /// ```
338 /// use bittle::Bits;
339 ///
340 /// let set: u128 = bittle::set![3, 7];
341 /// assert!(set.iter_ones().eq([3, 7]));
342 /// ```
343 ///
344 /// A larger bit set:
345 ///
346 /// ```
347 /// use bittle::Bits;
348 ///
349 /// let set: [u32; 4] = bittle::set![4, 67, 71, 127];
350 /// assert!(set.iter_ones().eq([4, 67, 71, 127]));
351 /// assert!(set.iter_ones().rev().eq([127, 71, 67, 4]));
352 /// ```
353 fn iter_ones(&self) -> Self::IterOnes<'_>;
354
355 /// Construct an iterator over ones in the bit set.
356 ///
357 /// Will iterate through elements from smallest to largest index.
358 ///
359 /// # Examples
360 ///
361 /// ```
362 /// use bittle::{Bits, LittleEndian};
363 ///
364 /// let set: u128 = bittle::set_le![3, 7];
365 /// assert!(set.iter_ones_in::<LittleEndian>().eq([3, 7]));
366 /// ```
367 ///
368 /// A larger bit set:
369 ///
370 /// ```
371 /// use bittle::{Bits, LittleEndian};
372 ///
373 /// let set: [u32; 4] = bittle::set_le![4, 67, 71];
374 /// assert!(set.iter_ones_in::<LittleEndian>().eq([4, 67, 71]));
375 /// ```
376 fn iter_ones_in<E>(&self) -> Self::IterOnesIn<'_, E>
377 where
378 E: Endian;
379
380 /// Construct an iterator over ones in the bit set using [`LittleEndian`]
381 /// indexing.
382 ///
383 /// Will iterate through elements from smallest to largest index.
384 ///
385 /// # Examples
386 ///
387 /// ```
388 /// use bittle::Bits;
389 ///
390 /// let set: u128 = bittle::set_le![3, 7];
391 /// assert!(set.iter_ones_le().eq([3, 7]));
392 /// ```
393 ///
394 /// A larger bit set:
395 ///
396 /// ```
397 /// use bittle::Bits;
398 ///
399 /// let set: [u32; 4] = bittle::set_le![4, 67, 71];
400 /// assert!(set.iter_ones_le().eq([4, 67, 71]));
401 /// ```
402 #[inline]
403 fn iter_ones_le(&self) -> Self::IterOnesIn<'_, LittleEndian> {
404 self.iter_ones_in()
405 }
406
407 /// Construct an iterator over ones in the bit set using [`BigEndian`]
408 /// indexing.
409 ///
410 /// Will iterate through elements from smallest to largest index.
411 ///
412 /// # Examples
413 ///
414 /// ```
415 /// use bittle::Bits;
416 ///
417 /// let set: u128 = bittle::set_be![3, 7];
418 /// assert!(set.iter_ones_be().eq([3, 7]));
419 /// ```
420 ///
421 /// A larger bit set:
422 ///
423 /// ```
424 /// use bittle::Bits;
425 ///
426 /// let set: [u32; 4] = bittle::set_be![4, 67, 71];
427 /// assert!(set.iter_ones_be().eq([4, 67, 71]));
428 /// ```
429 #[inline]
430 fn iter_ones_be(&self) -> Self::IterOnesIn<'_, BigEndian> {
431 self.iter_ones_in()
432 }
433
434 /// Construct an iterator over zeros in the bit set using [`DefaultEndian`]
435 /// indexing.
436 ///
437 /// Will iterate through elements from smallest to largest index.
438 ///
439 /// [`DefaultEndian`]: crate::DefaultEndian
440 ///
441 /// # Examples
442 ///
443 /// ```
444 /// use bittle::Bits;
445 ///
446 /// let set: u8 = bittle::set![3, 7];
447 /// assert!(set.iter_zeros().eq([0, 1, 2, 4, 5, 6]));
448 /// ```
449 ///
450 /// A larger bit set:
451 ///
452 /// ```
453 /// use bittle::Bits;
454 ///
455 /// let set: [u8; 2] = bittle::set![3, 7, 13, 14, 15];
456 /// assert!(set.iter_zeros().eq([0, 1, 2, 4, 5, 6, 8, 9, 10, 11, 12]));
457 /// assert!(set.iter_zeros().rev().eq([12, 11, 10, 9, 8, 6, 5, 4, 2, 1, 0]));
458 /// ```
459 fn iter_zeros(&self) -> Self::IterZeros<'_>;
460
461 /// Construct an iterator over zeros in the bit set.
462 ///
463 /// Will iterate through elements from smallest to largest index.
464 ///
465 /// # Examples
466 ///
467 /// ```
468 /// use bittle::{Bits, LittleEndian};
469 ///
470 /// let set: u8 = bittle::set_le![3, 7];
471 /// assert!(set.iter_zeros_in::<LittleEndian>().eq([0, 1, 2, 4, 5, 6]));
472 /// ```
473 ///
474 /// A larger bit set:
475 ///
476 /// ```
477 /// use bittle::{Bits, LittleEndian};
478 ///
479 /// let set: [u8; 2] = bittle::set_le![3, 7, 13, 14, 15];
480 /// assert!(set.iter_zeros_in::<LittleEndian>().eq([0, 1, 2, 4, 5, 6, 8, 9, 10, 11, 12]));
481 /// ```
482 fn iter_zeros_in<E>(&self) -> Self::IterZerosIn<'_, E>
483 where
484 E: Endian;
485
486 /// Construct an iterator over zeros in the bit set using [`LittleEndian`] indexing.
487 ///
488 /// Will iterate through elements from smallest to largest index.
489 ///
490 /// # Examples
491 ///
492 /// ```
493 /// use bittle::Bits;
494 ///
495 /// let set: u8 = bittle::set_le![3, 7];
496 /// assert!(set.iter_zeros_le().eq([0, 1, 2, 4, 5, 6]));
497 /// ```
498 ///
499 /// A larger bit set:
500 ///
501 /// ```
502 /// use bittle::Bits;
503 ///
504 /// let set: [u8; 2] = bittle::set_le![3, 7, 13, 14, 15];
505 /// assert!(set.iter_zeros_le().eq([0, 1, 2, 4, 5, 6, 8, 9, 10, 11, 12]));
506 /// ```
507 #[inline]
508 fn iter_zeros_le(&self) -> Self::IterZerosIn<'_, LittleEndian> {
509 self.iter_zeros_in()
510 }
511
512 /// Construct an iterator over zeros in the bit set using [`BigEndian`]
513 /// indexing.
514 ///
515 /// Will iterate through elements from smallest to largest index.
516 ///
517 /// # Examples
518 ///
519 /// ```
520 /// use bittle::Bits;
521 ///
522 /// let set: u8 = bittle::set_be![3, 7];
523 /// assert!(set.iter_zeros_be().eq([0, 1, 2, 4, 5, 6]));
524 /// ```
525 ///
526 /// A larger bit set:
527 ///
528 /// ```
529 /// use bittle::Bits;
530 ///
531 /// let set: [u8; 2] = bittle::set_be![3, 7, 13, 14, 15];
532 /// assert!(set.iter_zeros_be().eq([0, 1, 2, 4, 5, 6, 8, 9, 10, 11, 12]));
533 /// ```
534 #[inline]
535 fn iter_zeros_be(&self) -> Self::IterZerosIn<'_, BigEndian> {
536 self.iter_zeros_in()
537 }
538
539 /// Join this bit set with an iterator, creating an iterator that only
540 /// yields the elements which are set to ones using custom [`Endian`]
541 /// indexing.
542 ///
543 /// The underlying iterator is advanced using [`Iterator::nth`] as
544 /// appropriate.
545 ///
546 /// # Examples
547 ///
548 /// ```
549 /// use bittle::{Bits, LittleEndian};
550 ///
551 /// let mask: u128 = bittle::set_le![0, 1, 3];
552 /// let mut values = vec![false, false, false, false];
553 ///
554 /// for value in mask.join_ones_in::<_, LittleEndian>(values.iter_mut()) {
555 /// *value = true;
556 /// }
557 ///
558 /// assert_eq!(values, vec![true, true, false, true]);
559 /// ```
560 fn join_ones_in<I, E>(&self, iter: I) -> JoinOnes<'_, Self, E, I::IntoIter>
561 where
562 I: IntoIterator,
563 E: Endian,
564 {
565 JoinOnes::new(self.iter_ones_in(), iter.into_iter())
566 }
567
568 /// Join this bit set with an iterator, creating an iterator that only
569 /// yields the elements which are set to ones using [`DefaultEndian`]
570 /// indexing.
571 ///
572 /// The underlying iterator is advanced using [`Iterator::nth`] as
573 /// appropriate.
574 ///
575 /// [`DefaultEndian`]: crate::DefaultEndian
576 ///
577 /// # Examples
578 ///
579 /// ```
580 /// use bittle::Bits;
581 ///
582 /// let mask: u128 = bittle::set![0, 1, 3];
583 /// let mut values = vec![false, false, false, false];
584 ///
585 /// for value in mask.join_ones(values.iter_mut()) {
586 /// *value = true;
587 /// }
588 ///
589 /// assert_eq!(values, vec![true, true, false, true]);
590 /// ```
591 #[inline]
592 fn join_ones<I>(&self, iter: I) -> JoinOnes<'_, Self, DefaultEndian, I::IntoIter>
593 where
594 I: IntoIterator,
595 {
596 JoinOnes::new(self.iter_ones_in(), iter.into_iter())
597 }
598
599 /// Join this bit set with an iterator, creating an iterator that only
600 /// yields the elements which are set to ones using [`LittleEndian`] indexing.
601 ///
602 /// The underlying iterator is advanced using [`Iterator::nth`] as
603 /// appropriate.
604 ///
605 /// # Examples
606 ///
607 /// ```
608 /// use bittle::Bits;
609 ///
610 /// let mask: u8 = 0b11010000;
611 /// let mut values = vec![false, false, false, false];
612 ///
613 /// for value in mask.join_ones_le(values.iter_mut()) {
614 /// *value = true;
615 /// }
616 ///
617 /// assert_eq!(values, vec![true, true, false, true]);
618 /// ```
619 #[inline]
620 fn join_ones_le<I>(&self, iter: I) -> JoinOnes<'_, Self, LittleEndian, I::IntoIter>
621 where
622 I: IntoIterator,
623 {
624 self.join_ones_in(iter)
625 }
626
627 /// Join this bit set with an iterator, creating an iterator that only
628 /// yields the elements which are set to ones using [`BigEndian`] indexing.
629 ///
630 /// The underlying iterator is advanced using [`Iterator::nth`] as
631 /// appropriate.
632 ///
633 /// # Examples
634 ///
635 /// ```
636 /// use bittle::Bits;
637 ///
638 /// let mask: u8 = 0b00001011;
639 /// let mut values = vec![false, false, false, false];
640 ///
641 /// for value in mask.join_ones_be(values.iter_mut()) {
642 /// *value = true;
643 /// }
644 ///
645 /// assert_eq!(values, vec![true, true, false, true]);
646 /// ```
647 #[inline]
648 fn join_ones_be<I>(&self, iter: I) -> JoinOnes<'_, Self, BigEndian, I::IntoIter>
649 where
650 I: IntoIterator,
651 {
652 self.join_ones_in(iter)
653 }
654}
655
656impl<T> Bits for &T
657where
658 T: ?Sized + Bits,
659{
660 type IterOnes<'a> = T::IterOnes<'a>
661 where
662 Self: 'a;
663
664 type IterOnesIn<'a, E> = T::IterOnesIn<'a, E>
665 where
666 Self: 'a,
667 E: Endian;
668
669 type IterZeros<'a> = T::IterZeros<'a>
670 where
671 Self: 'a;
672
673 type IterZerosIn<'a, E> = T::IterZerosIn<'a, E>
674 where
675 Self: 'a,
676 E: Endian;
677
678 #[inline]
679 fn count_ones(&self) -> u32 {
680 (**self).count_ones()
681 }
682
683 #[inline]
684 fn count_zeros(&self) -> u32 {
685 (**self).count_zeros()
686 }
687
688 #[inline]
689 fn bits_capacity(&self) -> u32 {
690 (**self).bits_capacity()
691 }
692
693 #[inline]
694 fn all_zeros(&self) -> bool {
695 (**self).all_zeros()
696 }
697
698 #[inline]
699 fn all_ones(&self) -> bool {
700 (**self).all_ones()
701 }
702
703 #[inline]
704 fn test_bit(&self, index: u32) -> bool {
705 (**self).test_bit(index)
706 }
707
708 #[inline]
709 fn test_bit_in<E>(&self, index: u32) -> bool
710 where
711 E: Endian,
712 {
713 (**self).test_bit_in::<E>(index)
714 }
715
716 #[inline]
717 fn iter_ones(&self) -> Self::IterOnes<'_> {
718 (**self).iter_ones()
719 }
720
721 #[inline]
722 fn iter_ones_in<E>(&self) -> Self::IterOnesIn<'_, E>
723 where
724 E: Endian,
725 {
726 (**self).iter_ones_in()
727 }
728
729 #[inline]
730 fn iter_zeros(&self) -> Self::IterZeros<'_> {
731 (**self).iter_zeros()
732 }
733
734 #[inline]
735 fn iter_zeros_in<E>(&self) -> Self::IterZerosIn<'_, E>
736 where
737 E: Endian,
738 {
739 (**self).iter_zeros_in()
740 }
741}
742
743impl<T> Bits for &mut T
744where
745 T: ?Sized + Bits,
746{
747 type IterOnesIn<'a, E> = T::IterOnesIn<'a, E>
748 where
749 Self: 'a,
750 E: Endian;
751
752 type IterOnes<'a> = T::IterOnes<'a>
753 where
754 Self: 'a;
755
756 type IterZerosIn<'a, E> = T::IterZerosIn<'a, E>
757 where
758 Self: 'a,
759 E: Endian;
760
761 type IterZeros<'a> = T::IterZeros<'a>
762 where
763 Self: 'a;
764
765 #[inline]
766 fn count_ones(&self) -> u32 {
767 (**self).count_ones()
768 }
769
770 #[inline]
771 fn count_zeros(&self) -> u32 {
772 (**self).count_zeros()
773 }
774
775 #[inline]
776 fn bits_capacity(&self) -> u32 {
777 (**self).bits_capacity()
778 }
779
780 #[inline]
781 fn all_zeros(&self) -> bool {
782 (**self).all_zeros()
783 }
784
785 #[inline]
786 fn all_ones(&self) -> bool {
787 (**self).all_ones()
788 }
789
790 #[inline]
791 fn test_bit(&self, index: u32) -> bool {
792 (**self).test_bit(index)
793 }
794
795 #[inline]
796 fn test_bit_in<E>(&self, index: u32) -> bool
797 where
798 E: Endian,
799 {
800 (**self).test_bit_in::<E>(index)
801 }
802
803 #[inline]
804 fn iter_ones(&self) -> Self::IterOnes<'_> {
805 (**self).iter_ones()
806 }
807
808 #[inline]
809 fn iter_ones_in<E>(&self) -> Self::IterOnesIn<'_, E>
810 where
811 E: Endian,
812 {
813 (**self).iter_ones_in()
814 }
815
816 #[inline]
817 fn iter_zeros(&self) -> Self::IterZeros<'_> {
818 (**self).iter_zeros()
819 }
820
821 #[inline]
822 fn iter_zeros_in<E>(&self) -> Self::IterZerosIn<'_, E>
823 where
824 E: Endian,
825 {
826 (**self).iter_zeros_in()
827 }
828}