#![allow(clippy::exhaustive_structs, clippy::exhaustive_enums)]
use crate::ListLength;
use alloc::borrow::Cow;
use icu_provider::DataMarker;
use icu_provider::{yoke, zerofrom};
mod serde_dfa;
pub use serde_dfa::SerdeDFA;
#[icu_provider::data_struct(
AndListV1Marker = "list/and@1",
OrListV1Marker = "list/or@1",
UnitListV1Marker = "list/unit@1"
)]
#[derive(Clone, Debug)]
#[cfg_attr(
feature = "datagen",
derive(serde::Serialize, databake::Bake),
databake(path = icu_list::provider),
)]
pub struct ListFormatterPatternsV1<'data>(
#[cfg_attr(feature = "datagen", serde(with = "deduplicating_array"))]
pub [ConditionalListJoinerPattern<'data>; 12],
);
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for ListFormatterPatternsV1<'de> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
#[cfg(not(feature = "serde_human"))]
if deserializer.is_human_readable() {
use serde::de::Error;
return Err(D::Error::custom(
"Deserializing human-readable ListFormatter data requires the 'serde_human' feature",
));
}
Ok(ListFormatterPatternsV1(deduplicating_array::deserialize(
deserializer,
)?))
}
}
pub(crate) struct ErasedListV1Marker;
impl DataMarker for ErasedListV1Marker {
type Yokeable = ListFormatterPatternsV1<'static>;
}
impl<'data> ListFormatterPatternsV1<'data> {
pub(crate) fn start(&self, style: ListLength) -> &ConditionalListJoinerPattern<'data> {
#![allow(clippy::indexing_slicing)] &self.0[4 * (style as usize)]
}
pub(crate) fn middle(&self, style: ListLength) -> &ConditionalListJoinerPattern<'data> {
#![allow(clippy::indexing_slicing)] &self.0[4 * (style as usize) + 1]
}
pub(crate) fn end(&self, style: ListLength) -> &ConditionalListJoinerPattern<'data> {
#![allow(clippy::indexing_slicing)] &self.0[4 * (style as usize) + 2]
}
pub(crate) fn pair(&self, style: ListLength) -> &ConditionalListJoinerPattern<'data> {
#![allow(clippy::indexing_slicing)] &self.0[4 * (style as usize) + 3]
}
}
#[derive(Clone, Debug, yoke::Yokeable, zerofrom::ZeroFrom)]
#[cfg_attr(
feature = "datagen",
derive(PartialEq, serde::Serialize, databake::Bake),
databake(path = icu_list::provider),
)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
pub struct ConditionalListJoinerPattern<'data> {
#[cfg_attr(feature = "serde", serde(borrow))]
pub default: ListJoinerPattern<'data>,
#[cfg_attr(
feature = "serde",
serde(borrow, deserialize_with = "SpecialCasePattern::deserialize_option")
)]
pub special_case: Option<SpecialCasePattern<'data>>,
}
#[derive(Clone, Debug, yoke::Yokeable, zerofrom::ZeroFrom)]
#[cfg_attr(
feature = "datagen",
derive(PartialEq, serde::Serialize, databake::Bake),
databake(path = icu_list::provider),
)]
pub struct SpecialCasePattern<'data> {
pub condition: SerdeDFA<'data>,
pub pattern: ListJoinerPattern<'data>,
}
#[cfg(feature = "serde")]
impl<'data> SpecialCasePattern<'data> {
fn deserialize_option<'de: 'data, D>(deserializer: D) -> Result<Option<Self>, D::Error>
where
D: serde::de::Deserializer<'de>,
{
use serde::Deserialize;
#[derive(Deserialize)]
struct SpecialCasePatternOptionalDfa<'data> {
#[cfg_attr(
feature = "serde",
serde(borrow, deserialize_with = "SerdeDFA::maybe_deserialize")
)]
pub condition: Option<SerdeDFA<'data>>,
#[cfg_attr(feature = "serde", serde(borrow))]
pub pattern: ListJoinerPattern<'data>,
}
Ok(
match Option::<SpecialCasePatternOptionalDfa<'data>>::deserialize(deserializer)? {
Some(SpecialCasePatternOptionalDfa {
condition: Some(condition),
pattern,
}) => Some(SpecialCasePattern { condition, pattern }),
_ => None,
},
)
}
}
#[derive(Clone, Debug, PartialEq, yoke::Yokeable, zerofrom::ZeroFrom)]
#[cfg_attr(feature = "datagen", derive(serde::Serialize))]
pub struct ListJoinerPattern<'data> {
pub(crate) string: Cow<'data, str>,
#[cfg_attr(feature = "datagen", serde(skip))]
pub(crate) index_0: u8,
pub(crate) index_1: u8,
}
#[cfg(feature = "serde")]
impl<'de: 'data, 'data> serde::Deserialize<'de> for ListJoinerPattern<'data> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[derive(serde::Deserialize)]
struct Dummy<'data> {
#[cfg_attr(feature = "serde", serde(borrow))]
string: Cow<'data, str>,
index_1: u8,
}
let Dummy { string, index_1 } = Dummy::deserialize(deserializer)?;
if index_1 as usize > string.len() {
use serde::de::Error;
Err(D::Error::custom("invalid index_1"))
} else {
Ok(ListJoinerPattern {
string,
index_0: 0,
index_1,
})
}
}
}
impl<'a> ListJoinerPattern<'a> {
pub const unsafe fn from_parts_unchecked(string: &'a str, index_1: u8) -> Self {
Self {
string: Cow::Borrowed(string),
index_0: 0,
index_1,
}
}
}
#[cfg(feature = "datagen")]
impl databake::Bake for ListJoinerPattern<'_> {
fn bake(&self, env: &databake::CrateEnv) -> databake::TokenStream {
env.insert("icu_list");
let string = (&*self.string).bake(env);
let index_1 = self.index_1.bake(env);
databake::quote! { unsafe {
::icu_list::provider::ListJoinerPattern::from_parts_unchecked(#string, #index_1)
}}
}
}
#[cfg(all(test, feature = "datagen"))]
#[test]
fn databake() {
databake::test_bake!(
ListJoinerPattern,
const: unsafe { crate::provider::ListJoinerPattern::from_parts_unchecked(", ", 2u8) },
icu_list
);
}