1use super::{Format, Packable};
2use core::iter;
3
4impl Packable for u8 {
5 fn pack<T>(&self, buf: &mut T) -> usize
6 where
7 T: Extend<u8>,
8 {
9 if *self <= 127 {
10 buf.extend(iter::once(self & Format::POSITIVE_FIXINT));
11 1
12 } else {
13 buf.extend(iter::once(Format::UINT8).chain(iter::once(*self)));
14 2
15 }
16 }
17}
18
19impl Packable for u16 {
20 fn pack<T>(&self, buf: &mut T) -> usize
21 where
22 T: Extend<u8>,
23 {
24 if *self <= 127 {
25 buf.extend(iter::once(*self as u8 & Format::POSITIVE_FIXINT));
26 1
27 } else if *self <= u8::MAX as u16 {
28 buf.extend(iter::once(Format::UINT8).chain(iter::once(*self as u8)));
29 2
30 } else {
31 buf.extend(iter::once(Format::UINT16).chain(self.to_be_bytes()));
32 3
33 }
34 }
35}
36
37impl Packable for u32 {
38 fn pack<T>(&self, buf: &mut T) -> usize
39 where
40 T: Extend<u8>,
41 {
42 if *self <= 127 {
43 buf.extend(iter::once(*self as u8 & Format::POSITIVE_FIXINT));
44 1
45 } else if *self <= u8::MAX as u32 {
46 buf.extend(iter::once(Format::UINT8).chain(iter::once(*self as u8)));
47 2
48 } else if *self <= u16::MAX as u32 {
49 buf.extend(iter::once(Format::UINT16).chain((*self as u16).to_be_bytes()));
50 3
51 } else {
52 buf.extend(iter::once(Format::UINT32).chain(self.to_be_bytes()));
53 5
54 }
55 }
56}
57
58impl Packable for u64 {
59 fn pack<T>(&self, buf: &mut T) -> usize
60 where
61 T: Extend<u8>,
62 {
63 if *self <= 127 {
64 buf.extend(iter::once(*self as u8 & Format::POSITIVE_FIXINT));
65 1
66 } else if *self <= u8::MAX as u64 {
67 buf.extend(iter::once(Format::UINT8).chain(iter::once(*self as u8)));
68 2
69 } else if *self <= u16::MAX as u64 {
70 buf.extend(iter::once(Format::UINT16).chain((*self as u16).to_be_bytes()));
71 3
72 } else if *self <= u32::MAX as u64 {
73 buf.extend(iter::once(Format::UINT32).chain((*self as u32).to_be_bytes()));
74 5
75 } else {
76 buf.extend(iter::once(Format::UINT64).chain(self.to_be_bytes()));
77 9
78 }
79 }
80}
81
82impl Packable for u128 {
83 fn pack<T>(&self, buf: &mut T) -> usize
84 where
85 T: Extend<u8>,
86 {
87 if *self <= 127 {
88 buf.extend(iter::once(*self as u8 & Format::POSITIVE_FIXINT));
89 1
90 } else if *self <= u8::MAX as u128 {
91 buf.extend(iter::once(Format::UINT8).chain(iter::once(*self as u8)));
92 2
93 } else if *self <= u16::MAX as u128 {
94 buf.extend(iter::once(Format::UINT16).chain((*self as u16).to_be_bytes()));
95 3
96 } else if *self <= u32::MAX as u128 {
97 buf.extend(iter::once(Format::UINT32).chain((*self as u32).to_be_bytes()));
98 5
99 } else if *self <= u64::MAX as u128 {
100 buf.extend(iter::once(Format::UINT64).chain((*self as u64).to_be_bytes()));
101 9
102 } else {
103 buf.extend(
104 iter::once(Format::BIN8)
105 .chain(iter::once(16))
106 .chain(self.to_be_bytes()),
107 );
108 18
109 }
110 }
111}
112
113impl Packable for usize {
114 fn pack<T>(&self, buf: &mut T) -> usize
115 where
116 T: Extend<u8>,
117 {
118 if *self <= 127 {
119 buf.extend(iter::once(*self as u8 & Format::POSITIVE_FIXINT));
120 1
121 } else if *self <= u8::MAX as usize {
122 buf.extend(iter::once(Format::UINT8).chain(iter::once(*self as u8)));
123 2
124 } else if *self <= u16::MAX as usize {
125 buf.extend(iter::once(Format::UINT16).chain((*self as u16).to_be_bytes()));
126 3
127 } else if *self <= u32::MAX as usize {
128 buf.extend(iter::once(Format::UINT32).chain((*self as u32).to_be_bytes()));
129 5
130 } else {
131 buf.extend(iter::once(Format::UINT64).chain(self.to_be_bytes()));
132 9
133 }
134 }
135}
136
137impl Packable for i8 {
138 fn pack<T>(&self, buf: &mut T) -> usize
139 where
140 T: Extend<u8>,
141 {
142 if *self <= -33 {
143 buf.extend(iter::once(Format::INT8).chain(iter::once(*self as u8)));
144 2
145 } else if *self <= -1 {
146 buf.extend(iter::once((*self | -32i8) as u8));
147 1
148 } else {
149 buf.extend(iter::once(*self as u8 & Format::POSITIVE_FIXINT));
150 1
151 }
152 }
153}
154
155impl Packable for i16 {
156 fn pack<T>(&self, buf: &mut T) -> usize
157 where
158 T: Extend<u8>,
159 {
160 if *self < i8::MIN as i16 {
161 buf.extend(iter::once(Format::INT16).chain(self.to_be_bytes()));
162 3
163 } else if *self <= -33 {
164 buf.extend(iter::once(Format::INT8).chain(iter::once((*self as i8) as u8)));
165 2
166 } else if *self <= -1 {
167 buf.extend(iter::once((*self as i8 | -32i8) as u8));
168 1
169 } else if *self <= i8::MAX as i16 {
170 buf.extend(iter::once(*self as u8 & Format::POSITIVE_FIXINT));
171 1
172 } else {
173 buf.extend(iter::once(Format::INT16).chain(self.to_be_bytes()));
174 3
175 }
176 }
177}
178
179impl Packable for i32 {
180 fn pack<T>(&self, buf: &mut T) -> usize
181 where
182 T: Extend<u8>,
183 {
184 if *self < i16::MIN as i32 {
185 buf.extend(iter::once(Format::INT32).chain(self.to_be_bytes()));
186 5
187 } else if *self < i8::MIN as i32 {
188 buf.extend(iter::once(Format::INT16).chain((*self as i16).to_be_bytes()));
189 3
190 } else if *self <= -33 {
191 buf.extend(iter::once(Format::INT8).chain(iter::once((*self as i8) as u8)));
192 2
193 } else if *self <= -1 {
194 buf.extend(iter::once((*self | -32i32) as u8));
195 1
196 } else if *self <= i8::MAX as i32 {
197 buf.extend(iter::once(*self as u8 & Format::POSITIVE_FIXINT));
198 1
199 } else if *self <= i16::MAX as i32 {
200 buf.extend(iter::once(Format::INT16).chain((*self as i16).to_be_bytes()));
201 3
202 } else {
203 buf.extend(iter::once(Format::INT32).chain(self.to_be_bytes()));
204 5
205 }
206 }
207}
208
209impl Packable for i64 {
210 fn pack<T>(&self, buf: &mut T) -> usize
211 where
212 T: Extend<u8>,
213 {
214 if *self < i32::MIN as i64 {
215 buf.extend(iter::once(Format::INT64).chain(self.to_be_bytes()));
216 9
217 } else if *self < i16::MIN as i64 {
218 buf.extend(iter::once(Format::INT32).chain((*self as i32).to_be_bytes()));
219 5
220 } else if *self < i8::MIN as i64 {
221 buf.extend(iter::once(Format::INT16).chain((*self as i16).to_be_bytes()));
222 3
223 } else if *self <= -33 {
224 buf.extend(iter::once(Format::INT8).chain(iter::once((*self as i8) as u8)));
225 2
226 } else if *self <= -1 {
227 buf.extend(iter::once((*self | -32i64) as u8));
228 1
229 } else if *self <= i8::MAX as i64 {
230 buf.extend(iter::once(*self as u8 & Format::POSITIVE_FIXINT));
231 1
232 } else if *self <= i16::MAX as i64 {
233 buf.extend(iter::once(Format::INT16).chain((*self as i16).to_be_bytes()));
234 3
235 } else if *self <= i32::MAX as i64 {
236 buf.extend(iter::once(Format::INT32).chain((*self as i32).to_be_bytes()));
237 5
238 } else {
239 buf.extend(iter::once(Format::INT64).chain(self.to_be_bytes()));
240 9
241 }
242 }
243}
244
245impl Packable for i128 {
246 fn pack<T>(&self, buf: &mut T) -> usize
247 where
248 T: Extend<u8>,
249 {
250 if *self < i64::MIN as i128 {
251 buf.extend(
252 iter::once(Format::BIN8)
253 .chain(iter::once(16))
254 .chain(self.to_be_bytes()),
255 );
256 18
257 } else if *self < i32::MIN as i128 {
258 buf.extend(iter::once(Format::INT64).chain((*self as i64).to_be_bytes()));
259 9
260 } else if *self < i16::MIN as i128 {
261 buf.extend(iter::once(Format::INT32).chain((*self as i32).to_be_bytes()));
262 5
263 } else if *self < i8::MIN as i128 {
264 buf.extend(iter::once(Format::INT16).chain((*self as i16).to_be_bytes()));
265 3
266 } else if *self <= -33 {
267 buf.extend(iter::once(Format::INT8).chain(iter::once((*self as i8) as u8)));
268 2
269 } else if *self <= -1 {
270 buf.extend(iter::once((*self | -32i128) as u8));
271 1
272 } else if *self <= i8::MAX as i128 {
273 buf.extend(iter::once(*self as u8 & Format::POSITIVE_FIXINT));
274 1
275 } else if *self <= i16::MAX as i128 {
276 buf.extend(iter::once(Format::INT16).chain((*self as i16).to_be_bytes()));
277 3
278 } else if *self <= i32::MAX as i128 {
279 buf.extend(iter::once(Format::INT32).chain((*self as i32).to_be_bytes()));
280 5
281 } else if *self <= i64::MAX as i128 {
282 buf.extend(iter::once(Format::INT64).chain((*self as i64).to_be_bytes()));
283 9
284 } else {
285 buf.extend(
286 iter::once(Format::BIN8)
287 .chain(iter::once(16))
288 .chain(self.to_be_bytes()),
289 );
290 18
291 }
292 }
293}
294
295impl Packable for isize {
296 fn pack<T>(&self, buf: &mut T) -> usize
297 where
298 T: Extend<u8>,
299 {
300 if *self < i32::MIN as isize {
301 buf.extend(iter::once(Format::INT64).chain(self.to_be_bytes()));
302 9
303 } else if *self < i16::MIN as isize {
304 buf.extend(iter::once(Format::INT32).chain((*self as i32).to_be_bytes()));
305 5
306 } else if *self < i8::MIN as isize {
307 buf.extend(iter::once(Format::INT16).chain((*self as i16).to_be_bytes()));
308 3
309 } else if *self <= -33 {
310 buf.extend(iter::once(Format::INT8).chain(iter::once((*self as i8) as u8)));
311 2
312 } else if *self <= -1 {
313 buf.extend(iter::once((*self | -32isize) as u8));
314 1
315 } else if *self <= i8::MAX as isize {
316 buf.extend(iter::once(*self as u8 & Format::POSITIVE_FIXINT));
317 1
318 } else if *self <= i16::MAX as isize {
319 buf.extend(iter::once(Format::INT16).chain((*self as i16).to_be_bytes()));
320 3
321 } else if *self <= i32::MAX as isize {
322 buf.extend(iter::once(Format::INT32).chain((*self as i32).to_be_bytes()));
323 5
324 } else {
325 buf.extend(iter::once(Format::INT64).chain(self.to_be_bytes()));
326 9
327 }
328 }
329}