bitworks/
bitset8.rs

1//! Module containing [`Bitset8`].
2
3use crate::{
4    bit::Bit,
5    bitset::{Bitset, LeftAligned},
6    error::{ConvError, ConvTarget},
7    prelude::{Bitset128, Bitset16, Bitset32, Bitset64, Byteset, Index},
8    safety_markers::Size,
9};
10use std::{
11    fmt::{Binary, Debug, Display, LowerHex, Octal, UpperHex},
12    ops::{
13        BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not, Shl, ShlAssign, Shr,
14        ShrAssign,
15    },
16};
17
18type Inner = u8;
19type BIndex = Index<Bitset8>;
20const BITS: usize = 8;
21
22/// [`Bitset`] of bit size 8.
23#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
24#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
25#[repr(transparent)]
26pub struct Bitset8(pub(crate) Inner);
27
28impl Bitset8 {
29    /// Constructs a new value of `Bitset8`.
30    ///
31    /// # Examples
32    /// ```rust
33    /// # use std::error::Error;
34    /// #
35    /// # fn main() -> Result<(), Box<dyn Error>> {
36    /// use bitworks::prelude::{Bitset, Bitset8};
37    ///
38    /// let bitset = Bitset8::new(19);
39    ///
40    /// assert_eq!(bitset, Bitset8::from_repr(19));
41    /// #   Ok(())
42    /// # }
43    /// ```
44    #[inline(always)]
45    pub const fn new(inner: Inner) -> Self {
46        Self(inner)
47    }
48
49    /// Returns the inner [`u8`] representation of `Bitset8`.
50    ///
51    /// # Examples
52    /// ```rust
53    /// # use std::error::Error;
54    /// #
55    /// # fn main() -> Result<(), Box<dyn Error>> {
56    /// use bitworks::prelude::Bitset8;
57    ///
58    /// let bitset = Bitset8::new(19);
59    /// let inner: u8 = bitset.into_inner();
60    ///
61    /// assert_eq!(inner, 19);
62    /// #   Ok(())
63    /// # }
64    /// ```
65    #[inline(always)]
66    pub const fn into_inner(&self) -> Inner {
67        self.0
68    }
69}
70
71unsafe impl LeftAligned for Bitset8 {
72    type _Repr = Inner;
73    type _Size = Size<1>;
74    const _BYTE_SIZE: usize = 1;
75    const _ALL: Self = Self(Inner::MAX);
76    const _NONE: Self = Self(Inner::MIN);
77
78    #[inline(always)]
79    fn _from_repr(value: Self::Repr) -> Self {
80        Self(value)
81    }
82}
83
84impl From<Inner> for Bitset8 {
85    #[inline(always)]
86    fn from(value: Inner) -> Self {
87        Self(value)
88    }
89}
90
91impl From<Bitset8> for Inner {
92    #[inline(always)]
93    fn from(value: Bitset8) -> Self {
94        value.0
95    }
96}
97
98impl From<BIndex> for Bitset8 {
99    #[inline(always)]
100    fn from(value: BIndex) -> Self {
101        Self(1) << value
102    }
103}
104
105impl From<Byteset<1>> for Bitset8 {
106    #[inline(always)]
107    fn from(value: Byteset<1>) -> Self {
108        Self(value.into_inner()[0])
109    }
110}
111
112impl TryFrom<Bitset16> for Bitset8 {
113    type Error = ConvError;
114
115    #[inline(always)]
116    fn try_from(value: Bitset16) -> Result<Self, Self::Error> {
117        Inner::try_from(value.into_inner())
118            .map(Self::from)
119            .map_err(|_| ConvError::new(ConvTarget::Set(16), ConvTarget::Set(8)))
120    }
121}
122
123impl TryFrom<Bitset32> for Bitset8 {
124    type Error = ConvError;
125
126    #[inline(always)]
127    fn try_from(value: Bitset32) -> Result<Self, Self::Error> {
128        Inner::try_from(value.into_inner())
129            .map(Self::from)
130            .map_err(|_| ConvError::new(ConvTarget::Set(32), ConvTarget::Set(8)))
131    }
132}
133
134impl TryFrom<Bitset64> for Bitset8 {
135    type Error = ConvError;
136
137    #[inline(always)]
138    fn try_from(value: Bitset64) -> Result<Self, Self::Error> {
139        Inner::try_from(value.into_inner())
140            .map(Self::from)
141            .map_err(|_| ConvError::new(ConvTarget::Set(64), ConvTarget::Set(8)))
142    }
143}
144
145impl TryFrom<Bitset128> for Bitset8 {
146    type Error = ConvError;
147
148    #[inline(always)]
149    fn try_from(value: Bitset128) -> Result<Self, Self::Error> {
150        Inner::try_from(value.into_inner())
151            .map(Self::from)
152            .map_err(|_| ConvError::new(ConvTarget::Set(128), ConvTarget::Set(8)))
153    }
154}
155
156impl Not for Bitset8 {
157    type Output = Self;
158
159    #[inline(always)]
160    fn not(self) -> Self::Output {
161        Self(!self.0)
162    }
163}
164
165impl BitAnd for Bitset8 {
166    type Output = Self;
167
168    #[inline(always)]
169    fn bitand(self, rhs: Self) -> Self::Output {
170        Self(self.0 & rhs.0)
171    }
172}
173
174impl BitAndAssign for Bitset8 {
175    #[inline(always)]
176    fn bitand_assign(&mut self, rhs: Self) {
177        self.0 &= rhs.0;
178    }
179}
180
181impl BitOr for Bitset8 {
182    type Output = Self;
183
184    #[inline(always)]
185    fn bitor(self, rhs: Self) -> Self::Output {
186        Self(self.0 | rhs.0)
187    }
188}
189
190impl BitOrAssign for Bitset8 {
191    #[inline(always)]
192    fn bitor_assign(&mut self, rhs: Self) {
193        self.0 |= rhs.0;
194    }
195}
196
197impl BitXor for Bitset8 {
198    type Output = Self;
199
200    #[inline(always)]
201    fn bitxor(self, rhs: Self) -> Self::Output {
202        Self(self.0 ^ rhs.0)
203    }
204}
205
206impl BitXorAssign for Bitset8 {
207    #[inline(always)]
208    fn bitxor_assign(&mut self, rhs: Self) {
209        self.0 ^= rhs.0;
210    }
211}
212
213impl Shl<BIndex> for Bitset8 {
214    type Output = Self;
215
216    #[inline(always)]
217    fn shl(self, rhs: BIndex) -> Self::Output {
218        Self::from(self.0.shl(rhs.into_inner()))
219    }
220}
221
222impl ShlAssign<BIndex> for Bitset8 {
223    #[inline(always)]
224    fn shl_assign(&mut self, rhs: BIndex) {
225        *self = self.shl(rhs);
226    }
227}
228
229impl Shr<BIndex> for Bitset8 {
230    type Output = Self;
231
232    #[inline(always)]
233    fn shr(self, rhs: BIndex) -> Self::Output {
234        Self::from(self.0.shr(rhs.into_inner()))
235    }
236}
237
238impl ShrAssign<BIndex> for Bitset8 {
239    #[inline(always)]
240    fn shr_assign(&mut self, rhs: BIndex) {
241        *self = self.shr(rhs);
242    }
243}
244
245impl BitAnd<BIndex> for Bitset8 {
246    type Output = Self;
247
248    #[inline(always)]
249    fn bitand(self, rhs: BIndex) -> Self::Output {
250        Self(self.0 & Self::from(rhs).0)
251    }
252}
253
254impl BitAndAssign<BIndex> for Bitset8 {
255    #[inline(always)]
256    fn bitand_assign(&mut self, rhs: BIndex) {
257        self.0 &= Self::from(rhs).0;
258    }
259}
260
261impl BitOr<BIndex> for Bitset8 {
262    type Output = Self;
263
264    #[inline(always)]
265    fn bitor(self, rhs: BIndex) -> Self::Output {
266        Self(self.0 | Self::from(rhs).0)
267    }
268}
269
270impl BitOrAssign<BIndex> for Bitset8 {
271    #[inline(always)]
272    fn bitor_assign(&mut self, rhs: BIndex) {
273        self.0 |= Self::from(rhs).0;
274    }
275}
276
277impl BitXor<BIndex> for Bitset8 {
278    type Output = Self;
279
280    #[inline(always)]
281    fn bitxor(self, rhs: BIndex) -> Self::Output {
282        Self(self.0 ^ Self::from(rhs).0)
283    }
284}
285
286impl BitXorAssign<BIndex> for Bitset8 {
287    #[inline(always)]
288    fn bitxor_assign(&mut self, rhs: BIndex) {
289        self.0 ^= Self::from(rhs).0;
290    }
291}
292
293impl FromIterator<Bit> for Bitset8 {
294    fn from_iter<T: IntoIterator<Item = Bit>>(iter: T) -> Self {
295        iter.into_iter()
296            .take(BITS)
297            .enumerate()
298            .filter_map(|(i, bit)| if bool::from(bit) { Some(i) } else { None })
299            .filter_map(|i| BIndex::try_from(i).ok())
300            .fold(Self::NONE, |acc, i| acc | Self(1) << i)
301    }
302}
303
304impl Debug for Bitset8 {
305    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
306        write!(f, "Bitset8({:#010b})", self.0)
307    }
308}
309
310impl Display for Bitset8 {
311    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
312        write!(f, "{:08b}", self.0)
313    }
314}
315
316impl Binary for Bitset8 {
317    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
318        write!(f, "{:#010b}", self.0)
319    }
320}
321
322impl Octal for Bitset8 {
323    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
324        write!(f, "{:#05o}", self.0)
325    }
326}
327
328impl UpperHex for Bitset8 {
329    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
330        write!(f, "{:#04X}", self.0)
331    }
332}
333
334impl LowerHex for Bitset8 {
335    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
336        write!(f, "{:#04x}", self.0)
337    }
338}
339
340#[cfg(test)]
341mod tests {
342    use std::error::Error;
343
344    use crate::{bit::Bit::*, prelude::Bitset};
345
346    use super::*;
347    type Tested = Bitset8;
348    type TestResult = Result<(), Box<dyn Error>>;
349
350    #[test]
351    fn construction() -> TestResult {
352        let bitset = Tested::NONE
353            .clone()
354            .replace(0.try_into()?, One)
355            .set(1.try_into()?)
356            .unset(0.try_into()?)
357            .build();
358
359        assert_eq!(bitset, 0b00000010.into());
360        Ok(())
361    }
362
363    #[test]
364    fn conversion_from_integer() {
365        let bitset: Tested = 0b10101010.into();
366
367        assert_eq!(bitset.0, 0b10101010);
368    }
369
370    #[test]
371    fn conversion_from_index() {
372        let bitset = Tested::from(Index::<Tested>::MIN);
373
374        assert_eq!(bitset.0, 1);
375    }
376
377    #[test]
378    fn into_inner() {
379        let bitset: Tested = 0b10101010.into();
380
381        assert_eq!(bitset.0, bitset.into_inner());
382    }
383
384    #[test]
385    fn bit_set_to_true() -> TestResult {
386        let mut bitset: Tested = 0b10101010.into();
387
388        bitset.replace(6.try_into()?, One);
389
390        assert_eq!(bitset.0, 0b11101010);
391        Ok(())
392    }
393
394    #[test]
395    fn bit_set_to_false() -> TestResult {
396        let mut bitset: Tested = 0b10101010.into();
397
398        bitset.replace(7.try_into()?, Zero);
399
400        assert_eq!(bitset.0, 0b00101010);
401        Ok(())
402    }
403
404    #[test]
405    fn bit() -> TestResult {
406        let bitset: Tested = 0b10101010.into();
407
408        assert_eq!(bitset.bit(0.try_into()?), Zero);
409        assert_eq!(bitset.bit(1.try_into()?), One);
410        Ok(())
411    }
412
413    #[test]
414    fn bit_check() -> TestResult {
415        let mut bitset: Tested = 0b10101010.into();
416
417        bitset.set(6.try_into()?);
418
419        assert_eq!(bitset.0, 0b11101010);
420        Ok(())
421    }
422
423    #[test]
424    fn bit_uncheck() -> TestResult {
425        let mut bitset: Tested = 0b10101010.into();
426
427        bitset.unset(7.try_into()?);
428
429        assert_eq!(bitset.0, 0b00101010);
430        Ok(())
431    }
432
433    #[test]
434    fn bit_ref() -> TestResult {
435        let bitset: Tested = 0b10101010.into();
436
437        assert_eq!(*bitset.bit_ref(0.try_into()?), Zero);
438        assert_eq!(*bitset.bit_ref(1.try_into()?), One);
439        Ok(())
440    }
441
442    #[test]
443    fn bit_mut() -> TestResult {
444        let mut bitset: Tested = 0b10101010.into();
445
446        assert_eq!(*bitset.bit_ref(0.try_into()?), Zero);
447        assert_eq!(*bitset.bit_ref(1.try_into()?), One);
448
449        *bitset.bit_mut(0.try_into()?) = One;
450        *bitset.bit_mut(1.try_into()?) = Zero;
451
452        assert_eq!(*bitset.bit_ref(0.try_into()?), One);
453        assert_eq!(*bitset.bit_ref(1.try_into()?), Zero);
454        Ok(())
455    }
456
457    #[test]
458    fn count_ones() {
459        let bitset: Tested = 0b11100000.into();
460
461        assert_eq!(bitset.count_ones(), 3);
462    }
463
464    #[test]
465    fn count_zeros() {
466        let bitset: Tested = 0b11100000.into();
467
468        assert_eq!(bitset.count_zeros(), 5);
469    }
470
471    #[test]
472    fn shl() -> TestResult {
473        let bitset: Tested = 0b00000001.into();
474
475        assert_eq!(bitset << 1.try_into()?, 0b00000010.into());
476
477        let mut bitset: Tested = 0b00000001.into();
478        bitset <<= 1.try_into()?;
479
480        assert_eq!(bitset, 0b00000010.into());
481        Ok(())
482    }
483
484    #[test]
485    fn shr() -> TestResult {
486        let bitset: Tested = 0b00000010.into();
487
488        assert_eq!(bitset >> 1.try_into()?, 0b00000001.into());
489
490        let mut bitset: Tested = 0b00000010.into();
491        bitset >>= 1.try_into()?;
492
493        assert_eq!(bitset, 0b00000001.into());
494        Ok(())
495    }
496
497    #[test]
498    fn not() {
499        let a: Tested = 0b11110000.into();
500
501        assert_eq!(!a, 0b00001111.into());
502    }
503
504    #[test]
505    fn bit_and() {
506        let a: Tested = 0b11110000.into();
507        let b: Tested = 0b11001100.into();
508
509        assert_eq!(a & b, 0b11000000.into());
510
511        let mut a: Tested = 0b11110000.into();
512        let b: Tested = 0b11001100.into();
513        a &= b;
514
515        assert_eq!(a, 0b11000000.into());
516    }
517
518    #[test]
519    fn bit_or() {
520        let a: Tested = 0b11110000.into();
521        let b: Tested = 0b11001100.into();
522
523        assert_eq!(a | b, 0b11111100.into());
524
525        let mut a: Tested = 0b11110000.into();
526        let b: Tested = 0b11001100.into();
527        a |= b;
528
529        assert_eq!(a, 0b11111100.into());
530    }
531
532    #[test]
533    fn bit_xor() {
534        let a: Tested = 0b11110000.into();
535        let b: Tested = 0b11001100.into();
536
537        assert_eq!(a ^ b, 0b00111100.into());
538
539        let mut a: Tested = 0b11110000.into();
540        let b: Tested = 0b11001100.into();
541        a ^= b;
542
543        assert_eq!(a, 0b00111100.into());
544    }
545
546    #[test]
547    fn complement() {
548        let a: Tested = 0b11110000.into();
549
550        assert_eq!(a.complement(), 0b00001111.into());
551    }
552
553    #[test]
554    fn intersection() {
555        let a: Tested = 0b11110000.into();
556        let b: Tested = 0b11001100.into();
557
558        assert_eq!(a.intersection(b), 0b11000000.into());
559    }
560
561    #[test]
562    fn union() {
563        let a: Tested = 0b11110000.into();
564        let b: Tested = 0b11001100.into();
565
566        assert_eq!(a.union(b), 0b11111100.into());
567    }
568
569    #[test]
570    fn difference() {
571        let a: Tested = 0b11110000.into();
572        let b: Tested = 0b11001100.into();
573
574        assert_eq!(a.difference(b), 0b00110000.into());
575    }
576
577    #[test]
578    fn sym_difference() {
579        let a: Tested = 0b11110000.into();
580        let b: Tested = 0b11001100.into();
581
582        assert_eq!(a.sym_difference(b), 0b00111100.into());
583    }
584
585    #[test]
586    fn bits() {
587        let bitset: Tested = 0b11110000.into();
588        let mut iter = bitset.bits();
589
590        assert_eq!(iter.next(), Some(Zero));
591        assert_eq!(iter.next(), Some(Zero));
592        assert_eq!(iter.next(), Some(Zero));
593        assert_eq!(iter.next(), Some(Zero));
594        assert_eq!(iter.next(), Some(One));
595        assert_eq!(iter.next(), Some(One));
596        assert_eq!(iter.next(), Some(One));
597        assert_eq!(iter.next(), Some(One));
598        assert_eq!(iter.next(), None);
599    }
600
601    #[test]
602    fn bits_ref() {
603        let bitset: Tested = 0b11110000.into();
604        let mut iter = bitset.bits_ref();
605
606        assert_eq!(iter.next().as_deref(), Some(&Zero));
607        assert_eq!(iter.next().as_deref(), Some(&Zero));
608        assert_eq!(iter.next().as_deref(), Some(&Zero));
609        assert_eq!(iter.next().as_deref(), Some(&Zero));
610        assert_eq!(iter.next().as_deref(), Some(&One));
611        assert_eq!(iter.next().as_deref(), Some(&One));
612        assert_eq!(iter.next().as_deref(), Some(&One));
613        assert_eq!(iter.next().as_deref(), Some(&One));
614        assert_eq!(iter.next(), None);
615    }
616
617    #[test]
618    fn bits_mut() {
619        let mut bitset: Tested = 0b11110000.into();
620
621        let mut iter = bitset.bits_ref();
622
623        assert_eq!(iter.next().as_deref(), Some(&Zero));
624        assert_eq!(iter.next().as_deref(), Some(&Zero));
625        assert_eq!(iter.next().as_deref(), Some(&Zero));
626        assert_eq!(iter.next().as_deref(), Some(&Zero));
627        assert_eq!(iter.next().as_deref(), Some(&One));
628        assert_eq!(iter.next().as_deref(), Some(&One));
629        assert_eq!(iter.next().as_deref(), Some(&One));
630        assert_eq!(iter.next().as_deref(), Some(&One));
631        assert_eq!(iter.next(), None);
632        drop(iter);
633
634        for mut bit in bitset.bits_mut() {
635            *bit = !*bit;
636        }
637
638        let mut iter = bitset.bits_ref();
639
640        assert_eq!(iter.next().as_deref(), Some(&One));
641        assert_eq!(iter.next().as_deref(), Some(&One));
642        assert_eq!(iter.next().as_deref(), Some(&One));
643        assert_eq!(iter.next().as_deref(), Some(&One));
644        assert_eq!(iter.next().as_deref(), Some(&Zero));
645        assert_eq!(iter.next().as_deref(), Some(&Zero));
646        assert_eq!(iter.next().as_deref(), Some(&Zero));
647        assert_eq!(iter.next().as_deref(), Some(&Zero));
648        assert_eq!(iter.next(), None);
649    }
650
651    #[test]
652    fn collect_from_bits() {
653        let a: Tested = 0b11110000.into();
654        let iter = a.bits();
655        let b: Tested = iter.collect();
656
657        assert_eq!(b, 0b11110000.into());
658
659        let arr = [One, Zero, One, Zero, One, Zero, One, Zero];
660        let bitset: Tested = arr
661            .into_iter()
662            // Need to reverse to get the same visual representation, because
663            // array's .into_iter() makes iterator from left to right,
664            // but .collect() will collect from right to left here.
665            .rev()
666            .collect();
667
668        assert_eq!(bitset, 0b10101010.into());
669    }
670
671    #[test]
672    fn ones() -> TestResult {
673        let bitset: Tested = 0b11110000.into();
674        let mut iter = bitset.ones();
675
676        assert_eq!(iter.next(), Some(4.try_into()?));
677        assert_eq!(iter.next(), Some(5.try_into()?));
678        assert_eq!(iter.next(), Some(6.try_into()?));
679        assert_eq!(iter.next(), Some(7.try_into()?));
680        assert_eq!(iter.next(), None);
681        Ok(())
682    }
683
684    #[test]
685    fn zeros() -> TestResult {
686        let bitset: Tested = 0b11110000.into();
687        let mut iter = bitset.zeros();
688
689        assert_eq!(iter.next(), Some(0.try_into()?));
690        assert_eq!(iter.next(), Some(1.try_into()?));
691        assert_eq!(iter.next(), Some(2.try_into()?));
692        assert_eq!(iter.next(), Some(3.try_into()?));
693        assert_eq!(iter.next(), None);
694        Ok(())
695    }
696
697    #[test]
698    fn from_slice_bool() {
699        // Same index order
700        let slice: &[Bit] = &[One, Zero, One, Zero, One, Zero, One, Zero];
701        let bitset: Tested = Tested::from_iterable(slice);
702
703        assert_eq!(bitset, 0b01010101.into());
704    }
705
706    #[test]
707    fn test_send() {
708        fn assert_send<T: Send>() {}
709        assert_send::<Tested>();
710    }
711
712    #[test]
713    fn test_sync() {
714        fn assert_sync<T: Sync>() {}
715        assert_sync::<Tested>();
716    }
717
718    #[test]
719    fn expand() -> TestResult {
720        let bitset1 = Bitset8::from(0b00011011);
721        let bitset2: Bitset16 = bitset1.expand();
722
723        assert_eq!(bitset2, Bitset16::from(0b00011011));
724
725        let bitset1 = Bitset8::from(0b00011011);
726        let bitset2: Bitset32 = bitset1.expand();
727
728        assert_eq!(bitset2, Bitset32::from(0b00011011));
729
730        let bitset1 = Bitset8::from(0b00011011);
731        let bitset2: Bitset64 = bitset1.expand();
732
733        assert_eq!(bitset2, Bitset64::from(0b00011011));
734
735        let bitset1 = Bitset8::from(0b00011011);
736        let bitset2: Bitset128 = bitset1.expand();
737
738        assert_eq!(bitset2, Bitset128::from(0b00011011));
739
740        Ok(())
741    }
742
743    #[test]
744    fn fast_expand() -> TestResult {
745        let bitset1 = Bitset8::from(0b00011011);
746        let bitset2: Bitset16 = bitset1.expand_optimized();
747
748        assert_eq!(bitset2, Bitset16::from(0b00011011));
749
750        let bitset1 = Bitset8::from(0b00011011);
751        let bitset2: Bitset32 = bitset1.expand_optimized();
752
753        assert_eq!(bitset2, Bitset32::from(0b00011011));
754
755        let bitset1 = Bitset8::from(0b00011011);
756        let bitset2: Bitset64 = bitset1.expand_optimized();
757
758        assert_eq!(bitset2, Bitset64::from(0b00011011));
759
760        let bitset1 = Bitset8::from(0b00011011);
761        let bitset2: Bitset128 = bitset1.expand_optimized();
762
763        assert_eq!(bitset2, Bitset128::from(0b00011011));
764
765        Ok(())
766    }
767
768    #[test]
769    fn combine() -> TestResult {
770        let bitset1 = Bitset8::from(0b00011011);
771        let bitset2 = Bitset8::from(0b11101000);
772
773        let bitset3: Bitset16 = bitset1.combine(bitset2);
774
775        assert_eq!(bitset3, Bitset16::from(0b1110100000011011));
776        Ok(())
777    }
778
779    #[test]
780    fn split() -> TestResult {
781        let bitset1 = Bitset16::from(0b1110100000011011);
782        let (bitset2, bitset3): (Bitset8, Bitset8) = bitset1.split();
783
784        assert_eq!(bitset2, Bitset8::from(0b00011011));
785        assert_eq!(bitset3, Bitset8::from(0b11101000));
786        Ok(())
787    }
788
789    #[test]
790    fn fast_combine() -> TestResult {
791        let bitset1 = Bitset8::from(0b00011011);
792        let bitset2 = Bitset8::from(0b11101000);
793
794        let bitset3: Bitset16 = bitset1.combine_optimized(bitset2);
795
796        assert_eq!(bitset3, Bitset16::from(0b1110100000011011));
797        Ok(())
798    }
799
800    #[test]
801    fn fast_split() -> TestResult {
802        let bitset1 = Bitset16::from(0b1110100000011011);
803        let (bitset2, bitset3): (Bitset8, Bitset8) = bitset1.split_optimized();
804
805        assert_eq!(bitset2, Bitset8::from(0b00011011));
806        assert_eq!(bitset3, Bitset8::from(0b11101000));
807        Ok(())
808    }
809}
bitworks/bitset8.rs

bitworks/
bitset8.rs
