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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use super::core::DataEncoder;
use crate::impl_encodable;
use crate::utils::ParseResult;

impl DataEncoder {
    /// Adds a string value to the encoder.
    ///
    /// This method converts the input into a `String`, writes its length (`u32`),
    /// then writes the raw bytes.
    ///
    /// # Example
    /// ```rust
    /// encoder.add_string("hello")?;
    /// ```
    ///
    /// This is equivalent to calling `String::encode_data(...)` directly.
    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)
    }

    /// Adds a single boolean value to the encoder.
    ///
    /// Encoded as a single byte: `0x01` for `true`, `0x00` for `false`.
    pub fn add_bool(&mut self, data: bool) -> ParseResult<()> {
        self.add_item(vec![data as u8])
    }
}

/// A trait for types that can be serialized using a [`DataEncoder`].
///
/// Types implementing `Encodable` define how to write their binary representation
/// into an output encoder. This is the core trait used by the framework's derive macros
/// and container support.
///
/// # Example
/// ```rust
/// struct MyData {
///     id: u32,
///     flag: bool,
/// }
///
/// impl Encodable for MyData {
///     fn encode_data(&self, encoder: &mut DataEncoder) -> ParseResult<()> {
///         encoder.add_item(self.id)?;
///         encoder.add_bool(self.flag)
///     }
/// }
/// ```
///
/// [`DataEncoder`]: crate::encoder::core::DataEncoder
pub trait Encodable {
    fn encode_data(&self, encoder: &mut DataEncoder) -> ParseResult<()>;
}

/// Implements `Encodable` for `Option<T>` by writing a boolean flag followed by the value (if present).
///
/// Format:
/// - `0x01` followed by encoded `T` if `Some`
/// - `0x00` if `None`
impl<T: Encodable> Encodable for Option<T> {
    fn encode_data(&self, writer: &mut DataEncoder) -> ParseResult<()> {
        match self {
            Some(value) => {
                writer.add_bool(true)?;
                value.encode_data(writer)
            }
            None => {
                writer.add_bool(false)?;
                Ok(())
            }
        }
    }
}

/// Implements `Encodable` for `Vec<T>` by prefixing the length (as `u32`), and encoding each element.
///
/// Format:
/// - `[length: u32][item1][item2]...[itemN]`
///
/// Note: Internally uses `add_slice`.
impl<T: Encodable> Encodable for Vec<T> {
    fn encode_data(&self, encoder: &mut DataEncoder) -> ParseResult<()> {
        encoder.add_slice(self)
    }
}

/// Implements `Encodable` for arrays `[T; N]` by encoding each element sequentially.
///
/// Does **not** include a length prefix; assumes caller knows the array size.
///
/// Format:
/// - `[item1][item2]...[itemN]`
impl<T: Encodable, const N: usize> Encodable for [T; N] {
    fn encode_data(&self, encoder: &mut DataEncoder) -> ParseResult<()> {
        for item in self {
            item.encode_data(encoder)?;
        }
        Ok(())
    }
}

impl Encodable for String {
    fn encode_data(&self, encoder: &mut DataEncoder) -> ParseResult<()> {
        encoder.add_u32(self.len() as u32)?;
        encoder.add_item(self.as_bytes())
    }
}

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