7319540133

Committed 25 Dec 2023 03:39AM UTC coverage: 72.884% (-0.1%) from 73.022%

Build # 7319540133

Build Type

push

github

Committed by

web-flow

Commit Message

Make ZeroVec have a niche via NonNull (#4491)

Run Details

7 of 7 new or added lines in 2 files covered. (100.0%)

2721 existing lines in 221 files now uncovered.

46318 of 63550 relevant lines covered (72.88%)

272438.55 hits per line

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

90.14

/components/datetime/src/pattern/runtime/pattern.rs

// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

use super::super::{reference, PatternError, PatternItem, TimeGranularity};
use alloc::vec::Vec;
use core::str::FromStr;
use icu_provider::prelude::*;
use zerovec::ZeroVec;

#[derive(Debug, PartialEq, Eq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]
#[cfg_attr(
    feature = "datagen",
    derive(databake::Bake),
    databake(path = icu_datetime::pattern::runtime),
)]
#[allow(clippy::exhaustive_structs)] // part of data struct
#[zerovec::make_varule(PatternULE)]
#[zerovec::skip_derive(Ord)]
pub struct Pattern<'data> {
    pub items: ZeroVec<'data, PatternItem>,
    /// This field should contain the smallest time unit from the `items` vec.
    /// If it doesn't, unexpected results for day periods may be encountered.
    pub metadata: PatternMetadata,
}

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
#[zerovec::make_ule(PatternMetadataULE)]
#[zerovec::skip_derive(Ord)]
pub struct PatternMetadata(u8);

impl PatternMetadata {
    #[inline]
    pub(crate) fn time_granularity(self) -> TimeGranularity {
        TimeGranularity::from_ordinal(self.0)
    }

    pub(crate) fn from_items(items: &[PatternItem]) -> Self {
        let time_granularity: TimeGranularity =
            items.iter().map(Into::into).max().unwrap_or_default();
        Self::from_time_granularity(time_granularity)
    }

    #[inline]
    #[doc(hidden)] // databake
    pub const fn from_time_granularity(time_granularity: TimeGranularity) -> Self {
        Self(time_granularity.ordinal())
    }

    pub(crate) fn set_time_granularity(&mut self, time_granularity: TimeGranularity) {
        self.0 = time_granularity.ordinal();
    }
}

impl Default for PatternMetadata {
    #[inline]
    fn default() -> Self {
        Self::from_time_granularity(TimeGranularity::None)
    }
}

impl<'data> Pattern<'data> {
    pub fn into_owned(self) -> Pattern<'static> {
        Pattern {
            items: self.items.into_owned(),
            metadata: self.metadata,
        }
    }
}

impl From<Vec<PatternItem>> for Pattern<'_> {
    fn from(items: Vec<PatternItem>) -> Self {
        Self {
            metadata: PatternMetadata::from_items(&items),
            items: ZeroVec::alloc_from_slice(&items),
        }
    }
}

impl From<&reference::Pattern> for Pattern<'_> {
    fn from(input: &reference::Pattern) -> Self {
        Self {
            items: ZeroVec::alloc_from_slice(&input.items),
            metadata: PatternMetadata::from_time_granularity(input.time_granularity),
        }
    }
}

impl From<&Pattern<'_>> for reference::Pattern {
    fn from(input: &Pattern<'_>) -> Self {
        Self {
            items: input.items.to_vec(),
            time_granularity: input.metadata.time_granularity(),
        }
    }
}

impl FromStr for Pattern<'_> {
    type Err = PatternError;

    fn from_str(input: &str) -> Result<Self, Self::Err> {
        let reference = crate::pattern::reference::Pattern::from_str(input)?;
        Ok(Self::from(&reference))
    }
}

impl Default for Pattern<'_> {
    fn default() -> Self {
        Self {
            items: ZeroVec::new(),
            metadata: PatternMetadata::default(),
        }
    }
}

#[cfg(feature = "datagen")]
impl core::fmt::Display for Pattern<'_> {
    fn fmt(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
        let reference = crate::pattern::reference::Pattern::from(self);
        reference.fmt(formatter)
    }
}

#[cfg(feature = "datagen")]
impl databake::Bake for PatternMetadata {
    fn bake(&self, ctx: &databake::CrateEnv) -> databake::TokenStream {
        ctx.insert("icu_datetime");
        let time_granularity = databake::Bake::bake(&self.time_granularity(), ctx);
        databake::quote! {
            icu_datetime::pattern::runtime::PatternMetadata::from_time_granularity(#time_granularity)
        }
    }
}

#[test]
#[cfg(feature = "datagen")]
fn databake() {
    databake::test_bake!(
        PatternMetadata,
        const: crate::pattern::runtime::PatternMetadata::from_time_granularity(
            crate::pattern::TimeGranularity::Hours
        ),
        icu_datetime,
    );
}

UNCOV 1	// This file is part of ICU4X. For terms of use, please see the file	×
2	// called LICENSE at the top level of the ICU4X source tree
3	// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
4
5	use super::super::{reference, PatternError, PatternItem, TimeGranularity};
6	use alloc::vec::Vec;
7	use core::str::FromStr;
8	use icu_provider::prelude::*;
9	use zerovec::ZeroVec;
10
11	#[derive(Debug, PartialEq, Eq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]	27,760✔
12	#[cfg_attr(
13	feature = "datagen",
14	derive(databake::Bake),	×
15	databake(path = icu_datetime::pattern::runtime),
16	)]
17	#[allow(clippy::exhaustive_structs)] // part of data struct
UNCOV 18	#[zerovec::make_varule(PatternULE)]	×
19	#[zerovec::skip_derive(Ord)]
20	pub struct Pattern<'data> {
21	pub items: ZeroVec<'data, PatternItem>,	14,485✔
22	/// This field should contain the smallest time unit from the `items` vec.
23	/// If it doesn't, unexpected results for day periods may be encountered.
24	pub metadata: PatternMetadata,	14,485✔
25	}
26
27	#[derive(Debug, Copy, Clone, PartialEq, Eq)]	14,490✔
UNCOV 28	#[zerovec::make_ule(PatternMetadataULE)]	×
29	#[zerovec::skip_derive(Ord)]
30	pub struct PatternMetadata(u8);	15✔
31
32	impl PatternMetadata {
33	#[inline]
34	pub(crate) fn time_granularity(self) -> TimeGranularity {	585✔
35	TimeGranularity::from_ordinal(self.0)	585✔
36	}	585✔
37
38	pub(crate) fn from_items(items: &[PatternItem]) -> Self {	452✔
39	let time_granularity: TimeGranularity =
40	items.iter().map(Into::into).max().unwrap_or_default();	452✔
41	Self::from_time_granularity(time_granularity)	452✔
42	}	452✔
43
44	#[inline]
45	#[doc(hidden)] // databake
46	pub const fn from_time_granularity(time_granularity: TimeGranularity) -> Self {	1,113✔
47	Self(time_granularity.ordinal())	1,113✔
48	}	1,113✔
49
50	pub(crate) fn set_time_granularity(&mut self, time_granularity: TimeGranularity) {	9✔
51	self.0 = time_granularity.ordinal();	9✔
52	}	9✔
53	}
54
55	impl Default for PatternMetadata {
56	#[inline]
57	fn default() -> Self {	1✔
58	Self::from_time_granularity(TimeGranularity::None)	1✔
59	}	1✔
60	}
61
62	impl<'data> Pattern<'data> {
63	pub fn into_owned(self) -> Pattern<'static> {	311✔
64	Pattern {	311✔
65	items: self.items.into_owned(),	311✔
66	metadata: self.metadata,	311✔
67	}
68	}	311✔
69	}
70
71	impl From<Vec<PatternItem>> for Pattern<'_> {
72	fn from(items: Vec<PatternItem>) -> Self {	452✔
73	Self {	452✔
74	metadata: PatternMetadata::from_items(&items),	452✔
75	items: ZeroVec::alloc_from_slice(&items),	452✔
76	}
77	}	452✔
78	}
79
80	impl From<&reference::Pattern> for Pattern<'_> {
81	fn from(input: &reference::Pattern) -> Self {	629✔
82	Self {	629✔
83	items: ZeroVec::alloc_from_slice(&input.items),	629✔
84	metadata: PatternMetadata::from_time_granularity(input.time_granularity),	629✔
UNCOV 85	}	×
86	}	629✔
87	}
88
89	impl From<&Pattern<'_>> for reference::Pattern {
90	fn from(input: &Pattern<'_>) -> Self {	10✔
91	Self {	10✔
92	items: input.items.to_vec(),	10✔
93	time_granularity: input.metadata.time_granularity(),	10✔
UNCOV 94	}	×
95	}	10✔
96	}
97
98	impl FromStr for Pattern<'_> {
99	type Err = PatternError;
100
101	fn from_str(input: &str) -> Result<Self, Self::Err> {	584✔
102	let reference = crate::pattern::reference::Pattern::from_str(input)?;	584✔
103	Ok(Self::from(&reference))	584✔
104	}	584✔
105	}
106
107	impl Default for Pattern<'_> {
108	fn default() -> Self {	1✔
109	Self {	1✔
110	items: ZeroVec::new(),	1✔
111	metadata: PatternMetadata::default(),	1✔
UNCOV 112	}	×
113	}	1✔
114	}
115
116	#[cfg(feature = "datagen")]
117	impl core::fmt::Display for Pattern<'_> {
118	fn fmt(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {	10✔
119	let reference = crate::pattern::reference::Pattern::from(self);	10✔
120	reference.fmt(formatter)	10✔
121	}	10✔
122	}
123
124	#[cfg(feature = "datagen")]
125	impl databake::Bake for PatternMetadata {
126	fn bake(&self, ctx: &databake::CrateEnv) -> databake::TokenStream {	1✔
127	ctx.insert("icu_datetime");	1✔
128	let time_granularity = databake::Bake::bake(&self.time_granularity(), ctx);	1✔
129	databake::quote! {	1✔
130	icu_datetime::pattern::runtime::PatternMetadata::from_time_granularity(#time_granularity)
131	}
132	}	1✔
133	}
134
135	#[test]
136	#[cfg(feature = "datagen")]
137	fn databake() {	2✔
138	databake::test_bake!(	1✔
139	PatternMetadata,
140	const: crate::pattern::runtime::PatternMetadata::from_time_granularity(	1✔
141	crate::pattern::TimeGranularity::Hours	1✔
142	),
143	icu_datetime,
144	);
145	}	2✔

zbraniecki / icu4x / 7319540133

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