io_ext 0.2.0

Read & Write extensions to deal with primitive types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use std::io::{Result, Write};

macro_rules! impl_write {
    ($($type:ty),*) => {
        $(
            paste::paste! {
                #[inline]
                fn [<write_ $type _ne>](&mut self, value: $type) -> usize {
                    self.write(&value.to_ne_bytes()).expect("Write failed")
                }

                #[inline]
                fn [<write_ $type _ne_checked>](&mut self, value: $type) -> Result<usize> {
                    self.write(&value.to_ne_bytes())
                }

                #[inline]
                fn [<write_ $type>](&mut self, value: $type) -> usize {
                    self.write(&value.to_be_bytes()).expect("Write failed")
                }

                #[inline]
                fn [<write_ $type _checked>](&mut self, value: $type) -> Result<usize> {
                    self.write(&value.to_be_bytes())
                }

                #[inline]
                fn [<write_ $type _le>](&mut self, value: $type) -> usize {
                    self.write(&value.to_le_bytes()).expect("Write failed")
                }

                #[inline]
                fn [<write_ $type _le_checked>](&mut self, value: $type) -> Result<usize> {
                    self.write(&value.to_le_bytes())
                }
            }
        )*
    };
}

/// # Write extension
/// All provided methods interprets input value with specified engianess and then writes them to the writer.
/// # Panics
/// If [`std::io::Write::write`] will return an error, **ALL** methods that doesn't end with `_checked` will panic.
/// All `_checked` methods will return an error in that case.
/// Provided methods:
/// * `write_*_ne` - Native-endian
/// * `write_*_be` - Big-endian
/// * `write_*_le` - Little-endian
/// # Example
/// ```
/// use io_ext::WriteExt;
/// 
/// let mut buf = Box::new([0u8; 4]);
/// let mut slice = &mut buf[..];
/// // Note: &[u8] implements Read trait
///
/// slice.write_u16(0x40);
/// assert!(slice.write_i16_le_checked(13).is_ok());
///
/// assert_eq!(&buf[..], b"\x00\x40\x0D\x00");
/// ```
pub trait WriteExt: Write {
    #[inline]
    fn write_u8(&mut self, value: u8) -> usize {
        self.write(std::slice::from_ref(&value)).expect("Write failed")
    }

    #[inline]
    fn write_u8_checked(&mut self, value: u8) -> Result<usize> {
        self.write(std::slice::from_ref(&value))
    }

    impl_write!(f32 , f64, u16, i16, u32, i32, u64, i64, u128, i128);
}

impl<W> WriteExt for W
where
    W: Write 
{ }