1use funty::Integral;
2
3use crate::prelude::*;
4
5pub trait BitBufMutExts: BitBufMut {
6 #[allow(non_snake_case)]
7 fn put_uN<O: ByteOrder, const N: usize, U, V: Integral>(
8 &mut self,
9 value: U,
10 ) -> std::io::Result<()>
11 where
12 U: Into<V>,
13 {
14 let mut bits = BitVec::repeat(false, N);
15 let value_slice = bits.as_mut_bitslice();
16 let value_integral: V = value.into();
19 O::store(value_slice, value_integral);
20 self.try_put_bit_slice(value_slice)?;
21 Ok(())
22 }
23
24 fn put_bool(&mut self, value: bool) -> std::io::Result<()> {
25 self.put_u1(u1::new(value as u8))
26 }
27
28 fn put_u1(&mut self, value: u1) -> std::io::Result<()> {
29 self.put_uN::<BigEndian, 1, u1, u8>(value)
30 }
31
32 fn put_u2(&mut self, value: u2) -> std::io::Result<()> {
33 self.put_uN::<BigEndian, 2, u2, u8>(value)
34 }
35
36 fn put_u3(&mut self, value: u3) -> std::io::Result<()> {
37 self.put_uN::<BigEndian, 3, u3, u8>(value)
38 }
39
40 fn put_u4(&mut self, value: u4) -> std::io::Result<()> {
41 self.put_uN::<BigEndian, 4, u4, u8>(value)
42 }
43
44 fn put_u5(&mut self, value: u5) -> std::io::Result<()> {
45 self.put_uN::<BigEndian, 5, u5, u8>(value)
46 }
47
48 fn put_u6(&mut self, value: u6) -> std::io::Result<()> {
49 self.put_uN::<BigEndian, 6, u6, u8>(value)
50 }
51
52 fn put_u7(&mut self, value: u7) -> std::io::Result<()> {
53 self.put_uN::<BigEndian, 7, u7, u8>(value)
54 }
55
56 fn put_u8(&mut self, value: u8) -> std::io::Result<()> {
57 self.put_uN::<BigEndian, 8, u8, u8>(value)
58 }
59
60 fn put_u9<O: ByteOrder>(&mut self, value: u9) -> std::io::Result<()> {
61 self.put_uN::<O, 9, u9, u16>(value)
62 }
63 fn put_u10<O: ByteOrder>(&mut self, value: u10) -> std::io::Result<()> {
64 self.put_uN::<O, 10, u10, u16>(value)
65 }
66 fn put_u11<O: ByteOrder>(&mut self, value: u11) -> std::io::Result<()> {
67 self.put_uN::<O, 11, u11, u16>(value)
68 }
69 fn put_u12<O: ByteOrder>(&mut self, value: u12) -> std::io::Result<()> {
70 self.put_uN::<O, 12, u12, u16>(value)
71 }
72 fn put_u13<O: ByteOrder>(&mut self, value: u13) -> std::io::Result<()> {
73 self.put_uN::<O, 13, u13, u16>(value)
74 }
75 fn put_u14<O: ByteOrder>(&mut self, value: u14) -> std::io::Result<()> {
76 self.put_uN::<O, 14, u14, u16>(value)
77 }
78 fn put_u15<O: ByteOrder>(&mut self, value: u15) -> std::io::Result<()> {
79 self.put_uN::<O, 15, u15, u16>(value)
80 }
81 fn put_u16<O: ByteOrder>(&mut self, value: u16) -> std::io::Result<()> {
82 self.put_uN::<O, 16, u16, u16>(value)
83 }
84 fn put_u17<O: ByteOrder>(&mut self, value: u17) -> std::io::Result<()> {
85 self.put_uN::<O, 17, u17, u32>(value)
86 }
87 fn put_u18<O: ByteOrder>(&mut self, value: u18) -> std::io::Result<()> {
88 self.put_uN::<O, 18, u18, u32>(value)
89 }
90 fn put_u19<O: ByteOrder>(&mut self, value: u19) -> std::io::Result<()> {
91 self.put_uN::<O, 19, u19, u32>(value)
92 }
93 fn put_u20<O: ByteOrder>(&mut self, value: u20) -> std::io::Result<()> {
94 self.put_uN::<O, 20, u20, u32>(value)
95 }
96 fn put_u21<O: ByteOrder>(&mut self, value: u21) -> std::io::Result<()> {
97 self.put_uN::<O, 21, u21, u32>(value)
98 }
99 fn put_u22<O: ByteOrder>(&mut self, value: u22) -> std::io::Result<()> {
100 self.put_uN::<O, 22, u22, u32>(value)
101 }
102 fn put_u23<O: ByteOrder>(&mut self, value: u23) -> std::io::Result<()> {
103 self.put_uN::<O, 23, u23, u32>(value)
104 }
105 fn put_u24<O: ByteOrder>(&mut self, value: u24) -> std::io::Result<()> {
106 self.put_uN::<O, 24, u24, u32>(value)
107 }
108 fn put_u25<O: ByteOrder>(&mut self, value: u25) -> std::io::Result<()> {
109 self.put_uN::<O, 25, u25, u32>(value)
110 }
111 fn put_u26<O: ByteOrder>(&mut self, value: u26) -> std::io::Result<()> {
112 self.put_uN::<O, 26, u26, u32>(value)
113 }
114 fn put_u27<O: ByteOrder>(&mut self, value: u27) -> std::io::Result<()> {
115 self.put_uN::<O, 27, u27, u32>(value)
116 }
117 fn put_u28<O: ByteOrder>(&mut self, value: u28) -> std::io::Result<()> {
118 self.put_uN::<O, 28, u28, u32>(value)
119 }
120 fn put_u29<O: ByteOrder>(&mut self, value: u29) -> std::io::Result<()> {
121 self.put_uN::<O, 29, u29, u32>(value)
122 }
123 fn put_u30<O: ByteOrder>(&mut self, value: u30) -> std::io::Result<()> {
124 self.put_uN::<O, 30, u30, u32>(value)
125 }
126 fn put_u31<O: ByteOrder>(&mut self, value: u31) -> std::io::Result<()> {
127 self.put_uN::<O, 31, u31, u32>(value)
128 }
129 fn put_u32<O: ByteOrder>(&mut self, value: u32) -> std::io::Result<()> {
130 self.put_uN::<O, 32, u32, u32>(value)
131 }
132}
133
134impl<T: BitBufMut + ?Sized> BitBufMutExts for T {}
135
136#[cfg(test)]
137mod tests {
138 use crate::prelude::*;
139
140 #[test]
141 fn test_put() {
142 let mut bits_mut = BitsMut::new();
143 bits_mut.put_u1(u1::new(0b1)).unwrap();
144 bits_mut.put_u3(u3::new(0b001)).unwrap();
145 bits_mut.put_u5(u5::new(0b00001)).unwrap();
146 bits_mut.put_u7(u7::new(0b0000001)).unwrap();
147
148 assert_eq!(
149 &bits_mut[..],
150 bits![1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]
151 );
152 }
153
154 #[test]
155 fn test_put_big_endian() {
156 {
157 let mut bits_mut = BitsMut::new();
158 let value = u9::new(0b1_01010101);
159 bits_mut.put_u9::<BigEndian>(value).unwrap();
160 assert_eq!(&bits_mut[..], bits![1, 0, 1, 0, 1, 0, 1, 0, 1]);
161 }
162 {
163 let mut bits_mut = BitsMut::new();
164 let value = u21::new(0b10101_01010101_01010101);
165 bits_mut.put_u21::<BigEndian>(value).unwrap();
166 assert_eq!(
167 &bits_mut[..],
168 bits![1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
169 );
170 }
171 }
172
173 #[test]
174 fn test_put_little_endian() {
175 {
176 let mut bits_mut = BitsMut::new();
177 let value = u9::new(0b1_00001111);
178 bits_mut.put_u9::<LittleEndian>(value).unwrap();
179 assert_eq!(&bits_mut[..], bits![0, 0, 0, 0, 1, 1, 1, 1, 1]);
180 }
181 {
182 let mut bits_mut = BitsMut::new();
183 let value = u21::new(0b00110_00001111_00011100);
184 bits_mut.put_u21::<LittleEndian>(value).unwrap();
185 assert_eq!(
186 &bits_mut[..],
187 bits![0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0]
188 );
189 }
190 }
191}