15157758481

Committed 21 May 2025 08:48AM UTC coverage: 57.3% (-0.4%) from 57.743%

Build # 15157758481

Build Type

Pull #663

github

Committed by

web-flow

Commit Message

Merge acb982d9b into e65aa2890

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

Run Details

19 of 70 new or added lines in 3 files covered. (27.14%)

52 existing lines in 4 files now uncovered.

9407 of 16417 relevant lines covered (57.3%)

137.21 hits per line

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

26.15

/facet-core/src/impls_bytes.rs

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

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

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

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

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

facet-rs / facet / 15157758481

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