15202915268

Committed 23 May 2025 05:19AM UTC coverage: 57.209% (+0.02%) from 57.185%

Build # 15202915268

Build Type

Pull #663

github

Committed by

web-flow

Commit Message

Merge 5f616f138 into 4b41e5c8a

Pull Request Pull Request #663: Add support for the `bytes` crate

Run Details

79 of 142 new or added lines in 5 files covered. (55.63%)

47 existing lines in 4 files now uncovered.

9547 of 16688 relevant lines covered (57.21%)

138.36 hits per line

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

32.0

/facet-core/src/impls_bytes.rs

use alloc::boxed::Box;

use bytes::{BufMut as _, Bytes, BytesMut};

use crate::{
    Def, Facet, IterVTable, ListDef, ListVTable, PtrConst, PtrMut, PtrUninit, Shape, Type,
    UserType, ValueVTable, value_vtable,
};

type BytesIterator<'mem> = core::slice::Iter<'mem, u8>;

unsafe impl Facet<'_> for Bytes {
    const VTABLE: &'static ValueVTable = &const {
        let mut vtable = value_vtable!(Bytes, |f, _opts| write!(f, "Bytes"));
        vtable.try_from = Some(
            |source: PtrConst, source_shape: &Shape, target: PtrUninit| {
                if source_shape.is_type::<BytesMut>() {
                    let source = unsafe { source.read::<BytesMut>() };
                    let bytes = source.freeze();
                    Ok(unsafe { target.put(bytes) })
                } else {
                    Err(crate::TryFromError::UnsupportedSourceShape {
                        src_shape: source_shape,
                        expected: &[Bytes::SHAPE],
                    })
                }
            },
        );

        vtable
    };

    const SHAPE: &'static Shape<'static> = &const {
        Shape::builder_for_sized::<Self>()
            .ty(Type::User(UserType::Opaque))
            .inner(|| BytesMut::SHAPE)
            .def(Def::List(
                ListDef::builder()
                    .vtable(
                        &const {
                            ListVTable::builder()
                                .len(|ptr| unsafe {
                                    let bytes = ptr.get::<Self>();
                                    bytes.len()
                                })
                                .get(|ptr, index| unsafe {
                                    let bytes = ptr.get::<Self>();
                                    let item = bytes.get(index)?;
                                    Some(PtrConst::new(item))
                                })
                                .as_ptr(|ptr| unsafe {
                                    let bytes = ptr.get::<Self>();
                                    PtrConst::new(bytes.as_ptr())
                                })
                                .iter_vtable(
                                    IterVTable::builder()
                                        .init_with_value(|ptr| unsafe {
                                            let bytes = ptr.get::<Self>();
                                            let iter: BytesIterator = bytes.iter();
                                            let iter_state = Box::new(iter);
                                            PtrMut::new(Box::into_raw(iter_state) as *mut u8)
                                        })
                                        .next(|iter_ptr| unsafe {
                                            let state = iter_ptr.as_mut::<BytesIterator<'_>>();
                                            state.next().map(|value| PtrConst::new(value))
                                        })
                                        .next_back(|iter_ptr| unsafe {
                                            let state = iter_ptr.as_mut::<BytesIterator<'_>>();
                                            state.next_back().map(|value| PtrConst::new(value))
                                        })
                                        .dealloc(|iter_ptr| unsafe {
                                            drop(Box::from_raw(
                                                iter_ptr.as_ptr::<BytesIterator<'_>>()
                                                    as *mut BytesIterator<'_>,
                                            ));
                                        })
                                        .build(),
                                )
                                .build()
                        },
                    )
                    .t(|| u8::SHAPE)
                    .build(),
            ))
            .build()
    };
}

unsafe impl Facet<'_> for BytesMut {
    const VTABLE: &'static ValueVTable =
        &const { value_vtable!(BytesMut, |f, _opts| write!(f, "BytesMut")) };

    const SHAPE: &'static Shape<'static> = &const {
        Shape::builder_for_sized::<Self>()
            .ty(Type::User(UserType::Opaque))
            .def(Def::List(
                ListDef::builder()
                    .vtable(
                        &const {
                            ListVTable::builder()
                                .init_in_place_with_capacity(|data, capacity| unsafe {
                                    data.put(Self::with_capacity(capacity))
                                })
                                .push(|ptr, item| unsafe {
                                    let bytes = ptr.as_mut::<Self>();
                                    let item = item.read::<u8>();
                                    (*bytes).put_u8(item);
                                })
                                .len(|ptr| unsafe {
                                    let bytes = ptr.get::<Self>();
                                    bytes.len()
                                })
                                .get(|ptr, index| unsafe {
                                    let bytes = ptr.get::<Self>();
                                    let item = bytes.get(index)?;
                                    Some(PtrConst::new(item))
                                })
                                .get_mut(|ptr, index| unsafe {
                                    let bytes = ptr.as_mut::<Self>();
                                    let item = bytes.get_mut(index)?;
                                    Some(PtrMut::new(item))
                                })
                                .as_ptr(|ptr| unsafe {
                                    let bytes = ptr.get::<Self>();
                                    PtrConst::new(bytes.as_ptr())
                                })
                                .as_mut_ptr(|ptr| unsafe {
                                    let bytes = ptr.as_mut::<Self>();
                                    PtrMut::new(bytes.as_mut_ptr())
                                })
                                .iter_vtable(
                                    IterVTable::builder()
                                        .init_with_value(|ptr| unsafe {
                                            let bytes = ptr.get::<Self>();
                                            let iter: BytesIterator = bytes.iter();
                                            let iter_state = Box::new(iter);
                                            PtrMut::new(Box::into_raw(iter_state) as *mut u8)
                                        })
                                        .next(|iter_ptr| unsafe {
                                            let state = iter_ptr.as_mut::<BytesIterator<'_>>();
                                            state.next().map(|value| PtrConst::new(value))
                                        })
                                        .next_back(|iter_ptr| unsafe {
                                            let state = iter_ptr.as_mut::<BytesIterator<'_>>();
                                            state.next_back().map(|value| PtrConst::new(value))
                                        })
                                        .dealloc(|iter_ptr| unsafe {
                                            drop(Box::from_raw(
                                                iter_ptr.as_ptr::<BytesIterator<'_>>()
                                                    as *mut BytesIterator<'_>,
                                            ));
                                        })
                                        .build(),
                                )
                                .build()
                        },
                    )
                    .t(|| u8::SHAPE)
                    .build(),
            ))
            .build()
    };
}

1	use alloc::boxed::Box;
2
3	use bytes::{BufMut as _, Bytes, BytesMut};
4
5	use crate::{
6	Def, Facet, IterVTable, ListDef, ListVTable, PtrConst, PtrMut, PtrUninit, Shape, Type,
7	UserType, ValueVTable, value_vtable,
8	};
9
10	type BytesIterator<'mem> = core::slice::Iter<'mem, u8>;
11
12	unsafe impl Facet<'_> for Bytes {
13	const VTABLE: &'static ValueVTable = &const {
14	let mut vtable = value_vtable!(Bytes, \|f, _opts\| write!(f, "Bytes"));	4✔
15	vtable.try_from = Some(
16	\|source: PtrConst, source_shape: &Shape, target: PtrUninit\| {	1✔
17	if source_shape.is_type::<BytesMut>() {	1✔
18	let source = unsafe { source.read::<BytesMut>() };	1✔
19	let bytes = source.freeze();	1✔
20	Ok(unsafe { target.put(bytes) })	1✔
21	} else {
NEW 22	Err(crate::TryFromError::UnsupportedSourceShape {	×
NEW 23	src_shape: source_shape,	×
NEW 24	expected: &[Bytes::SHAPE],	×
NEW 25	})	×
26	}
27	},	1✔
28	);
29
30	vtable
31	};
32
33	const SHAPE: &'static Shape<'static> = &const {
34	Shape::builder_for_sized::<Self>()
35	.ty(Type::User(UserType::Opaque))
36	.inner(\|\| BytesMut::SHAPE)
37	.def(Def::List(
38	ListDef::builder()
39	.vtable(
40	&const {
41	ListVTable::builder()
42	.len(\|ptr\| unsafe {
43	let bytes = ptr.get::<Self>();	1✔
44	bytes.len()	1✔
45	})	1✔
46	.get(\|ptr, index\| unsafe {
NEW 47	let bytes = ptr.get::<Self>();	×
NEW 48	let item = bytes.get(index)?;	×
NEW 49	Some(PtrConst::new(item))	×
NEW 50	})	×
51	.as_ptr(\|ptr\| unsafe {
52	let bytes = ptr.get::<Self>();	1✔
53	PtrConst::new(bytes.as_ptr())	1✔
54	})	1✔
55	.iter_vtable(
56	IterVTable::builder()
57	.init_with_value(\|ptr\| unsafe {
NEW 58	let bytes = ptr.get::<Self>();	×
NEW 59	let iter: BytesIterator = bytes.iter();	×
NEW 60	let iter_state = Box::new(iter);	×
NEW 61	PtrMut::new(Box::into_raw(iter_state) as *mut u8)	×
NEW 62	})	×
63	.next(\|iter_ptr\| unsafe {
NEW 64	let state = iter_ptr.as_mut::<BytesIterator<'_>>();	×
NEW 65	state.next().map(\|value\| PtrConst::new(value))	×
NEW 66	})	×
67	.next_back(\|iter_ptr\| unsafe {
NEW 68	let state = iter_ptr.as_mut::<BytesIterator<'_>>();	×
NEW 69	state.next_back().map(\|value\| PtrConst::new(value))	×
NEW 70	})	×
71	.dealloc(\|iter_ptr\| unsafe {
NEW 72	drop(Box::from_raw(	×
NEW 73	iter_ptr.as_ptr::<BytesIterator<'_>>()	×
NEW 74	as *mut BytesIterator<'_>,	×
75	));
NEW 76	})	×
77	.build(),
78	)
79	.build()
80	},
81	)
82	.t(\|\| u8::SHAPE)
83	.build(),
84	))
85	.build()
86	};
87	}
88
89	unsafe impl Facet<'_> for BytesMut {
90	const VTABLE: &'static ValueVTable =
91	&const { value_vtable!(BytesMut, \|f, _opts\| write!(f, "BytesMut")) };	20✔
92
93	const SHAPE: &'static Shape<'static> = &const {
94	Shape::builder_for_sized::<Self>()
95	.ty(Type::User(UserType::Opaque))
96	.def(Def::List(
97	ListDef::builder()
98	.vtable(
99	&const {
100	ListVTable::builder()
101	.init_in_place_with_capacity(\|data, capacity\| unsafe {
NEW 102	data.put(Self::with_capacity(capacity))	×
NEW 103	})	×
104	.push(\|ptr, item\| unsafe {
105	let bytes = ptr.as_mut::<Self>();	10✔
106	let item = item.read::<u8>();	10✔
107	(*bytes).put_u8(item);	10✔
108	})	10✔
109	.len(\|ptr\| unsafe {
110	let bytes = ptr.get::<Self>();	1✔
111	bytes.len()	1✔
112	})	1✔
113	.get(\|ptr, index\| unsafe {
NEW 114	let bytes = ptr.get::<Self>();	×
NEW 115	let item = bytes.get(index)?;	×
NEW 116	Some(PtrConst::new(item))	×
NEW 117	})	×
118	.get_mut(\|ptr, index\| unsafe {
NEW 119	let bytes = ptr.as_mut::<Self>();	×
NEW 120	let item = bytes.get_mut(index)?;	×
NEW 121	Some(PtrMut::new(item))	×
NEW 122	})	×
123	.as_ptr(\|ptr\| unsafe {
124	let bytes = ptr.get::<Self>();	1✔
125	PtrConst::new(bytes.as_ptr())	1✔
126	})	1✔
127	.as_mut_ptr(\|ptr\| unsafe {
NEW 128	let bytes = ptr.as_mut::<Self>();	×
NEW 129	PtrMut::new(bytes.as_mut_ptr())	×
NEW 130	})	×
131	.iter_vtable(
132	IterVTable::builder()
133	.init_with_value(\|ptr\| unsafe {
NEW 134	let bytes = ptr.get::<Self>();	×
NEW 135	let iter: BytesIterator = bytes.iter();	×
NEW 136	let iter_state = Box::new(iter);	×
NEW 137	PtrMut::new(Box::into_raw(iter_state) as *mut u8)	×
NEW 138	})	×
139	.next(\|iter_ptr\| unsafe {
NEW 140	let state = iter_ptr.as_mut::<BytesIterator<'_>>();	×
NEW 141	state.next().map(\|value\| PtrConst::new(value))	×
NEW 142	})	×
143	.next_back(\|iter_ptr\| unsafe {
NEW 144	let state = iter_ptr.as_mut::<BytesIterator<'_>>();	×
NEW 145	state.next_back().map(\|value\| PtrConst::new(value))	×
NEW 146	})	×
147	.dealloc(\|iter_ptr\| unsafe {
NEW 148	drop(Box::from_raw(	×
NEW 149	iter_ptr.as_ptr::<BytesIterator<'_>>()	×
NEW 150	as *mut BytesIterator<'_>,	×
151	));
NEW 152	})	×
153	.build(),
154	)
155	.build()
156	},
157	)
158	.t(\|\| u8::SHAPE)
159	.build(),
160	))
161	.build()
162	};
163	}

facet-rs / facet / 15202915268

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