fef 0.2.3

Rust implementation of a parser of the FEF format
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

use crate::common::traits::private::Sealed;
use crate::v0::config::Config;
use crate::v0::raw;
use crate::v0::traits::{ReadFrom, WriteTo};
use std::io::{Read, Write};
use std::string::String;

use super::error::{StringReadError, StringWriteError};

impl Sealed for String {}

impl<R> ReadFrom<R> for String
where
    R: Read + ?Sized,
{
    type ReadError = StringReadError;

    /// Reads a string from the given byte stream according to the given configuration.
    ///
    /// # Example
    /// ```rust
    /// # use std::io::Read;
    /// # use fef::v0::traits::ReadFrom;
    /// # use fef::v0::config::OverridableConfig;
    /// # use std::string::String;
    /// # fn main() -> Result<(), fef::v0::raw::error::StringReadError> {
    /// let file = vec![0x05, 0x48, 0x65, 0x6C, 0x6C, 0x6F];
    /// let mut file_reader = file.as_slice();
    ///
    /// let configuration = OverridableConfig::default();
    ///
    /// let string = String::read_from(&mut file_reader, &configuration)?;
    /// assert_eq!(string, "Hello");
    ///
    /// # Ok(())
    /// # }
    ///```
    fn read_from<C: ?Sized + Config>(
        reader: &mut R,
        configuration: &C,
    ) -> Result<Self, Self::ReadError> {
        let length: usize = raw::VariableLengthEnum::read_from(&mut *reader, &*configuration)?
            .try_into()
            .map_err(|_| StringReadError::LengthTooLarge)?;

        let mut buffer: Vec<u8> = Vec::with_capacity(length);
        reader.take(length as u64).read_to_end(&mut buffer)?;

        let parsed_utf8: String = String::from_utf8(buffer)?;

        Ok(parsed_utf8)
    }
}

impl<W> WriteTo<W> for String
where
    W: Write + ?Sized,
{
    type WriteError = StringWriteError;
    fn write_to<C: ?Sized + Config>(
        &self,
        writer: &mut W,
        configuration: &C,
    ) -> Result<(), Self::WriteError> {
        let bytes = self.as_bytes();
        let length = bytes.len();
        let variable_length_enum = raw::VariableLengthEnum::from(length);
        variable_length_enum.write_to(writer, configuration)?;
        writer.write_all(bytes)?;
        Ok(())
    }
}