1 #[repr(C)]
2 #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
3 pub struct __BindgenBitfieldUnit<Storage, Align> {
4     storage: Storage,
5     align: [Align; 0],
6 }
7 
8 impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
9     #[inline]
new(storage: Storage) -> Self10     pub const fn new(storage: Storage) -> Self {
11         Self { storage, align: [] }
12     }
13 }
14 
15 impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
16 where
17     Storage: AsRef<[u8]> + AsMut<[u8]>,
18 {
19     #[inline]
get_bit(&self, index: usize) -> bool20     pub fn get_bit(&self, index: usize) -> bool {
21         debug_assert!(index / 8 < self.storage.as_ref().len());
22 
23         let byte_index = index / 8;
24         let byte = self.storage.as_ref()[byte_index];
25 
26         let bit_index = if cfg!(target_endian = "big") {
27             7 - (index % 8)
28         } else {
29             index % 8
30         };
31 
32         let mask = 1 << bit_index;
33 
34         byte & mask == mask
35     }
36 
37     #[inline]
set_bit(&mut self, index: usize, val: bool)38     pub fn set_bit(&mut self, index: usize, val: bool) {
39         debug_assert!(index / 8 < self.storage.as_ref().len());
40 
41         let byte_index = index / 8;
42         let byte = &mut self.storage.as_mut()[byte_index];
43 
44         let bit_index = if cfg!(target_endian = "big") {
45             7 - (index % 8)
46         } else {
47             index % 8
48         };
49 
50         let mask = 1 << bit_index;
51         if val {
52             *byte |= mask;
53         } else {
54             *byte &= !mask;
55         }
56     }
57 
58     #[inline]
get(&self, bit_offset: usize, bit_width: u8) -> u6459     pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
60         debug_assert!(bit_width <= 64);
61         debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
62         debug_assert!(
63             (bit_offset + (bit_width as usize)) / 8 <=
64                 self.storage.as_ref().len()
65         );
66 
67         let mut val = 0;
68 
69         for i in 0..(bit_width as usize) {
70             if self.get_bit(i + bit_offset) {
71                 let index = if cfg!(target_endian = "big") {
72                     bit_width as usize - 1 - i
73                 } else {
74                     i
75                 };
76                 val |= 1 << index;
77             }
78         }
79 
80         val
81     }
82 
83     #[inline]
set(&mut self, bit_offset: usize, bit_width: u8, val: u64)84     pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
85         debug_assert!(bit_width <= 64);
86         debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
87         debug_assert!(
88             (bit_offset + (bit_width as usize)) / 8 <=
89                 self.storage.as_ref().len()
90         );
91 
92         for i in 0..(bit_width as usize) {
93             let mask = 1 << i;
94             let val_bit_is_set = val & mask == mask;
95             let index = if cfg!(target_endian = "big") {
96                 bit_width as usize - 1 - i
97             } else {
98                 i
99             };
100             self.set_bit(index + bit_offset, val_bit_is_set);
101         }
102     }
103 }
104