15200273552

Committed 23 May 2025 01:30AM UTC coverage: 57.069% (-0.1%) from 57.185%

Build # 15200273552

Build Type

Pull #663

github

Committed by

web-flow

Commit Message

Merge ae88b1e00 into 4b41e5c8a

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%)

24 existing lines in 1 file now uncovered.

9494 of 16636 relevant lines covered (57.07%)

136.52 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 alloc::boxed::Box;

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

facet-rs / facet / 15200273552

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