1 //! bytes and numbers related serialization functions
2 use crate::internal::{SerializeFn, WriteContext, GenError};
3 use crate::lib::std::io::Write;
4 
5 macro_rules! try_write(($out:ident, $len:ident, $data:expr) => (
6     match $out.write($data) {
7         Err(io)           => Err(GenError::IoError(io)),
8         Ok(n) if n < $len => Err(GenError::BufferTooSmall($len - n)),
9         Ok(_)             => Ok($out)
10     }
11 ));
12 
13 /// Writes an `u8` to the output
14 ///
15 /// ```rust
16 /// use cookie_factory::{gen, bytes::be_u8};
17 ///
18 /// let mut buf = [0u8; 100];
19 ///
20 /// {
21 ///   let (buf, pos) = gen(be_u8(1u8), &mut buf[..]).unwrap();
22 ///   assert_eq!(pos, 1);
23 ///   assert_eq!(buf.len(), 100 - 1);
24 /// }
25 ///
26 /// assert_eq!(&buf[..1], &[1u8][..]);
27 /// ```
be_u8<W: Write>(i: u8) -> impl SerializeFn<W>28 pub fn be_u8<W: Write>(i: u8) -> impl SerializeFn<W> {
29     let len = 1;
30 
31     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_be_bytes()[..])
32 }
33 
34 /// Writes an `u16` in big endian byte order to the output
35 ///
36 /// ```rust
37 /// use cookie_factory::{gen, bytes::be_u16};
38 ///
39 /// let mut buf = [0u8; 100];
40 ///
41 /// {
42 ///   let (buf, pos) = gen(be_u16(1u16), &mut buf[..]).unwrap();
43 ///   assert_eq!(pos, 2);
44 ///   assert_eq!(buf.len(), 100 - 2);
45 /// }
46 ///
47 /// assert_eq!(&buf[..2], &[0u8, 1u8][..]);
48 /// ```
be_u16<W: Write>(i: u16) -> impl SerializeFn<W>49 pub fn be_u16<W: Write>(i: u16) -> impl SerializeFn<W> {
50     let len = 2;
51 
52     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_be_bytes()[..])
53 }
54 
55 /// Writes the lower 24 bit of an `u32` in big endian byte order to the output
56 ///
57 /// ```rust
58 /// use cookie_factory::{gen, bytes::be_u24};
59 ///
60 /// let mut buf = [0u8; 100];
61 ///
62 /// {
63 ///   let (buf, pos) = gen(be_u24(1u32), &mut buf[..]).unwrap();
64 ///   assert_eq!(pos, 3);
65 ///   assert_eq!(buf.len(), 100 - 3);
66 /// }
67 ///
68 /// assert_eq!(&buf[..3], &[0u8, 0u8, 1u8][..]);
69 /// ```
be_u24<W: Write>(i: u32) -> impl SerializeFn<W>70 pub fn be_u24<W: Write>(i: u32) -> impl SerializeFn<W> {
71     let len = 3;
72 
73     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_be_bytes()[1..])
74 }
75 
76 /// Writes an `u32` in big endian byte order to the output
77 ///
78 /// ```rust
79 /// use cookie_factory::{gen, bytes::be_u32};
80 ///
81 /// let mut buf = [0u8; 100];
82 ///
83 /// {
84 ///   let (buf, pos) = gen(be_u32(1u32), &mut buf[..]).unwrap();
85 ///   assert_eq!(pos, 4);
86 ///   assert_eq!(buf.len(), 100 - 4);
87 /// }
88 ///
89 /// assert_eq!(&buf[..4], &[0u8, 0u8, 0u8, 1u8][..]);
90 /// ```
be_u32<W: Write>(i: u32) -> impl SerializeFn<W>91 pub fn be_u32<W: Write>(i: u32) -> impl SerializeFn<W> {
92     let len = 4;
93 
94     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_be_bytes()[..])
95 }
96 
97 /// Writes an `u64` in big endian byte order to the output
98 ///
99 /// ```rust
100 /// use cookie_factory::{gen, bytes::be_u64};
101 ///
102 /// let mut buf = [0u8; 100];
103 ///
104 /// {
105 ///   let (buf, pos) = gen(be_u64(1u64), &mut buf[..]).unwrap();
106 ///   assert_eq!(pos, 8);
107 ///   assert_eq!(buf.len(), 100 - 8);
108 /// }
109 ///
110 /// assert_eq!(&buf[..8], &[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8][..]);
111 /// ```
be_u64<W: Write>(i: u64) -> impl SerializeFn<W>112 pub fn be_u64<W: Write>(i: u64) -> impl SerializeFn<W> {
113     let len = 8;
114 
115     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_be_bytes()[..])
116 }
117 
118 /// Writes an `i8` to the output
119 ///
120 /// ```rust
121 /// use cookie_factory::{gen, bytes::be_i8};
122 ///
123 /// let mut buf = [0u8; 100];
124 ///
125 /// {
126 ///   let (buf, pos) = gen(be_i8(1i8), &mut buf[..]).unwrap();
127 ///   assert_eq!(pos, 1);
128 ///   assert_eq!(buf.len(), 100 - 1);
129 /// }
130 ///
131 /// assert_eq!(&buf[..1], &[1u8][..]);
132 /// ```
be_i8<W: Write>(i: i8) -> impl SerializeFn<W>133 pub fn be_i8<W: Write>(i: i8) -> impl SerializeFn<W> {
134     be_u8(i as u8)
135 }
136 
137 /// Writes an `i16` in big endian byte order to the output
138 ///
139 /// ```rust
140 /// use cookie_factory::{gen, bytes::be_i16};
141 ///
142 /// let mut buf = [0u8; 100];
143 ///
144 /// {
145 ///   let (buf, pos) = gen(be_i16(1i16), &mut buf[..]).unwrap();
146 ///   assert_eq!(pos, 2);
147 ///   assert_eq!(buf.len(), 100 - 2);
148 /// }
149 ///
150 /// assert_eq!(&buf[..2], &[0u8, 1u8][..]);
151 /// ```
be_i16<W: Write>(i: i16) -> impl SerializeFn<W>152 pub fn be_i16<W: Write>(i: i16) -> impl SerializeFn<W> {
153     be_u16(i as u16)
154 }
155 
156 /// Writes the lower 24 bit of an `i32` in big endian byte order to the output
157 ///
158 /// ```rust
159 /// use cookie_factory::{gen, bytes::be_i24};
160 ///
161 /// let mut buf = [0u8; 100];
162 ///
163 /// {
164 ///   let (buf, pos) = gen(be_i24(1i32), &mut buf[..]).unwrap();
165 ///   assert_eq!(pos, 3);
166 ///   assert_eq!(buf.len(), 100 - 3);
167 /// }
168 ///
169 /// assert_eq!(&buf[..3], &[0u8, 0u8, 1u8][..]);
170 /// ```
be_i24<W: Write>(i: i32) -> impl SerializeFn<W>171 pub fn be_i24<W: Write>(i: i32) -> impl SerializeFn<W> {
172     be_u24(i as u32)
173 }
174 
175 /// Writes an `i32` in big endian byte order to the output
176 ///
177 /// ```rust
178 /// use cookie_factory::{gen, bytes::be_i32};
179 ///
180 /// let mut buf = [0u8; 100];
181 ///
182 /// {
183 ///   let (buf, pos) = gen(be_i32(1i32), &mut buf[..]).unwrap();
184 ///   assert_eq!(pos, 4);
185 ///   assert_eq!(buf.len(), 100 - 4);
186 /// }
187 ///
188 /// assert_eq!(&buf[..4], &[0u8, 0u8, 0u8, 1u8][..]);
189 /// ```
be_i32<W: Write>(i: i32) -> impl SerializeFn<W>190 pub fn be_i32<W: Write>(i: i32) -> impl SerializeFn<W> {
191     be_u32(i as u32)
192 }
193 
194 /// Writes an `i64` in big endian byte order to the output
195 ///
196 /// ```rust
197 /// use cookie_factory::{gen, bytes::be_i64};
198 ///
199 /// let mut buf = [0u8; 100];
200 ///
201 /// {
202 ///   let (buf, pos) = gen(be_i64(1i64), &mut buf[..]).unwrap();
203 ///   assert_eq!(pos, 8);
204 ///   assert_eq!(buf.len(), 100 - 8);
205 /// }
206 ///
207 /// assert_eq!(&buf[..8], &[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8][..]);
208 /// ```
be_i64<W: Write>(i: i64) -> impl SerializeFn<W>209 pub fn be_i64<W: Write>(i: i64) -> impl SerializeFn<W> {
210     be_u64(i as u64)
211 }
212 
213 /// Writes an `f32` in big endian byte order to the output
214 ///
215 /// ```rust
216 /// use cookie_factory::{gen, bytes::be_f32};
217 ///
218 /// let mut buf = [0u8; 100];
219 ///
220 /// {
221 ///   let (buf, pos) = gen(be_f32(1.0f32), &mut buf[..]).unwrap();
222 ///   assert_eq!(pos, 4);
223 ///   assert_eq!(buf.len(), 100 - 4);
224 /// }
225 ///
226 /// assert_eq!(&buf[..4], &[63u8, 128u8, 0u8, 0u8][..]);
227 /// ```
be_f32<W: Write>(i: f32) -> impl SerializeFn<W>228 pub fn be_f32<W: Write>(i: f32) -> impl SerializeFn<W> {
229     be_u32(i.to_bits())
230 }
231 
232 /// Writes an `f64` in big endian byte order to the output
233 ///
234 /// ```rust
235 /// use cookie_factory::{gen, bytes::be_f64};
236 ///
237 /// let mut buf = [0u8; 100];
238 ///
239 /// {
240 ///   let (buf, pos) = gen(be_f64(1.0f64), &mut buf[..]).unwrap();
241 ///   assert_eq!(pos, 8);
242 ///   assert_eq!(buf.len(), 100 - 8);
243 /// }
244 ///
245 /// assert_eq!(&buf[..8], &[63u8, 240u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8][..]);
246 /// ```
be_f64<W: Write>(i: f64) -> impl SerializeFn<W>247 pub fn be_f64<W: Write>(i: f64) -> impl SerializeFn<W> {
248     be_u64(i.to_bits())
249 }
250 
251 /// Writes an `u8` to the output
252 ///
253 /// ```rust
254 /// use cookie_factory::{gen, bytes::le_u8};
255 ///
256 /// let mut buf = [0u8; 100];
257 ///
258 /// {
259 ///   let (buf, pos) = gen(le_u8(1u8), &mut buf[..]).unwrap();
260 ///   assert_eq!(pos, 1);
261 ///   assert_eq!(buf.len(), 100 - 1);
262 /// }
263 ///
264 /// assert_eq!(&buf[..1], &[1u8][..]);
265 /// ```
le_u8<W: Write>(i: u8) -> impl SerializeFn<W>266 pub fn le_u8<W: Write>(i: u8) -> impl SerializeFn<W> {
267     let len = 1;
268 
269     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_le_bytes()[..])
270 }
271 
272 /// Writes an `u16` in little endian byte order to the output
273 ///
274 /// ```rust
275 /// use cookie_factory::{gen, bytes::le_u16};
276 ///
277 /// let mut buf = [0u8; 100];
278 ///
279 /// {
280 ///   let (buf, pos) = gen(le_u16(1u16), &mut buf[..]).unwrap();
281 ///   assert_eq!(pos, 2);
282 ///   assert_eq!(buf.len(), 100 - 2);
283 /// }
284 ///
285 /// assert_eq!(&buf[..2], &[1u8, 0u8][..]);
286 /// ```
le_u16<W: Write>(i: u16) -> impl SerializeFn<W>287 pub fn le_u16<W: Write>(i: u16) -> impl SerializeFn<W> {
288     let len = 2;
289 
290     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_le_bytes()[..])
291 }
292 
293 /// Writes the lower 24 bit of an `u32` in little endian byte order to the output
294 ///
295 /// ```rust
296 /// use cookie_factory::{gen, bytes::le_u24};
297 ///
298 /// let mut buf = [0u8; 100];
299 ///
300 /// {
301 ///   let (buf, pos) = gen(le_u24(1u32), &mut buf[..]).unwrap();
302 ///   assert_eq!(pos, 3);
303 ///   assert_eq!(buf.len(), 100 - 3);
304 /// }
305 ///
306 /// assert_eq!(&buf[..3], &[1u8, 0u8, 0u8][..]);
307 /// ```
le_u24<W: Write>(i: u32) -> impl SerializeFn<W>308 pub fn le_u24<W: Write>(i: u32) -> impl SerializeFn<W> {
309     let len = 3;
310 
311     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_le_bytes()[0..3])
312 }
313 
314 /// Writes an `u32` in little endian byte order to the output
315 ///
316 /// ```rust
317 /// use cookie_factory::{gen, bytes::le_u32};
318 ///
319 /// let mut buf = [0u8; 100];
320 ///
321 /// {
322 ///   let (buf, pos) = gen(le_u32(1u32), &mut buf[..]).unwrap();
323 ///   assert_eq!(pos, 4);
324 ///   assert_eq!(buf.len(), 100 - 4);
325 /// }
326 ///
327 /// assert_eq!(&buf[..4], &[1u8, 0u8, 0u8, 0u8][..]);
328 /// ```
le_u32<W: Write>(i: u32) -> impl SerializeFn<W>329 pub fn le_u32<W: Write>(i: u32) -> impl SerializeFn<W> {
330     let len = 4;
331 
332     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_le_bytes()[..])
333 }
334 
335 /// Writes an `u64` in little endian byte order to the output
336 ///
337 /// ```rust
338 /// use cookie_factory::{gen, bytes::le_u64};
339 ///
340 /// let mut buf = [0u8; 100];
341 ///
342 /// {
343 ///   let (buf, pos) = gen(le_u64(1u64), &mut buf[..]).unwrap();
344 ///   assert_eq!(pos, 8);
345 ///   assert_eq!(buf.len(), 100 - 8);
346 /// }
347 ///
348 /// assert_eq!(&buf[..8], &[1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8][..]);
349 /// ```
le_u64<W: Write>(i: u64) -> impl SerializeFn<W>350 pub fn le_u64<W: Write>(i: u64) -> impl SerializeFn<W> {
351     let len = 8;
352 
353     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_le_bytes()[..])
354 }
355 
356 /// Writes an `i8` to the output
357 ///
358 /// ```rust
359 /// use cookie_factory::{gen, bytes::le_i8};
360 ///
361 /// let mut buf = [0u8; 100];
362 ///
363 /// {
364 ///   let (buf, pos) = gen(le_i8(1i8), &mut buf[..]).unwrap();
365 ///   assert_eq!(pos, 1);
366 ///   assert_eq!(buf.len(), 100 - 1);
367 /// }
368 ///
369 /// assert_eq!(&buf[..1], &[1u8][..]);
370 /// ```
le_i8<W: Write>(i: i8) -> impl SerializeFn<W>371 pub fn le_i8<W: Write>(i: i8) -> impl SerializeFn<W> {
372     le_u8(i as u8)
373 }
374 
375 /// Writes an `o16` in little endian byte order to the output
376 ///
377 /// ```rust
378 /// use cookie_factory::{gen, bytes::le_i16};
379 ///
380 /// let mut buf = [0u8; 100];
381 ///
382 /// {
383 ///   let (buf, pos) = gen(le_i16(1i16), &mut buf[..]).unwrap();
384 ///   assert_eq!(pos, 2);
385 ///   assert_eq!(buf.len(), 100 - 2);
386 /// }
387 ///
388 /// assert_eq!(&buf[..2], &[1u8, 0u8][..]);
389 /// ```
le_i16<W: Write>(i: i16) -> impl SerializeFn<W>390 pub fn le_i16<W: Write>(i: i16) -> impl SerializeFn<W> {
391     le_u16(i as u16)
392 }
393 
394 /// Writes the lower 24 bit of an `i32` in little endian byte order to the output
395 ///
396 /// ```rust
397 /// use cookie_factory::{gen, bytes::le_i24};
398 ///
399 /// let mut buf = [0u8; 100];
400 ///
401 /// {
402 ///   let (buf, pos) = gen(le_i24(1i32), &mut buf[..]).unwrap();
403 ///   assert_eq!(pos, 3);
404 ///   assert_eq!(buf.len(), 100 - 3);
405 /// }
406 ///
407 /// assert_eq!(&buf[..3], &[1u8, 0u8, 0u8][..]);
408 /// ```
le_i24<W: Write>(i: i32) -> impl SerializeFn<W>409 pub fn le_i24<W: Write>(i: i32) -> impl SerializeFn<W> {
410     le_u24(i as u32)
411 }
412 
413 /// Writes an `i32` in little endian byte order to the output
414 ///
415 /// ```rust
416 /// use cookie_factory::{gen, bytes::le_i32};
417 ///
418 /// let mut buf = [0u8; 100];
419 ///
420 /// {
421 ///   let (buf, pos) = gen(le_i32(1i32), &mut buf[..]).unwrap();
422 ///   assert_eq!(pos, 4);
423 ///   assert_eq!(buf.len(), 100 - 4);
424 /// }
425 ///
426 /// assert_eq!(&buf[..4], &[1u8, 0u8, 0u8, 0u8][..]);
427 /// ```
le_i32<W: Write>(i: i32) -> impl SerializeFn<W>428 pub fn le_i32<W: Write>(i: i32) -> impl SerializeFn<W> {
429     le_u32(i as u32)
430 }
431 
432 /// Writes an `i64` in little endian byte order to the output
433 ///
434 /// ```rust
435 /// use cookie_factory::{gen, bytes::le_i64};
436 ///
437 /// let mut buf = [0u8; 100];
438 ///
439 /// {
440 ///   let (buf, pos) = gen(le_i64(1i64), &mut buf[..]).unwrap();
441 ///   assert_eq!(pos, 8);
442 ///   assert_eq!(buf.len(), 100 - 8);
443 /// }
444 ///
445 /// assert_eq!(&buf[..8], &[1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8][..]);
446 /// ```
le_i64<W: Write>(i: i64) -> impl SerializeFn<W>447 pub fn le_i64<W: Write>(i: i64) -> impl SerializeFn<W> {
448     le_u64(i as u64)
449 }
450 
451 /// Writes an `f32` in little endian byte order to the output
452 ///
453 /// ```rust
454 /// use cookie_factory::{gen, bytes::le_f32};
455 ///
456 /// let mut buf = [0u8; 100];
457 ///
458 /// {
459 ///   let (buf, pos) = gen(le_f32(1.0f32), &mut buf[..]).unwrap();
460 ///   assert_eq!(pos, 4);
461 ///   assert_eq!(buf.len(), 100 - 4);
462 /// }
463 ///
464 /// assert_eq!(&buf[..4], &[0u8, 0u8, 128u8, 63u8][..]);
465 /// ```
le_f32<W: Write>(i: f32) -> impl SerializeFn<W>466 pub fn le_f32<W: Write>(i: f32) -> impl SerializeFn<W> {
467     le_u32(i.to_bits())
468 }
469 
470 /// Writes an `f64` in little endian byte order to the output
471 ///
472 /// ```rust
473 /// use cookie_factory::{gen, bytes::le_f64};
474 ///
475 /// let mut buf = [0u8; 100];
476 ///
477 /// {
478 ///   let (buf, pos) = gen(le_f64(1.0f64), &mut buf[..]).unwrap();
479 ///   assert_eq!(pos, 8);
480 ///   assert_eq!(buf.len(), 100 - 8);
481 /// }
482 ///
483 /// assert_eq!(&buf[..8], &[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 240u8, 63u8][..]);
484 /// ```
le_f64<W: Write>(i: f64) -> impl SerializeFn<W>485 pub fn le_f64<W: Write>(i: f64) -> impl SerializeFn<W> {
486     le_u64(i.to_bits())
487 }
488 
489 /// Writes an `u8` to the output
490 ///
491 /// ```rust
492 /// use cookie_factory::{gen, bytes::ne_u8};
493 ///
494 /// let mut buf = [0u8; 100];
495 ///
496 /// {
497 ///   let (buf, pos) = gen(ne_u8(1u8), &mut buf[..]).unwrap();
498 ///   assert_eq!(pos, 1);
499 ///   assert_eq!(buf.len(), 100 - 1);
500 /// }
501 ///
502 /// assert_eq!(&buf[..1], &[1u8][..]);
503 /// ```
ne_u8<W: Write>(i: u8) -> impl SerializeFn<W>504 pub fn ne_u8<W: Write>(i: u8) -> impl SerializeFn<W> {
505     let len = 1;
506 
507     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_ne_bytes()[..])
508 }
509 
510 /// Writes an `u16` in native byte order to the output
511 ///
512 /// ```rust
513 /// use cookie_factory::{gen, bytes::ne_u16};
514 ///
515 /// let mut buf = [0u8; 100];
516 ///
517 /// {
518 ///   let (buf, pos) = gen(ne_u16(1u16), &mut buf[..]).unwrap();
519 ///   assert_eq!(pos, 2);
520 ///   assert_eq!(buf.len(), 100 - 2);
521 /// }
522 ///
523 /// #[cfg(target_endian = "big")]
524 /// assert_eq!(&buf[..2], &[0u8, 1u8][..]);
525 /// #[cfg(target_endian = "litte")]
526 /// assert_eq!(&buf[..2], &[1u8, 0u8][..]);
527 /// ```
ne_u16<W: Write>(i: u16) -> impl SerializeFn<W>528 pub fn ne_u16<W: Write>(i: u16) -> impl SerializeFn<W> {
529     let len = 2;
530 
531     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_ne_bytes()[..])
532 }
533 
534 /// Writes the lower 24 bit of an `u32` in native byte order to the output
535 ///
536 /// ```rust
537 /// use cookie_factory::{gen, bytes::ne_u24};
538 ///
539 /// let mut buf = [0u8; 100];
540 ///
541 /// {
542 ///   let (buf, pos) = gen(ne_u24(1u32), &mut buf[..]).unwrap();
543 ///   assert_eq!(pos, 3);
544 ///   assert_eq!(buf.len(), 100 - 3);
545 /// }
546 ///
547 /// #[cfg(target_endian = "big")]
548 /// assert_eq!(&buf[..3], &[0u8, 0u8, 1u8][..]);
549 /// #[cfg(target_endian = "litte")]
550 /// assert_eq!(&buf[..3], &[1u8, 0u8, 0u8][..]);
551 /// ```
ne_u24<W: Write>(i: u32) -> impl SerializeFn<W>552 pub fn ne_u24<W: Write>(i: u32) -> impl SerializeFn<W> {
553     let len = 3;
554 
555     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_ne_bytes()[1..])
556 }
557 
558 /// Writes an `u32` in native byte order to the output
559 ///
560 /// ```rust
561 /// use cookie_factory::{gen, bytes::ne_u32};
562 ///
563 /// let mut buf = [0u8; 100];
564 ///
565 /// {
566 ///   let (buf, pos) = gen(ne_u32(1u32), &mut buf[..]).unwrap();
567 ///   assert_eq!(pos, 4);
568 ///   assert_eq!(buf.len(), 100 - 4);
569 /// }
570 ///
571 /// #[cfg(target_endian = "big")]
572 /// assert_eq!(&buf[..4], &[0u8, 0u8, 0u8, 1u8][..]);
573 /// #[cfg(target_endian = "litte")]
574 /// assert_eq!(&buf[..4], &[1u8, 0u8, 0u8, 0u8][..]);
575 /// ```
ne_u32<W: Write>(i: u32) -> impl SerializeFn<W>576 pub fn ne_u32<W: Write>(i: u32) -> impl SerializeFn<W> {
577     let len = 4;
578 
579     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_ne_bytes()[..])
580 }
581 
582 /// Writes an `u64` in native byte order to the output
583 ///
584 /// ```rust
585 /// use cookie_factory::{gen, bytes::ne_u64};
586 ///
587 /// let mut buf = [0u8; 100];
588 ///
589 /// {
590 ///   let (buf, pos) = gen(ne_u64(1u64), &mut buf[..]).unwrap();
591 ///   assert_eq!(pos, 8);
592 ///   assert_eq!(buf.len(), 100 - 8);
593 /// }
594 ///
595 /// #[cfg(target_endian = "big")]
596 /// assert_eq!(&buf[..8], &[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8][..]);
597 /// #[cfg(target_endian = "litte")]
598 /// assert_eq!(&buf[..8], &[1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8][..]);
599 /// ```
ne_u64<W: Write>(i: u64) -> impl SerializeFn<W>600 pub fn ne_u64<W: Write>(i: u64) -> impl SerializeFn<W> {
601     let len = 8;
602 
603     move |mut out: WriteContext<W>| try_write!(out, len, &i.to_ne_bytes()[..])
604 }
605 
606 /// Writes an `i8` to the output
607 ///
608 /// ```rust
609 /// use cookie_factory::{gen, bytes::ne_i8};
610 ///
611 /// let mut buf = [0u8; 100];
612 ///
613 /// {
614 ///   let (buf, pos) = gen(ne_i8(1i8), &mut buf[..]).unwrap();
615 ///   assert_eq!(pos, 1);
616 ///   assert_eq!(buf.len(), 100 - 1);
617 /// }
618 ///
619 /// assert_eq!(&buf[..1], &[1u8][..]);
620 /// ```
ne_i8<W: Write>(i: i8) -> impl SerializeFn<W>621 pub fn ne_i8<W: Write>(i: i8) -> impl SerializeFn<W> {
622     ne_u8(i as u8)
623 }
624 
625 /// Writes an `i16` in native byte order to the output
626 ///
627 /// ```rust
628 /// use cookie_factory::{gen, bytes::ne_i16};
629 ///
630 /// let mut buf = [0u8; 100];
631 ///
632 /// {
633 ///   let (buf, pos) = gen(ne_i16(1i16), &mut buf[..]).unwrap();
634 ///   assert_eq!(pos, 2);
635 ///   assert_eq!(buf.len(), 100 - 2);
636 /// }
637 ///
638 /// #[cfg(target_endian = "big")]
639 /// assert_eq!(&buf[..2], &[0u8, 1u8][..]);
640 /// #[cfg(target_endian = "litte")]
641 /// assert_eq!(&buf[..2], &[1u8, 0u8][..]);
642 /// ```
ne_i16<W: Write>(i: i16) -> impl SerializeFn<W>643 pub fn ne_i16<W: Write>(i: i16) -> impl SerializeFn<W> {
644     ne_u16(i as u16)
645 }
646 
647 /// Writes the lower 24 bit of an `i32` in native byte order to the output
648 ///
649 /// ```rust
650 /// use cookie_factory::{gen, bytes::ne_i24};
651 ///
652 /// let mut buf = [0u8; 100];
653 ///
654 /// {
655 ///   let (buf, pos) = gen(ne_i24(1i32), &mut buf[..]).unwrap();
656 ///   assert_eq!(pos, 3);
657 ///   assert_eq!(buf.len(), 100 - 3);
658 /// }
659 ///
660 /// #[cfg(target_endian = "big")]
661 /// assert_eq!(&buf[..3], &[0u8, 0u8, 1u8][..]);
662 /// #[cfg(target_endian = "litte")]
663 /// assert_eq!(&buf[..3], &[1u8, 0u8, 0u8][..]);
664 /// ```
ne_i24<W: Write>(i: i32) -> impl SerializeFn<W>665 pub fn ne_i24<W: Write>(i: i32) -> impl SerializeFn<W> {
666     ne_u24(i as u32)
667 }
668 
669 /// Writes an `i32` in native byte order to the output
670 ///
671 /// ```rust
672 /// use cookie_factory::{gen, bytes::ne_i32};
673 ///
674 /// let mut buf = [0u8; 100];
675 ///
676 /// {
677 ///   let (buf, pos) = gen(ne_i32(1i32), &mut buf[..]).unwrap();
678 ///   assert_eq!(pos, 4);
679 ///   assert_eq!(buf.len(), 100 - 4);
680 /// }
681 ///
682 /// #[cfg(target_endian = "big")]
683 /// assert_eq!(&buf[..4], &[0u8, 0u8, 0u8, 1u8][..]);
684 /// #[cfg(target_endian = "litte")]
685 /// assert_eq!(&buf[..4], &[1u8, 0u8, 0u8, 0u8][..]);
686 /// ```
ne_i32<W: Write>(i: i32) -> impl SerializeFn<W>687 pub fn ne_i32<W: Write>(i: i32) -> impl SerializeFn<W> {
688     ne_u32(i as u32)
689 }
690 
691 /// Writes an `i64` in native byte order to the output
692 ///
693 /// ```rust
694 /// use cookie_factory::{gen, bytes::ne_i64};
695 ///
696 /// let mut buf = [0u8; 100];
697 ///
698 /// {
699 ///   let (buf, pos) = gen(ne_i64(1i64), &mut buf[..]).unwrap();
700 ///   assert_eq!(pos, 8);
701 ///   assert_eq!(buf.len(), 100 - 8);
702 /// }
703 ///
704 /// #[cfg(target_endian = "big")]
705 /// assert_eq!(&buf[..8], &[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8][..]);
706 /// #[cfg(target_endian = "litte")]
707 /// assert_eq!(&buf[..8], &[1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8][..]);
708 /// ```
ne_i64<W: Write>(i: i64) -> impl SerializeFn<W>709 pub fn ne_i64<W: Write>(i: i64) -> impl SerializeFn<W> {
710     ne_u64(i as u64)
711 }
712 
713 /// Writes an `f32` in native byte order to the output
714 ///
715 /// ```rust
716 /// use cookie_factory::{gen, bytes::ne_f32};
717 ///
718 /// let mut buf = [0u8; 100];
719 ///
720 /// {
721 ///   let (buf, pos) = gen(ne_f32(1.0f32), &mut buf[..]).unwrap();
722 ///   assert_eq!(pos, 4);
723 ///   assert_eq!(buf.len(), 100 - 4);
724 /// }
725 ///
726 /// #[cfg(target_endian = "big")]
727 /// assert_eq!(&buf[..4], &[63u8, 128u8, 0u8, 0u8][..]);
728 /// #[cfg(target_endian = "little")]
729 /// assert_eq!(&buf[..4], &[0u8, 0u8, 128u8, 63u8][..]);
730 /// ```
ne_f32<W: Write>(i: f32) -> impl SerializeFn<W>731 pub fn ne_f32<W: Write>(i: f32) -> impl SerializeFn<W> {
732     ne_u32(i.to_bits())
733 }
734 
735 /// Writes an `f64` in native byte order to the output
736 ///
737 /// ```rust
738 /// use cookie_factory::{gen, bytes::ne_f64};
739 ///
740 /// let mut buf = [0u8; 100];
741 ///
742 /// {
743 ///   let (buf, pos) = gen(ne_f64(1.0f64), &mut buf[..]).unwrap();
744 ///   assert_eq!(pos, 8);
745 ///   assert_eq!(buf.len(), 100 - 8);
746 /// }
747 ///
748 /// #[cfg(target_endian = "big")]
749 /// assert_eq!(&buf[..8], &[63u8, 240u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8][..]);
750 /// #[cfg(target_endian = "little")]
751 /// assert_eq!(&buf[..8], &[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 240u8, 63u8][..]);
752 /// ```
ne_f64<W: Write>(i: f64) -> impl SerializeFn<W>753 pub fn ne_f64<W: Write>(i: f64) -> impl SerializeFn<W> {
754     ne_u64(i.to_bits())
755 }
756