dataparser_core 0.1.0

A flexible and efficient binary parsing and serialization library for Rust
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

use std::io::Write;

use crate::{encoder::core::DataEncoder, impl_write_encodable, utils::ParseResult};

use super::core::DataWriter;

pub trait WriteEncodable {
    fn to_writer<W: Write>(&self, encoder: &mut DataWriter<W>) -> ParseResult<()>;
}

impl<T: WriteEncodable> WriteEncodable for Option<T> {
    fn to_writer<W: Write>(&self, encoder: &mut DataWriter<W>) -> ParseResult<()> {
        match self {
            Some(value) => {
                encoder.add_bool(true)?;
                value.to_writer(encoder)
            }
            None => {
                encoder.add_bool(false)?;
                Ok(())
            }
        }
    }
}

impl<T: WriteEncodable> WriteEncodable for Vec<T> {
    fn to_writer<W: Write>(&self, encoder: &mut DataWriter<W>) -> ParseResult<()> {
        encoder.add_u32(self.len() as u32)?;
        for item in self {
            let mut temp_encoder = DataEncoder::default();
            temp_encoder.set_options(&encoder.options);
            item.to_writer(&mut DataWriter::new(Vec::new()))?;
            let item_data = temp_encoder.get_data()?;
            encoder.add_u32(item_data.len() as u32)?;
            encoder.add_item(item_data)?;
        }
        Ok(())
    }
}

impl<T: WriteEncodable, const N: usize> WriteEncodable for [T; N] {
    fn to_writer<W: Write>(&self, encoder: &mut DataWriter<W>) -> ParseResult<()> {
        for item in self {
            item.to_writer(encoder)?;
        }
        Ok(())
    }
}

impl WriteEncodable for String {
    fn to_writer<W: Write>(&self, encoder: &mut DataWriter<W>) -> ParseResult<()> {
        encoder.add_u32(self.len() as u32)?;
        encoder.add_item(self.as_bytes())
    }
}

impl<W: Write> DataWriter<W> {
    pub fn add_string(&mut self, data: impl Into<String>) -> ParseResult<()> {
        let data: String = data.into();
        self.add_u32(data.len() as u32)?;
        self.add_item(data)
    }

    pub fn add_bool(&mut self, data: bool) -> ParseResult<()> {
        self.add_item(vec![data as u8])
    }
}

impl_write_encodable!(u8, u16, u32, u64, usize, i8, i16, i32, i64, isize, f32, f64);