14477221649

Committed 15 Apr 2025 06:54PM UTC coverage: 39.362% (+9.8%) from 29.588%

Build # 14477221649

Build Type

Pull #240

github

Committed by

fasterthanlime

Commit Message

AH yes, the wrong path

Pull Request Pull Request #240: Blacksmith cache

Run Details

3987 of 10129 relevant lines covered (39.36%)

41.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

59.02

/facet-msgpack/src/to_msgpack.rs

use facet_core::{Def, Facet};

use facet_reflect::Peek;
use log::trace;
use std::io::{self, Write};

/// Serializes any Facet type to MessagePack bytes
pub fn to_vec<T: Facet>(value: &T) -> Vec<u8> {
    let mut buffer = Vec::new();
    let peek = Peek::new(value);
    serialize(peek, &mut buffer).unwrap();
    buffer
}

/// Serializes any Facet type to a writer in MessagePack format
fn serialize<W: Write>(pv: Peek<'_>, writer: &mut W) -> io::Result<()> {
    let shape = pv.shape();
    match shape.def {
        Def::Scalar(_) => {
            trace!("Serializing scalar");
            if pv.shape().is_type::<String>() {
                let value = pv.get::<String>().unwrap();
                write_str(writer, value)
            } else if pv.shape().is_type::<u64>() {
                let value = pv.get::<u64>().unwrap();
                write_u64(writer, *value)
            } else if pv.shape().is_type::<u32>() {
                let value = pv.get::<u32>().unwrap();
                write_u32(writer, *value)
            } else if pv.shape().is_type::<u16>() {
                let value = pv.get::<u16>().unwrap();
                write_u16(writer, *value)
            } else if pv.shape().is_type::<u8>() {
                let value = pv.get::<u8>().unwrap();
                write_u8(writer, *value)
            } else if pv.shape().is_type::<i64>() {
                let value = pv.get::<i64>().unwrap();
                write_i64(writer, *value)
            } else if pv.shape().is_type::<i32>() {
                let value = pv.get::<i32>().unwrap();
                write_i32(writer, *value)
            } else if pv.shape().is_type::<i16>() {
                let value = pv.get::<i16>().unwrap();
                write_i16(writer, *value)
            } else if pv.shape().is_type::<i8>() {
                let value = pv
                    .get::<i8>()
                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
                write_i8(writer, *value)
            } else {
                return Err(io::Error::new(
                    io::ErrorKind::Other,
                    format!("Unsupported scalar type: {}", pv.shape()),
                ));
            }
        }
        Def::Struct(sd) => {
            trace!("Serializing struct");
            let ps = pv
                .into_struct()
                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;

            // Write map header
            let fields = sd.fields;
            write_map_len(writer, fields.len())?;

            // Write fields
            for (field, field_peek) in ps.fields() {
                write_str(writer, field.name)?;
                serialize(field_peek, writer)?;
            }
            Ok(())
        }
        _ => Err(io::Error::new(
            io::ErrorKind::Other,
            format!("Unsupported type: {:?}", pv.shape()),
        )),
    }
}

fn write_str<W: Write>(writer: &mut W, s: &str) -> io::Result<()> {
    let bytes = s.as_bytes();
    let len = bytes.len();

    match len {
        0..=31 => {
            // fixstr
            writer.write_all(&[(0xa0 | len as u8)])?;
        }
        32..=255 => {
            // str8
            writer.write_all(&[0xd9, len as u8])?;
        }
        256..=65535 => {
            // str16
            writer.write_all(&[0xda])?;
            writer.write_all(&(len as u16).to_be_bytes())?;
        }
        _ => {
            // str32
            writer.write_all(&[0xdb])?;
            writer.write_all(&(len as u32).to_be_bytes())?;
        }
    }
    writer.write_all(bytes)
}

fn write_u8<W: Write>(writer: &mut W, n: u8) -> io::Result<()> {
    match n {
        0..=127 => {
            // positive fixint
            writer.write_all(&[n])
        }
        _ => {
            // uint8
            writer.write_all(&[0xcc, n])
        }
    }
}

fn write_u16<W: Write>(writer: &mut W, n: u16) -> io::Result<()> {
    match n {
        0..=127 => {
            // positive fixint
            writer.write_all(&[n as u8])
        }
        128..=255 => {
            // uint8
            writer.write_all(&[0xcc, n as u8])
        }
        _ => {
            // uint16
            writer.write_all(&[0xcd])?;
            writer.write_all(&n.to_be_bytes())
        }
    }
}

fn write_u32<W: Write>(writer: &mut W, n: u32) -> io::Result<()> {
    match n {
        0..=127 => {
            // positive fixint
            writer.write_all(&[n as u8])
        }
        128..=255 => {
            // uint8
            writer.write_all(&[0xcc, n as u8])
        }
        256..=65535 => {
            // uint16
            writer.write_all(&[0xcd])?;
            writer.write_all(&(n as u16).to_be_bytes())
        }
        _ => {
            // uint32
            writer.write_all(&[0xce])?;
            writer.write_all(&n.to_be_bytes())
        }
    }
}

fn write_u64<W: Write>(writer: &mut W, n: u64) -> io::Result<()> {
    match n {
        0..=127 => {
            // positive fixint
            writer.write_all(&[n as u8])
        }
        128..=255 => {
            // uint8
            writer.write_all(&[0xcc, n as u8])
        }
        256..=65535 => {
            // uint16
            writer.write_all(&[0xcd])?;
            writer.write_all(&(n as u16).to_be_bytes())
        }
        65536..=4294967295 => {
            // uint32
            writer.write_all(&[0xce])?;
            writer.write_all(&(n as u32).to_be_bytes())
        }
        _ => {
            // uint64
            writer.write_all(&[0xcf])?;
            writer.write_all(&n.to_be_bytes())
        }
    }
}

fn write_i8<W: Write>(writer: &mut W, n: i8) -> io::Result<()> {
    match n {
        -32..=-1 => {
            // negative fixint
            writer.write_all(&[n as u8])
        }
        -128..=-33 => {
            // int8
            writer.write_all(&[0xd0, n as u8])
        }
        0..=127 => {
            // positive fixint
            writer.write_all(&[n as u8])
        }
    }
}

fn write_i16<W: Write>(writer: &mut W, n: i16) -> io::Result<()> {
    match n {
        -32..=-1 => {
            // negative fixint
            writer.write_all(&[n as u8])
        }
        -128..=-33 => {
            // int8
            writer.write_all(&[0xd0, n as u8])
        }
        -32768..=-129 => {
            // int16
            writer.write_all(&[0xd1])?;
            writer.write_all(&n.to_be_bytes())
        }
        0..=127 => {
            // positive fixint
            writer.write_all(&[n as u8])
        }
        128..=255 => {
            // uint8
            writer.write_all(&[0xcc, n as u8])
        }
        256..=32767 => {
            // uint16
            writer.write_all(&[0xcd])?;
            writer.write_all(&(n as u16).to_be_bytes())
        }
    }
}

fn write_i32<W: Write>(writer: &mut W, n: i32) -> io::Result<()> {
    match n {
        -32..=-1 => {
            // negative fixint
            writer.write_all(&[n as u8])
        }
        -128..=-33 => {
            // int8
            writer.write_all(&[0xd0, n as u8])
        }
        -32768..=-129 => {
            // int16
            writer.write_all(&[0xd1])?;
            writer.write_all(&(n as i16).to_be_bytes())
        }
        -2147483648..=-32769 => {
            // int32
            writer.write_all(&[0xd2])?;
            writer.write_all(&n.to_be_bytes())
        }
        0..=127 => {
            // positive fixint
            writer.write_all(&[n as u8])
        }
        128..=255 => {
            // uint8
            writer.write_all(&[0xcc, n as u8])
        }
        256..=65535 => {
            // uint16
            writer.write_all(&[0xcd])?;
            writer.write_all(&(n as u16).to_be_bytes())
        }
        65536..=2147483647 => {
            // uint32
            writer.write_all(&[0xce])?;
            writer.write_all(&(n as u32).to_be_bytes())
        }
    }
}

fn write_i64<W: Write>(writer: &mut W, n: i64) -> io::Result<()> {
    match n {
        -32..=-1 => {
            // negative fixint
            writer.write_all(&[n as u8])
        }
        -128..=-33 => {
            // int8
            writer.write_all(&[0xd0, n as u8])
        }
        -32768..=-129 => {
            // int16
            writer.write_all(&[0xd1])?;
            writer.write_all(&(n as i16).to_be_bytes())
        }
        -2147483648..=-32769 => {
            // int32
            writer.write_all(&[0xd2])?;
            writer.write_all(&(n as i32).to_be_bytes())
        }
        i64::MIN..=-2147483649 => {
            // int64
            writer.write_all(&[0xd3])?;
            writer.write_all(&n.to_be_bytes())
        }
        0..=127 => {
            // positive fixint
            writer.write_all(&[n as u8])
        }
        128..=255 => {
            // uint8
            writer.write_all(&[0xcc, n as u8])
        }
        256..=65535 => {
            // uint16
            writer.write_all(&[0xcd])?;
            writer.write_all(&(n as u16).to_be_bytes())
        }
        65536..=4294967295 => {
            // uint32
            writer.write_all(&[0xce])?;
            writer.write_all(&(n as u32).to_be_bytes())
        }
        4294967296..=i64::MAX => {
            // uint64
            writer.write_all(&[0xcf])?;
            writer.write_all(&(n as u64).to_be_bytes())
        }
    }
}

fn write_map_len<W: Write>(writer: &mut W, len: usize) -> io::Result<()> {
    match len {
        0..=15 => {
            // fixmap
            writer.write_all(&[(0x80 | len as u8)])
        }
        16..=65535 => {
            // map16
            writer.write_all(&[0xde])?;
            writer.write_all(&(len as u16).to_be_bytes())
        }
        _ => {
            // map32
            writer.write_all(&[0xdf])?;
            writer.write_all(&(len as u32).to_be_bytes())
        }
    }
}

1	use facet_core::{Def, Facet};
2
3	use facet_reflect::Peek;
4	use log::trace;
5	use std::io::{self, Write};
6
7	/// Serializes any Facet type to MessagePack bytes
8	pub fn to_vec<T: Facet>(value: &T) -> Vec<u8> {	2✔
9	let mut buffer = Vec::new();	2✔
10	let peek = Peek::new(value);	2✔
11	serialize(peek, &mut buffer).unwrap();	2✔
12	buffer	2✔
13	}	2✔
14
15	/// Serializes any Facet type to a writer in MessagePack format
16	fn serialize<W: Write>(pv: Peek<'_>, writer: &mut W) -> io::Result<()> {	14✔
17	let shape = pv.shape();	14✔
18	match shape.def {	14✔
19	Def::Scalar(_) => {
20	trace!("Serializing scalar");	12✔
21	if pv.shape().is_type::<String>() {	12✔
22	let value = pv.get::<String>().unwrap();	1✔
23	write_str(writer, value)	1✔
24	} else if pv.shape().is_type::<u64>() {	11✔
25	let value = pv.get::<u64>().unwrap();	2✔
26	write_u64(writer, *value)	2✔
27	} else if pv.shape().is_type::<u32>() {	9✔
28	let value = pv.get::<u32>().unwrap();	1✔
29	write_u32(writer, *value)	1✔
30	} else if pv.shape().is_type::<u16>() {	8✔
31	let value = pv.get::<u16>().unwrap();	1✔
32	write_u16(writer, *value)	1✔
33	} else if pv.shape().is_type::<u8>() {	7✔
34	let value = pv.get::<u8>().unwrap();	2✔
35	write_u8(writer, *value)	2✔
36	} else if pv.shape().is_type::<i64>() {	5✔
37	let value = pv.get::<i64>().unwrap();	1✔
38	write_i64(writer, *value)	1✔
39	} else if pv.shape().is_type::<i32>() {	4✔
40	let value = pv.get::<i32>().unwrap();	1✔
41	write_i32(writer, *value)	1✔
42	} else if pv.shape().is_type::<i16>() {	3✔
43	let value = pv.get::<i16>().unwrap();	1✔
44	write_i16(writer, *value)	1✔
45	} else if pv.shape().is_type::<i8>() {	2✔
46	let value = pv	2✔
47	.get::<i8>()	2✔
48	.map_err(\|e\| io::Error::new(io::ErrorKind::Other, e))?;	2✔
49	write_i8(writer, *value)	2✔
50	} else {
51	return Err(io::Error::new(	×
52	io::ErrorKind::Other,	×
53	format!("Unsupported scalar type: {}", pv.shape()),	×
54	));	×
55	}
56	}
57	Def::Struct(sd) => {	2✔
58	trace!("Serializing struct");	2✔
59	let ps = pv	2✔
60	.into_struct()	2✔
61	.map_err(\|e\| io::Error::new(io::ErrorKind::Other, e))?;	2✔
62
63	// Write map header
64	let fields = sd.fields;	2✔
65	write_map_len(writer, fields.len())?;	2✔
66
67	// Write fields
68	for (field, field_peek) in ps.fields() {	12✔
69	write_str(writer, field.name)?;	12✔
70	serialize(field_peek, writer)?;	12✔
71	}
72	Ok(())	2✔
73	}
74	_ => Err(io::Error::new(	×
75	io::ErrorKind::Other,	×
76	format!("Unsupported type: {:?}", pv.shape()),	×
77	)),	×
78	}
79	}	14✔
80
81	fn write_str<W: Write>(writer: &mut W, s: &str) -> io::Result<()> {	13✔
82	let bytes = s.as_bytes();	13✔
83	let len = bytes.len();	13✔
84		13✔
85	match len {	13✔
86	0..=31 => {	13✔
87	// fixstr
88	writer.write_all(&[(0xa0 \| len as u8)])?;	13✔
89	}
90	32..=255 => {	×
91	// str8
92	writer.write_all(&[0xd9, len as u8])?;	×
93	}
94	256..=65535 => {	×
95	// str16
96	writer.write_all(&[0xda])?;	×
97	writer.write_all(&(len as u16).to_be_bytes())?;	×
98	}
99	_ => {
100	// str32
101	writer.write_all(&[0xdb])?;	×
102	writer.write_all(&(len as u32).to_be_bytes())?;	×
103	}
104	}
105	writer.write_all(bytes)	13✔
106	}	13✔
107
108	fn write_u8<W: Write>(writer: &mut W, n: u8) -> io::Result<()> {	2✔
109	match n {	2✔
110	0..=127 => {	2✔
111	// positive fixint
112	writer.write_all(&[n])	1✔
113	}
114	_ => {
115	// uint8
116	writer.write_all(&[0xcc, n])	1✔
117	}
118	}
119	}	2✔
120
121	fn write_u16<W: Write>(writer: &mut W, n: u16) -> io::Result<()> {	1✔
122	match n {	1✔
123	0..=127 => {	1✔
124	// positive fixint
125	writer.write_all(&[n as u8])	×
126	}
127	128..=255 => {	1✔
128	// uint8
129	writer.write_all(&[0xcc, n as u8])	×
130	}
131	_ => {
132	// uint16
133	writer.write_all(&[0xcd])?;	1✔
134	writer.write_all(&n.to_be_bytes())	1✔
135	}
136	}
137	}	1✔
138
139	fn write_u32<W: Write>(writer: &mut W, n: u32) -> io::Result<()> {	1✔
140	match n {	1✔
141	0..=127 => {	1✔
142	// positive fixint
143	writer.write_all(&[n as u8])	×
144	}
145	128..=255 => {	1✔
146	// uint8
147	writer.write_all(&[0xcc, n as u8])	×
148	}
149	256..=65535 => {	1✔
150	// uint16
151	writer.write_all(&[0xcd])?;	×
152	writer.write_all(&(n as u16).to_be_bytes())	×
153	}
154	_ => {
155	// uint32
156	writer.write_all(&[0xce])?;	1✔
157	writer.write_all(&n.to_be_bytes())	1✔
158	}
159	}
160	}	1✔
161
162	fn write_u64<W: Write>(writer: &mut W, n: u64) -> io::Result<()> {	2✔
163	match n {	2✔
164	0..=127 => {	2✔
165	// positive fixint
166	writer.write_all(&[n as u8])	1✔
167	}
168	128..=255 => {	1✔
169	// uint8
170	writer.write_all(&[0xcc, n as u8])	×
171	}
172	256..=65535 => {	1✔
173	// uint16
174	writer.write_all(&[0xcd])?;	×
175	writer.write_all(&(n as u16).to_be_bytes())	×
176	}
177	65536..=4294967295 => {	1✔
178	// uint32
179	writer.write_all(&[0xce])?;	×
180	writer.write_all(&(n as u32).to_be_bytes())	×
181	}
182	_ => {
183	// uint64
184	writer.write_all(&[0xcf])?;	1✔
185	writer.write_all(&n.to_be_bytes())	1✔
186	}
187	}
188	}	2✔
189
190	fn write_i8<W: Write>(writer: &mut W, n: i8) -> io::Result<()> {	2✔
191	match n {	2✔
192	-32..=-1 => {	1✔
193	// negative fixint
194	writer.write_all(&[n as u8])	1✔
195	}
196	-128..=-33 => {	1✔
197	// int8
198	writer.write_all(&[0xd0, n as u8])	1✔
199	}
200	0..=127 => {	×
201	// positive fixint
202	writer.write_all(&[n as u8])	×
203	}
204	}
205	}	2✔
206
207	fn write_i16<W: Write>(writer: &mut W, n: i16) -> io::Result<()> {	1✔
208	match n {	1✔
209	-32..=-1 => {	×
210	// negative fixint
211	writer.write_all(&[n as u8])	×
212	}
213	-128..=-33 => {	×
214	// int8
215	writer.write_all(&[0xd0, n as u8])	×
216	}
217	-32768..=-129 => {	1✔
218	// int16
219	writer.write_all(&[0xd1])?;	1✔
220	writer.write_all(&n.to_be_bytes())	1✔
221	}
222	0..=127 => {	×
223	// positive fixint
224	writer.write_all(&[n as u8])	×
225	}
226	128..=255 => {	×
227	// uint8
228	writer.write_all(&[0xcc, n as u8])	×
229	}
230	256..=32767 => {	×
231	// uint16
232	writer.write_all(&[0xcd])?;	×
233	writer.write_all(&(n as u16).to_be_bytes())	×
234	}
235	}
236	}	1✔
237
238	fn write_i32<W: Write>(writer: &mut W, n: i32) -> io::Result<()> {	1✔
239	match n {	1✔
240	-32..=-1 => {	×
241	// negative fixint
242	writer.write_all(&[n as u8])	×
243	}
244	-128..=-33 => {	×
245	// int8
246	writer.write_all(&[0xd0, n as u8])	×
247	}
248	-32768..=-129 => {	×
249	// int16
250	writer.write_all(&[0xd1])?;	×
251	writer.write_all(&(n as i16).to_be_bytes())	×
252	}
253	-2147483648..=-32769 => {	1✔
254	// int32
255	writer.write_all(&[0xd2])?;	1✔
256	writer.write_all(&n.to_be_bytes())	1✔
257	}
258	0..=127 => {	×
259	// positive fixint
260	writer.write_all(&[n as u8])	×
261	}
262	128..=255 => {	×
263	// uint8
264	writer.write_all(&[0xcc, n as u8])	×
265	}
266	256..=65535 => {	×
267	// uint16
268	writer.write_all(&[0xcd])?;	×
269	writer.write_all(&(n as u16).to_be_bytes())	×
270	}
271	65536..=2147483647 => {	×
272	// uint32
273	writer.write_all(&[0xce])?;	×
274	writer.write_all(&(n as u32).to_be_bytes())	×
275	}
276	}
277	}	1✔
278
279	fn write_i64<W: Write>(writer: &mut W, n: i64) -> io::Result<()> {	1✔
280	match n {	1✔
281	-32..=-1 => {	×
282	// negative fixint
283	writer.write_all(&[n as u8])	×
284	}
285	-128..=-33 => {	×
286	// int8
287	writer.write_all(&[0xd0, n as u8])	×
288	}
289	-32768..=-129 => {	×
290	// int16
291	writer.write_all(&[0xd1])?;	×
292	writer.write_all(&(n as i16).to_be_bytes())	×
293	}
294	-2147483648..=-32769 => {	×
295	// int32
296	writer.write_all(&[0xd2])?;	×
297	writer.write_all(&(n as i32).to_be_bytes())	×
298	}
299	i64::MIN..=-2147483649 => {	1✔
300	// int64
301	writer.write_all(&[0xd3])?;	1✔
302	writer.write_all(&n.to_be_bytes())	1✔
303	}
304	0..=127 => {	×
305	// positive fixint
306	writer.write_all(&[n as u8])	×
307	}
308	128..=255 => {	×
309	// uint8
310	writer.write_all(&[0xcc, n as u8])	×
311	}
312	256..=65535 => {	×
313	// uint16
314	writer.write_all(&[0xcd])?;	×
315	writer.write_all(&(n as u16).to_be_bytes())	×
316	}
317	65536..=4294967295 => {	×
318	// uint32
319	writer.write_all(&[0xce])?;	×
320	writer.write_all(&(n as u32).to_be_bytes())	×
321	}
322	4294967296..=i64::MAX => {	×
323	// uint64
324	writer.write_all(&[0xcf])?;	×
325	writer.write_all(&(n as u64).to_be_bytes())	×
326	}
327	}
328	}	1✔
329
330	fn write_map_len<W: Write>(writer: &mut W, len: usize) -> io::Result<()> {	2✔
331	match len {	2✔
332	0..=15 => {	2✔
333	// fixmap
334	writer.write_all(&[(0x80 \| len as u8)])	2✔
335	}
336	16..=65535 => {	×
337	// map16
338	writer.write_all(&[0xde])?;	×
339	writer.write_all(&(len as u16).to_be_bytes())	×
340	}
341	_ => {
342	// map32
343	writer.write_all(&[0xdf])?;	×
344	writer.write_all(&(len as u32).to_be_bytes())	×
345	}
346	}
347	}	2✔

facet-rs / facet / 14477221649

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous