oxicode 0.2.1

A modern binary serialization library - successor to bincode
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Encoding functionality

use crate::error::Result;

#[cfg(feature = "alloc")]
use alloc::vec::Vec;

/// Writer trait for encoding values
pub trait Writer {
    /// Write bytes to the writer
    ///
    /// This should write all bytes or return an error
    fn write(&mut self, bytes: &[u8]) -> Result<()>;
}

/// Writer implementation that writes to a Vec<u8>
#[cfg(feature = "alloc")]
pub struct VecWriter {
    buffer: Vec<u8>,
}

#[cfg(feature = "alloc")]
impl VecWriter {
    /// Create a new VecWriter
    pub fn new() -> Self {
        Self {
            buffer: Vec::new(),
        }
    }

    /// Create a new VecWriter with the given capacity
    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            buffer: Vec::with_capacity(capacity),
        }
    }

    /// Get the inner Vec<u8>
    pub fn into_vec(self) -> Vec<u8> {
        self.buffer
    }

    /// Get a reference to the inner buffer
    pub fn as_slice(&self) -> &[u8] {
        &self.buffer
    }
}

#[cfg(feature = "alloc")]
impl Default for VecWriter {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(feature = "alloc")]
impl Writer for VecWriter {
    fn write(&mut self, bytes: &[u8]) -> Result<()> {
        self.buffer.extend_from_slice(bytes);
        Ok(())
    }
}

/// Writer implementation that writes to a byte slice
pub struct SliceWriter<'a> {
    slice: &'a mut [u8],
    index: usize,
}

impl<'a> SliceWriter<'a> {
    /// Create a new SliceWriter
    pub fn new(slice: &'a mut [u8]) -> Self {
        Self { slice, index: 0 }
    }

    /// Get the number of bytes written
    pub fn bytes_written(&self) -> usize {
        self.index
    }
}

impl<'a> Writer for SliceWriter<'a> {
    fn write(&mut self, bytes: &[u8]) -> Result<()> {
        let len = bytes.len();
        if self.index + len > self.slice.len() {
            return Err(crate::error::Error::UnexpectedEnd { additional: len });
        }
        self.slice[self.index..self.index + len].copy_from_slice(bytes);
        self.index += len;
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    #[cfg(feature = "alloc")]
    fn test_vec_writer() {
        let mut writer = VecWriter::new();
        writer.write(&[0x42]).expect("Failed to write");
        assert_eq!(writer.as_slice(), &[0x42]);

        writer.write(&[0x43, 0x44]).expect("Failed to write");
        assert_eq!(writer.as_slice(), &[0x42, 0x43, 0x44]);
    }

    #[test]
    fn test_slice_writer() {
        let mut buffer = [0u8; 10];
        {
            let mut writer = SliceWriter::new(&mut buffer);

            writer.write(&[0x42]).expect("Failed to write");
            assert_eq!(writer.bytes_written(), 1);

            writer.write(&[0x43, 0x44]).expect("Failed to write");
            assert_eq!(writer.bytes_written(), 3);

            // Fill the rest
            writer
                .write(&[0xFF; 7])
                .expect("Failed to write remaining");
            assert_eq!(writer.bytes_written(), 10);

            // Should fail - buffer full
            assert!(writer.write(&[0x00]).is_err());
        }

        // Check the buffer after writer is dropped
        assert_eq!(buffer[0], 0x42);
        assert_eq!(&buffer[..3], &[0x42, 0x43, 0x44]);
    }
}