encode 1.0.0

A simple framework for encoding binary data.
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

use core::fmt::Error;
use core::fmt::Formatter;

use crate::BaseEncoder;
use crate::StrEncoder;

impl BaseEncoder for Formatter<'_> {
    type Error = Error;
}

impl StrEncoder for Formatter<'_> {
    #[inline]
    fn put_str(&mut self, string: &str) -> Result<(), Self::Error> {
        self.write_str(string)
    }
}

#[cfg(all(test, feature = "alloc"))]
mod tests {
    use super::*;
    use crate::Encodable;
    use alloc::string::String;
    use core::fmt::Write;

    #[test]
    fn assert_that_formatter_can_be_used_as_an_encoder() {
        struct MyEncodable;

        impl<E> Encodable<E> for MyEncodable
        where
            E: StrEncoder,
        {
            type Error = E::Error;
            fn encode(&self, encoder: &mut E) -> Result<(), Self::Error> {
                "Hello world".encode(encoder)
            }
        }

        impl core::fmt::Display for MyEncodable {
            fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), core::fmt::Error> {
                self.encode(f)
            }
        }
        let mut output = String::new();
        writeln!(&mut output, "{}", MyEncodable).expect("Failed to write to output");

        assert_eq!(output, "Hello world\n");
    }
}