aldrin_core/impls/
bytes.rs

1#[cfg(feature = "introspection")]
2use crate::introspection::{ir, Introspectable, LexicalId, References};
3use crate::tags::{self, PrimaryTag};
4use crate::{Deserialize, DeserializeError, Deserializer, Serialize, SerializeError, Serializer};
5use std::collections::{LinkedList, VecDeque};
6use std::mem::{self, MaybeUninit};
7
8impl Serialize<tags::Bytes> for Vec<u8> {
9    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
10        serializer.serialize_byte_slice2(&self)
11    }
12}
13
14impl Serialize<tags::Bytes> for &Vec<u8> {
15    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
16        serializer.serialize_byte_slice2(self)
17    }
18}
19
20impl Deserialize<tags::Bytes> for Vec<u8> {
21    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
22        deserializer.deserialize_bytes_extend_new()
23    }
24}
25
26impl Serialize<tags::Bytes> for &[u8] {
27    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
28        serializer.serialize_byte_slice2(self)
29    }
30}
31
32impl<const N: usize> Serialize<tags::Bytes> for [u8; N] {
33    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
34        serializer.serialize_byte_slice2(&self)
35    }
36}
37
38impl<const N: usize> Serialize<tags::Bytes> for &[u8; N] {
39    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
40        serializer.serialize_byte_slice2(self)
41    }
42}
43
44impl<const N: usize> Deserialize<tags::Bytes> for [u8; N] {
45    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
46        let mut deserializer = deserializer.deserialize_bytes()?;
47
48        // SAFETY: This creates an array of MaybeUninit<U>, which doesn't require initialization.
49        let mut arr: [MaybeUninit<u8>; N] = unsafe { MaybeUninit::uninit().assume_init() };
50        let mut done = 0;
51
52        loop {
53            let slice = deserializer.as_slice()?;
54            let len = slice.len();
55
56            if len == 0 {
57                if done == N {
58                    // SAFETY: Exactly done elements have been initialized and done equals N.
59                    //
60                    // It's currently impossible to transmute [MaybeUninit<u8>; N] to [u8; N] when N
61                    // is a const generic. See https://github.com/rust-lang/rust/issues/61956.
62                    let value = unsafe {
63                        (*(&MaybeUninit::new(arr) as *const _ as *const MaybeUninit<[u8; N]>))
64                            .assume_init_read()
65                    };
66
67                    break deserializer.finish(value);
68                } else {
69                    break Err(DeserializeError::InvalidSerialization);
70                }
71            }
72
73            if done + len <= N {
74                // SAFETY: &[u8] and &[MaybeUninit<u8>] have the same layout
75                let slice: &[MaybeUninit<u8>] = unsafe { mem::transmute(slice) };
76
77                arr[done..(done + len)].copy_from_slice(slice);
78
79                done += len;
80                deserializer.advance(len)?;
81            } else {
82                break Err(DeserializeError::InvalidSerialization);
83            }
84        }
85    }
86}
87
88impl Serialize<tags::Bytes> for VecDeque<u8> {
89    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
90        serializer.serialize::<tags::Bytes>(&self)
91    }
92}
93
94impl Serialize<tags::Bytes> for &VecDeque<u8> {
95    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
96        let mut serializer = serializer.serialize_bytes2()?;
97
98        let (a, b) = self.as_slices();
99        serializer.serialize(a)?;
100        serializer.serialize(b)?;
101
102        serializer.finish()
103    }
104}
105
106impl Deserialize<tags::Bytes> for VecDeque<u8> {
107    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
108        deserializer.deserialize_bytes_extend_new()
109    }
110}
111
112impl Serialize<tags::Bytes> for LinkedList<u8> {
113    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
114        serializer.serialize::<tags::Bytes>(&self)
115    }
116}
117
118impl Serialize<tags::Bytes> for &LinkedList<u8> {
119    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
120        let mut serializer = serializer.serialize_bytes1(self.len())?;
121
122        for byte in self {
123            serializer.serialize(&[*byte])?;
124        }
125
126        serializer.finish()
127    }
128}
129
130impl Deserialize<tags::Bytes> for LinkedList<u8> {
131    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
132        deserializer.deserialize_bytes_extend_new()
133    }
134}
135
136impl PrimaryTag for bytes::Bytes {
137    type Tag = tags::Bytes;
138}
139
140impl Serialize<tags::Bytes> for bytes::Bytes {
141    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
142        serializer.serialize_byte_slice2(&self)
143    }
144}
145
146impl Serialize<tags::Bytes> for &bytes::Bytes {
147    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
148        serializer.serialize_byte_slice2(self)
149    }
150}
151
152impl Deserialize<tags::Bytes> for bytes::Bytes {
153    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
154        deserializer
155            .deserialize::<tags::Bytes, bytes::BytesMut>()
156            .map(bytes::BytesMut::freeze)
157    }
158}
159
160#[cfg(feature = "introspection")]
161impl Introspectable for bytes::Bytes {
162    fn layout() -> ir::LayoutIr {
163        ir::BuiltInTypeIr::Bytes.into()
164    }
165
166    fn lexical_id() -> LexicalId {
167        LexicalId::BYTES
168    }
169
170    fn add_references(_references: &mut References) {}
171}
172
173impl PrimaryTag for bytes::BytesMut {
174    type Tag = tags::Bytes;
175}
176
177impl Serialize<tags::Bytes> for bytes::BytesMut {
178    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
179        serializer.serialize_byte_slice2(&self)
180    }
181}
182
183impl Serialize<tags::Bytes> for &bytes::BytesMut {
184    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
185        serializer.serialize_byte_slice2(self)
186    }
187}
188
189impl Deserialize<tags::Bytes> for bytes::BytesMut {
190    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
191        let mut deserializer = deserializer.deserialize_bytes()?;
192        let mut bytes = Self::new();
193
194        loop {
195            let slice = deserializer.as_slice()?;
196
197            if slice.is_empty() {
198                break deserializer.finish(bytes);
199            } else {
200                bytes.extend_from_slice(slice);
201                deserializer.advance(slice.len())?;
202            }
203        }
204    }
205}
206
207#[cfg(feature = "introspection")]
208impl Introspectable for bytes::BytesMut {
209    fn layout() -> ir::LayoutIr {
210        ir::BuiltInTypeIr::Bytes.into()
211    }
212
213    fn lexical_id() -> LexicalId {
214        LexicalId::BYTES
215    }
216
217    fn add_references(_references: &mut References) {}
218}
219
220impl Serialize<tags::Bytes> for () {
221    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
222        serializer.serialize_bytes2()?.finish()
223    }
224}
225
226impl Serialize<tags::Bytes> for &() {
227    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
228        serializer.serialize_bytes2()?.finish()
229    }
230}
231
232impl Deserialize<tags::Bytes> for () {
233    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
234        deserializer.deserialize_bytes()?.finish(())
235    }
236}
aldrin_core/impls/bytes.rs

aldrin_core/impls/
bytes.rs
