cookie_factory/
bytes.rs

1//! bytes and numbers related serialization functions
2use crate::internal::{GenError, SerializeFn, WriteContext};
3use crate::lib::std::io::Write;
4
5macro_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/// ```
28pub 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/// ```
49pub 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/// ```
70pub 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/// ```
91pub 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/// ```
112pub 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/// ```
133pub 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/// ```
152pub 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/// ```
171pub 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/// ```
190pub 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/// ```
209pub 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/// ```
228pub 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/// ```
247pub 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/// ```
266pub 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/// ```
287pub 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/// ```
308pub 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/// ```
329pub 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/// ```
350pub 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/// ```
371pub 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/// ```
390pub 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/// ```
409pub 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/// ```
428pub 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/// ```
447pub 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/// ```
466pub 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/// ```
485pub 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/// ```
504pub 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/// ```
528pub 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/// ```
552pub 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/// ```
576pub 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/// ```
600pub 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/// ```
621pub 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/// ```
643pub 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/// ```
665pub 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/// ```
687pub 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/// ```
709pub 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/// ```
731pub 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/// ```
753pub fn ne_f64<W: Write>(i: f64) -> impl SerializeFn<W> {
754    ne_u64(i.to_bits())
755}
cookie_factory/bytes.rs

cookie_factory/
bytes.rs
