15940344048

Committed 28 Jun 2025 04:12AM UTC coverage: 77.613%. First build

Build # 15940344048

Build Type

push

github

Committed by

adierking

Commit Message

hsd: Vertex data

Run Details

0 of 109 new or added lines in 6 files covered. (0.0%)

20344 of 26212 relevant lines covered (77.61%)

1089927.15 hits per line

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

0.0

/unplug/src/hsd/array.rs

use super::pointer::DefaultIn;
use super::{Error, Node, Pointer, ReadPointer, Result};
use crate::common::ReadFrom;
use crate::hsd::pointer::ReadPointerBase;
use bumpalo::collections::vec::IntoIter;
use bumpalo::collections::Vec;
use bumpalo::Bump;
use std::ops::{Deref, DerefMut};

/// Trait for values that can be used in arrays.
/// Arrays (always?) end in a sentinel value, and the type needs to specify how to detect that.
pub trait ArrayElement {
    fn is_end_of_array(&self) -> bool;
}

impl<'a, T: Node<'a>> ArrayElement for Pointer<'a, T> {
    fn is_end_of_array(&self) -> bool {
        self.is_null()
    }
}

/// An array of pointers to nodes.
pub type PointerArray<'a, T> = Array<'a, Pointer<'a, T>>;

/// An array of values terminated by a sentinel value (e.g. null pointer).
/// Typically this needs to be contained in a pointer itself (TODO: make this easier).
#[derive(Clone, PartialEq, Eq)]
pub struct Array<'a, T: Node<'a> + ArrayElement> {
    elements: Vec<'a, T>,
}

impl<'a, T: Node<'a> + ArrayElement + std::fmt::Debug> std::fmt::Debug for Array<'a, T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_list().entries(&self.elements).finish()
    }
}

impl<'a, T: Node<'a> + ArrayElement> Array<'a, T> {
    pub fn new_in(arena: &'a Bump) -> Self {
        Self { elements: Vec::new_in(arena) }
    }
}

impl<'a, T: Node<'a> + ArrayElement> DefaultIn<'a> for Array<'a, T> {
    fn default_in(arena: &'a Bump) -> Self {
        Self::new_in(arena)
    }
}

impl<'a, T: Node<'a> + ArrayElement> Deref for Array<'a, T> {
    type Target = [T];
    fn deref(&self) -> &Self::Target {
        self.elements.deref()
    }
}

impl<'a, T: Node<'a> + ArrayElement> DerefMut for Array<'a, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.elements.deref_mut()
    }
}

impl<'a, T: Node<'a> + ArrayElement> IntoIterator for Array<'a, T> {
    type Item = T;
    type IntoIter = IntoIter<'a, T>;

    fn into_iter(self) -> Self::IntoIter {
        self.elements.into_iter()
    }
}

impl<'a, R, T> ReadFrom<R> for Array<'a, T>
where
    R: ReadPointer<'a> + ?Sized,
    T: Node<'a> + ArrayElement + ReadFrom<R, Error = Error>,
{
    type Error = Error;
    fn read_from(reader: &mut R) -> Result<Self> {
        let mut elements = Vec::new_in(reader.arena());
        loop {
            let value = T::read_from(reader)?;
            if value.is_end_of_array() {
                break;
            }
            elements.push(value);
        }
        Ok(Self { elements })
    }
}

impl<'a, T> Node<'a> for Array<'a, T> where
    for<'x> T: Node<'a> + ArrayElement + ReadFrom<dyn ReadPointerBase<'a> + 'x, Error = Error> + 'a
{
}

1	use super::pointer::DefaultIn;
2	use super::{Error, Node, Pointer, ReadPointer, Result};
3	use crate::common::ReadFrom;
4	use crate::hsd::pointer::ReadPointerBase;
5	use bumpalo::collections::vec::IntoIter;
6	use bumpalo::collections::Vec;
7	use bumpalo::Bump;
8	use std::ops::{Deref, DerefMut};
9
10	/// Trait for values that can be used in arrays.
11	/// Arrays (always?) end in a sentinel value, and the type needs to specify how to detect that.
12	pub trait ArrayElement {
13	fn is_end_of_array(&self) -> bool;
14	}
15
16	impl<'a, T: Node<'a>> ArrayElement for Pointer<'a, T> {
NEW 17	fn is_end_of_array(&self) -> bool {	×
NEW 18	self.is_null()	×
NEW 19	}	×
20	}
21
22	/// An array of pointers to nodes.
23	pub type PointerArray<'a, T> = Array<'a, Pointer<'a, T>>;
24
25	/// An array of values terminated by a sentinel value (e.g. null pointer).
26	/// Typically this needs to be contained in a pointer itself (TODO: make this easier).
27	#[derive(Clone, PartialEq, Eq)]	×
28	pub struct Array<'a, T: Node<'a> + ArrayElement> {
29	elements: Vec<'a, T>,
30	}
31
32	impl<'a, T: Node<'a> + ArrayElement + std::fmt::Debug> std::fmt::Debug for Array<'a, T> {
33	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	×
34	f.debug_list().entries(&self.elements).finish()	×
35	}	×
36	}
37
38	impl<'a, T: Node<'a> + ArrayElement> Array<'a, T> {
39	pub fn new_in(arena: &'a Bump) -> Self {	×
40	Self { elements: Vec::new_in(arena) }	×
41	}	×
42	}
43
44	impl<'a, T: Node<'a> + ArrayElement> DefaultIn<'a> for Array<'a, T> {
45	fn default_in(arena: &'a Bump) -> Self {	×
46	Self::new_in(arena)	×
47	}	×
48	}
49
50	impl<'a, T: Node<'a> + ArrayElement> Deref for Array<'a, T> {
51	type Target = [T];
52	fn deref(&self) -> &Self::Target {	×
53	self.elements.deref()	×
54	}	×
55	}
56
57	impl<'a, T: Node<'a> + ArrayElement> DerefMut for Array<'a, T> {
58	fn deref_mut(&mut self) -> &mut Self::Target {	×
59	self.elements.deref_mut()	×
60	}	×
61	}
62
63	impl<'a, T: Node<'a> + ArrayElement> IntoIterator for Array<'a, T> {
64	type Item = T;
65	type IntoIter = IntoIter<'a, T>;
66
67	fn into_iter(self) -> Self::IntoIter {	×
68	self.elements.into_iter()	×
69	}	×
70	}
71
72	impl<'a, R, T> ReadFrom<R> for Array<'a, T>
73	where
74	R: ReadPointer<'a> + ?Sized,
75	T: Node<'a> + ArrayElement + ReadFrom<R, Error = Error>,
76	{
77	type Error = Error;
78	fn read_from(reader: &mut R) -> Result<Self> {	×
79	let mut elements = Vec::new_in(reader.arena());	×
80	loop {
NEW 81	let value = T::read_from(reader)?;	×
NEW 82	if value.is_end_of_array() {	×
83	break;	×
84	}	×
NEW 85	elements.push(value);	×
86	}
87	Ok(Self { elements })	×
88	}	×
89	}
90
91	impl<'a, T> Node<'a> for Array<'a, T> where
92	for<'x> T: Node<'a> + ArrayElement + ReadFrom<dyn ReadPointerBase<'a> + 'x, Error = Error> + 'a
93	{
94	}

adierking / unplug / 15940344048

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