16482855623

Committed 23 Jul 2025 10:08PM UTC coverage: 58.447% (-0.2%) from 58.68%

Build # 16482855623

Build Type

Pull #855

github

Committed by

web-flow

Commit Message

Merge dca4c2302 into 5e8e214d1

Pull Request Pull Request #855: wip: Remove 'shape lifetime

Run Details

400 of 572 new or added lines in 70 files covered. (69.93%)

3 existing lines in 3 files now uncovered.

11939 of 20427 relevant lines covered (58.45%)

120.58 hits per line

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

5.45

/facet-core/src/types/def/array.rs

use crate::{PtrMut, ptr::PtrConst};

use super::Shape;

/// Fields for array types
#[derive(Clone, Copy, Debug)]
#[repr(C)]
pub struct ArrayDef {
    /// vtable for interacting with the array
    pub vtable: &'static ArrayVTable,

    /// shape of the items in the array
    pub t: &'static Shape,

    /// The length of the array
    pub n: usize,
}

impl ArrayDef {
    /// Returns a builder for ArrayDef
    pub const fn builder() -> ArrayDefBuilder {
        ArrayDefBuilder::new()
    }

    /// Returns the shape of the items in the array
    pub fn t(&self) -> &'static Shape {
        self.t
    }
}

/// Builder for ArrayDef
pub struct ArrayDefBuilder {
    vtable: Option<&'static ArrayVTable>,
    t: Option<&'static Shape>,
    n: Option<usize>,
}

impl ArrayDefBuilder {
    /// Creates a new ArrayDefBuilder
    #[allow(clippy::new_without_default)]
    pub const fn new() -> Self {
        Self {
            vtable: None,
            t: None,
            n: None,
        }
    }

    /// Sets the vtable for the ArrayDef
    pub const fn vtable(mut self, vtable: &'static ArrayVTable) -> Self {
        self.vtable = Some(vtable);
        self
    }

    /// Sets the item shape for the ArrayDef
    pub const fn t(mut self, t: &'static Shape) -> Self {
        self.t = Some(t);
        self
    }

    /// Sets the length for the ArrayDef (added method)
    pub const fn n(mut self, n: usize) -> Self {
        self.n = Some(n);
        self
    }

    /// Builds the ArrayDef
    pub const fn build(self) -> ArrayDef {
        ArrayDef {
            vtable: self.vtable.unwrap(),
            t: self.t.unwrap(),
            n: self.n.unwrap(),
        }
    }
}

/// Get pointer to the data buffer of the array.
///
/// # Safety
///
/// The `array` parameter must point to aligned, initialized memory of the correct type.
pub type ArrayAsPtrFn = unsafe fn(array: PtrConst) -> PtrConst;

/// Get mutable pointer to the data buffer of the array.
///
/// # Safety
///
/// The `array` parameter must point to aligned, initialized memory of the correct type.
pub type ArrayAsMutPtrFn = unsafe fn(array: PtrMut) -> PtrMut;

/// Virtual table for an array
#[derive(Clone, Copy, Debug)]
#[repr(C)]
pub struct ArrayVTable {
    /// cf. [`ArrayAsPtrFn`]
    pub as_ptr: ArrayAsPtrFn,

    /// cf. [`ArrayAsMutPtrFn`]
    pub as_mut_ptr: ArrayAsMutPtrFn,
}

impl ArrayVTable {
    /// Returns a builder for ListVTable
    pub const fn builder() -> ArrayVTableBuilder {
        ArrayVTableBuilder::new()
    }
}

/// Builds a [`ArrayVTable`]
pub struct ArrayVTableBuilder {
    as_ptr_fn: Option<ArrayAsPtrFn>,
    as_mut_ptr_fn: Option<ArrayAsMutPtrFn>,
}

impl ArrayVTableBuilder {
    /// Creates a new [`ArrayVTableBuilder`] with all fields set to `None`.
    #[allow(clippy::new_without_default)]
    pub const fn new() -> Self {
        Self {
            as_ptr_fn: None,
            as_mut_ptr_fn: None,
        }
    }

    /// Sets the as_ptr field
    pub const fn as_ptr(mut self, f: ArrayAsPtrFn) -> Self {
        self.as_ptr_fn = Some(f);
        self
    }

    /// Sets the as_mut_ptr field
    pub const fn as_mut_ptr(mut self, f: ArrayAsMutPtrFn) -> Self {
        self.as_mut_ptr_fn = Some(f);
        self
    }

    /// Builds the [`ArrayVTable`] from the current state of the builder.
    ///
    /// # Panics
    ///
    /// This method will panic if any of the required fields are `None`.
    pub const fn build(self) -> ArrayVTable {
        ArrayVTable {
            as_ptr: self.as_ptr_fn.unwrap(),
            as_mut_ptr: self.as_mut_ptr_fn.unwrap(),
        }
    }
}

1	use crate::{PtrMut, ptr::PtrConst};
2
3	use super::Shape;
4
5	/// Fields for array types
6	#[derive(Clone, Copy, Debug)]
7	#[repr(C)]
8	pub struct ArrayDef {
9	/// vtable for interacting with the array
10	pub vtable: &'static ArrayVTable,
11
12	/// shape of the items in the array
13	pub t: &'static Shape,
14
15	/// The length of the array
16	pub n: usize,
17	}
18
19	impl ArrayDef {
20	/// Returns a builder for ArrayDef
NEW 21	pub const fn builder() -> ArrayDefBuilder {	×
22	ArrayDefBuilder::new()	×
23	}	×
24
25	/// Returns the shape of the items in the array
26	pub fn t(&self) -> &'static Shape {	47✔
27	self.t	47✔
28	}	47✔
29	}
30
31	/// Builder for ArrayDef
32	pub struct ArrayDefBuilder {
33	vtable: Option<&'static ArrayVTable>,
34	t: Option<&'static Shape>,
35	n: Option<usize>,
36	}
37
38	impl ArrayDefBuilder {
39	/// Creates a new ArrayDefBuilder
40	#[allow(clippy::new_without_default)]
41	pub const fn new() -> Self {	×
42	Self {	×
43	vtable: None,	×
44	t: None,	×
45	n: None,	×
46	}	×
47	}	×
48
49	/// Sets the vtable for the ArrayDef
NEW 50	pub const fn vtable(mut self, vtable: &'static ArrayVTable) -> Self {	×
51	self.vtable = Some(vtable);	×
52	self	×
53	}	×
54
55	/// Sets the item shape for the ArrayDef
NEW 56	pub const fn t(mut self, t: &'static Shape) -> Self {	×
57	self.t = Some(t);	×
58	self	×
59	}	×
60
61	/// Sets the length for the ArrayDef (added method)
62	pub const fn n(mut self, n: usize) -> Self {	×
63	self.n = Some(n);	×
64	self	×
65	}	×
66
67	/// Builds the ArrayDef
NEW 68	pub const fn build(self) -> ArrayDef {	×
69	ArrayDef {	×
70	vtable: self.vtable.unwrap(),	×
71	t: self.t.unwrap(),	×
72	n: self.n.unwrap(),	×
73	}	×
74	}	×
75	}
76
77	/// Get pointer to the data buffer of the array.
78	///
79	/// # Safety
80	///
81	/// The `array` parameter must point to aligned, initialized memory of the correct type.
82	pub type ArrayAsPtrFn = unsafe fn(array: PtrConst) -> PtrConst;
83
84	/// Get mutable pointer to the data buffer of the array.
85	///
86	/// # Safety
87	///
88	/// The `array` parameter must point to aligned, initialized memory of the correct type.
89	pub type ArrayAsMutPtrFn = unsafe fn(array: PtrMut) -> PtrMut;
90
91	/// Virtual table for an array
92	#[derive(Clone, Copy, Debug)]
93	#[repr(C)]
94	pub struct ArrayVTable {
95	/// cf. [`ArrayAsPtrFn`]
96	pub as_ptr: ArrayAsPtrFn,
97
98	/// cf. [`ArrayAsMutPtrFn`]
99	pub as_mut_ptr: ArrayAsMutPtrFn,
100	}
101
102	impl ArrayVTable {
103	/// Returns a builder for ListVTable
104	pub const fn builder() -> ArrayVTableBuilder {	×
105	ArrayVTableBuilder::new()	×
106	}	×
107	}
108
109	/// Builds a [`ArrayVTable`]
110	pub struct ArrayVTableBuilder {
111	as_ptr_fn: Option<ArrayAsPtrFn>,
112	as_mut_ptr_fn: Option<ArrayAsMutPtrFn>,
113	}
114
115	impl ArrayVTableBuilder {
116	/// Creates a new [`ArrayVTableBuilder`] with all fields set to `None`.
117	#[allow(clippy::new_without_default)]
118	pub const fn new() -> Self {	×
119	Self {	×
120	as_ptr_fn: None,	×
121	as_mut_ptr_fn: None,	×
122	}	×
123	}	×
124
125	/// Sets the as_ptr field
126	pub const fn as_ptr(mut self, f: ArrayAsPtrFn) -> Self {	×
127	self.as_ptr_fn = Some(f);	×
128	self	×
129	}	×
130
131	/// Sets the as_mut_ptr field
132	pub const fn as_mut_ptr(mut self, f: ArrayAsMutPtrFn) -> Self {	×
133	self.as_mut_ptr_fn = Some(f);	×
134	self	×
135	}	×
136
137	/// Builds the [`ArrayVTable`] from the current state of the builder.
138	///
139	/// # Panics
140	///
141	/// This method will panic if any of the required fields are `None`.
142	pub const fn build(self) -> ArrayVTable {	×
143	ArrayVTable {	×
144	as_ptr: self.as_ptr_fn.unwrap(),	×
145	as_mut_ptr: self.as_mut_ptr_fn.unwrap(),	×
146	}	×
147	}	×
148	}

facet-rs / facet / 16482855623

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