mod adapter;
use crate::provider::pattern::runtime::{self, PatternULE};
use crate::size_test_macro::size_test;
use alloc::borrow::Cow;
use icu_pattern::SinglePlaceholderPattern;
use icu_provider::prelude::*;
use potential_utf::PotentialUtf8;
use zerovec::{ule::tuplevar::Tuple2VarULE, VarZeroCow, VarZeroSlice, VarZeroVec, ZeroMap};
#[allow(missing_docs)]
pub mod marker_attrs {
use icu_provider::DataMarkerAttributes;
pub const NUMERIC: &DataMarkerAttributes = DataMarkerAttributes::from_str_or_panic("1");
pub const ABBR: &DataMarkerAttributes = DataMarkerAttributes::from_str_or_panic("3");
pub const NARROW: &DataMarkerAttributes = DataMarkerAttributes::from_str_or_panic("4");
pub const WIDE: &DataMarkerAttributes = DataMarkerAttributes::from_str_or_panic("5");
pub const SHORT: &DataMarkerAttributes = DataMarkerAttributes::from_str_or_panic("6");
pub const ABBR_STANDALONE: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("3s");
pub const NARROW_STANDALONE: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("4s");
pub const WIDE_STANDALONE: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("5s");
pub const SHORT_STANDALONE: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("6s");
pub const PATTERN_LONG: &DataMarkerAttributes = DataMarkerAttributes::from_str_or_panic("l");
pub const PATTERN_MEDIUM: &DataMarkerAttributes = DataMarkerAttributes::from_str_or_panic("m");
pub const PATTERN_SHORT: &DataMarkerAttributes = DataMarkerAttributes::from_str_or_panic("s");
pub const PATTERN_LONG12: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("l12");
pub const PATTERN_MEDIUM12: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("m12");
pub const PATTERN_SHORT12: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("s12");
pub const PATTERN_LONG24: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("l24");
pub const PATTERN_MEDIUM24: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("m24");
pub const PATTERN_SHORT24: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("s24");
pub const PATTERN_LONG_DT: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("ldt");
pub const PATTERN_MEDIUM_DT: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("mdt");
pub const PATTERN_SHORT_DT: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("sdt");
pub const PATTERN_LONG_DZ: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("ldz");
pub const PATTERN_MEDIUM_DZ: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("mdz");
pub const PATTERN_SHORT_DZ: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("sdz");
pub const PATTERN_LONG_TZ: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("ltz");
pub const PATTERN_MEDIUM_TZ: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("mtz");
pub const PATTERN_SHORT_TZ: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("stz");
pub const PATTERN_LONG_DTZ: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("ldtz");
pub const PATTERN_MEDIUM_DTZ: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("mdtz");
pub const PATTERN_SHORT_DTZ: &DataMarkerAttributes =
DataMarkerAttributes::from_str_or_panic("sdtz");
pub const NUMERIC_STR: &str = NUMERIC.as_str();
pub const ABBR_STR: &str = ABBR.as_str();
pub const NARROW_STR: &str = NARROW.as_str();
pub const WIDE_STR: &str = WIDE.as_str();
pub const SHORT_STR: &str = SHORT.as_str();
pub const ABBR_STANDALONE_STR: &str = ABBR_STANDALONE.as_str();
pub const NARROW_STANDALONE_STR: &str = NARROW_STANDALONE.as_str();
pub const WIDE_STANDALONE_STR: &str = WIDE_STANDALONE.as_str();
pub const SHORT_STANDALONE_STR: &str = SHORT_STANDALONE.as_str();
pub const PATTERN_LONG_STR: &str = PATTERN_LONG.as_str();
pub const PATTERN_MEDIUM_STR: &str = PATTERN_MEDIUM.as_str();
pub const PATTERN_SHORT_STR: &str = PATTERN_SHORT.as_str();
pub const PATTERN_LONG12_STR: &str = PATTERN_LONG12.as_str();
pub const PATTERN_MEDIUM12_STR: &str = PATTERN_MEDIUM12.as_str();
pub const PATTERN_SHORT12_STR: &str = PATTERN_SHORT12.as_str();
pub const PATTERN_LONG24_STR: &str = PATTERN_LONG24.as_str();
pub const PATTERN_MEDIUM24_STR: &str = PATTERN_MEDIUM24.as_str();
pub const PATTERN_SHORT24_STR: &str = PATTERN_SHORT24.as_str();
pub const PATTERN_LONG_DT_STR: &str = PATTERN_LONG_DT.as_str();
pub const PATTERN_MEDIUM_DT_STR: &str = PATTERN_MEDIUM_DT.as_str();
pub const PATTERN_SHORT_DT_STR: &str = PATTERN_SHORT_DT.as_str();
pub const PATTERN_LONG_DZ_STR: &str = PATTERN_LONG_DZ.as_str();
pub const PATTERN_MEDIUM_DZ_STR: &str = PATTERN_MEDIUM_DZ.as_str();
pub const PATTERN_SHORT_DZ_STR: &str = PATTERN_SHORT_DZ.as_str();
pub const PATTERN_LONG_TZ_STR: &str = PATTERN_LONG_TZ.as_str();
pub const PATTERN_MEDIUM_TZ_STR: &str = PATTERN_MEDIUM_TZ.as_str();
pub const PATTERN_SHORT_TZ_STR: &str = PATTERN_SHORT_TZ.as_str();
pub const PATTERN_LONG_DTZ_STR: &str = PATTERN_LONG_DTZ.as_str();
pub const PATTERN_MEDIUM_DTZ_STR: &str = PATTERN_MEDIUM_DTZ.as_str();
pub const PATTERN_SHORT_DTZ_STR: &str = PATTERN_SHORT_DTZ.as_str();
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[allow(clippy::exhaustive_enums)] pub enum Length {
Abbr,
Narrow,
Wide,
Short,
Numeric,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum PatternLength {
Long,
Medium,
Short,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[allow(clippy::exhaustive_enums)] pub enum Context {
Format,
Standalone,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[allow(clippy::exhaustive_enums)] pub enum GlueType {
DateTime,
DateZone,
TimeZone,
DateTimeZone,
}
pub fn name_marker_attr_info(marker_attr: &DataMarkerAttributes) -> Option<(Context, Length)> {
use {Context::*, Length::*};
match &**marker_attr {
NUMERIC_STR => Some((Format, Numeric)),
ABBR_STR => Some((Format, Abbr)),
NARROW_STR => Some((Format, Narrow)),
WIDE_STR => Some((Format, Wide)),
SHORT_STR => Some((Format, Short)),
ABBR_STANDALONE_STR => Some((Standalone, Abbr)),
NARROW_STANDALONE_STR => Some((Standalone, Narrow)),
WIDE_STANDALONE_STR => Some((Standalone, Wide)),
SHORT_STANDALONE_STR => Some((Standalone, Short)),
_ => None,
}
}
pub fn pattern_marker_attr_info_for_glue(
marker_attr: &DataMarkerAttributes,
) -> Option<(PatternLength, GlueType)> {
use {GlueType::*, PatternLength::*};
match &**marker_attr {
PATTERN_LONG_DT_STR => Some((Long, DateTime)),
PATTERN_MEDIUM_DT_STR => Some((Medium, DateTime)),
PATTERN_SHORT_DT_STR => Some((Short, DateTime)),
PATTERN_LONG_DZ_STR => Some((Long, DateZone)),
PATTERN_MEDIUM_DZ_STR => Some((Medium, DateZone)),
PATTERN_SHORT_DZ_STR => Some((Short, DateZone)),
PATTERN_LONG_TZ_STR => Some((Long, TimeZone)),
PATTERN_MEDIUM_TZ_STR => Some((Medium, TimeZone)),
PATTERN_SHORT_TZ_STR => Some((Short, TimeZone)),
PATTERN_LONG_DTZ_STR => Some((Long, DateTimeZone)),
PATTERN_MEDIUM_DTZ_STR => Some((Medium, DateTimeZone)),
PATTERN_SHORT_DTZ_STR => Some((Short, DateTimeZone)),
_ => None,
}
}
pub fn name_attr_for(context: Context, length: Length) -> &'static DataMarkerAttributes {
use {Context::*, Length::*};
match (context, length) {
(Format, Numeric) => NUMERIC,
(Format, Abbr) => ABBR,
(Format, Narrow) => NARROW,
(Format, Wide) => WIDE,
(Format, Short) => SHORT,
(Standalone, Numeric) => NUMERIC,
(Standalone, Abbr) => ABBR_STANDALONE,
(Standalone, Narrow) => NARROW_STANDALONE,
(Standalone, Wide) => WIDE_STANDALONE,
(Standalone, Short) => SHORT_STANDALONE,
}
}
pub fn pattern_marker_attr_for_glue(
length: PatternLength,
glue_type: GlueType,
) -> &'static DataMarkerAttributes {
use {GlueType::*, PatternLength::*};
match (length, glue_type) {
(Long, DateTime) => PATTERN_LONG_DT,
(Medium, DateTime) => PATTERN_MEDIUM_DT,
(Short, DateTime) => PATTERN_SHORT_DT,
(Long, DateZone) => PATTERN_LONG_DZ,
(Medium, DateZone) => PATTERN_MEDIUM_DZ,
(Short, DateZone) => PATTERN_SHORT_DZ,
(Long, TimeZone) => PATTERN_LONG_TZ,
(Medium, TimeZone) => PATTERN_MEDIUM_TZ,
(Short, TimeZone) => PATTERN_SHORT_TZ,
(Long, DateTimeZone) => PATTERN_LONG_DTZ,
(Medium, DateTimeZone) => PATTERN_MEDIUM_DTZ,
(Short, DateTimeZone) => PATTERN_SHORT_DTZ,
}
}
}
icu_provider::data_marker!(
BuddhistYearNamesV1,
YearNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_year_length"
);
icu_provider::data_marker!(
ChineseYearNamesV1,
YearNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_year_length"
);
icu_provider::data_marker!(
CopticYearNamesV1,
YearNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_year_length"
);
icu_provider::data_marker!(
DangiYearNamesV1,
YearNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_year_length"
);
icu_provider::data_marker!(
EthiopianYearNamesV1,
YearNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_year_length"
);
icu_provider::data_marker!(
GregorianYearNamesV1,
YearNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_year_length"
);
icu_provider::data_marker!(
HebrewYearNamesV1,
YearNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_year_length"
);
icu_provider::data_marker!(
IndianYearNamesV1,
YearNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_year_length"
);
icu_provider::data_marker!(
HijriYearNamesV1,
YearNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_year_length"
);
icu_provider::data_marker!(
JapaneseYearNamesV1,
YearNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_year_length"
);
icu_provider::data_marker!(
JapaneseExtendedYearNamesV1,
YearNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_year_length"
);
icu_provider::data_marker!(
PersianYearNamesV1,
YearNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_year_length"
);
icu_provider::data_marker!(
RocYearNamesV1,
YearNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_year_length"
);
icu_provider::data_marker!(
BuddhistMonthNamesV1,
MonthNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_month_length"
);
icu_provider::data_marker!(
ChineseMonthNamesV1,
MonthNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_month_length"
);
icu_provider::data_marker!(
CopticMonthNamesV1,
MonthNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_month_length"
);
icu_provider::data_marker!(
DangiMonthNamesV1,
MonthNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_month_length"
);
icu_provider::data_marker!(
EthiopianMonthNamesV1,
MonthNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_month_length"
);
icu_provider::data_marker!(
GregorianMonthNamesV1,
MonthNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_month_length"
);
icu_provider::data_marker!(
HebrewMonthNamesV1,
MonthNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_month_length"
);
icu_provider::data_marker!(
IndianMonthNamesV1,
MonthNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_month_length"
);
icu_provider::data_marker!(
HijriMonthNamesV1,
MonthNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_month_length"
);
icu_provider::data_marker!(
JapaneseMonthNamesV1,
MonthNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_month_length"
);
icu_provider::data_marker!(
JapaneseExtendedMonthNamesV1,
MonthNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_month_length"
);
icu_provider::data_marker!(
PersianMonthNamesV1,
MonthNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_month_length"
);
icu_provider::data_marker!(
RocMonthNamesV1,
MonthNames<'static>,
#[cfg(feature = "datagen")]
attributes_domain = "datetime_month_length"
);
icu_provider::data_marker!(
WeekdayNamesV1,
LinearNames<'static>,
);
icu_provider::data_marker!(
DayPeriodNamesV1,
LinearNames<'static>,
);
icu_provider::data_marker!(
ChineseDayNamesV1,
LinearNames<'static>,
);
icu_provider::data_marker!(
DangiDayNamesV1,
LinearNames<'static>,
);
icu_provider::data_marker!(
PlaceholderDayNamesV1,
LinearNames<'static>,
);
icu_provider::data_marker!(
GluePatternV1,
GluePattern<'static>
);
icu_provider::data_marker!(
DateTimeSkeletonPatternsV1,
DateTimeSkeletons<'static>,
);
size_test!(YearNames, year_names_v1_size, 32);
#[doc = year_names_v1_size!()]
#[derive(Debug, PartialEq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]
#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
#[cfg_attr(feature = "datagen", databake(path = icu_datetime::provider::neo))]
#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
#[yoke(prove_covariance_manually)]
pub enum YearNames<'data> {
FixedEras(#[cfg_attr(feature = "serde", serde(borrow))] VarZeroVec<'data, str>),
VariableEras(#[cfg_attr(feature = "serde", serde(borrow))] YearNamesMap<'data>),
Cyclic(#[cfg_attr(feature = "serde", serde(borrow))] VarZeroVec<'data, str>),
}
icu_provider::data_struct!(
YearNames<'_>,
#[cfg(feature = "datagen")]
);
type YearNamesMap<'data> =
VarZeroCow<'data, Tuple2VarULE<VarZeroSlice<PotentialUtf8>, VarZeroSlice<str>>>;
pub(crate) fn get_year_name_from_map<'a>(
map: &'a YearNamesMap<'_>,
year: &PotentialUtf8,
) -> Option<&'a str> {
let idx = map.a().binary_search_by(|x| x.cmp(year)).ok()?;
map.b().get(idx)
}
size_test!(MonthNames, month_names_v1_size, 32);
#[doc = month_names_v1_size!()]
#[derive(Debug, PartialEq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]
#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
#[cfg_attr(feature = "datagen", databake(path = icu_datetime::provider::neo))]
#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
#[yoke(prove_covariance_manually)]
pub enum MonthNames<'data> {
Linear(#[cfg_attr(feature = "serde", serde(borrow))] VarZeroVec<'data, str>),
LeapLinear(#[cfg_attr(feature = "serde", serde(borrow))] VarZeroVec<'data, str>),
LeapNumeric(
#[cfg_attr(
feature = "serde",
serde(
borrow,
deserialize_with = "icu_pattern::deserialize_borrowed_cow::<icu_pattern::SinglePlaceholder, _>"
)
)]
Cow<'data, SinglePlaceholderPattern>,
),
}
icu_provider::data_struct!(
MonthNames<'_>,
#[cfg(feature = "datagen")]
);
size_test!(LinearNames, linear_names_v1_size, 24);
#[doc = linear_names_v1_size!()]
#[derive(Debug, PartialEq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]
#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
#[cfg_attr(feature = "datagen", databake(path = icu_datetime::provider::neo))]
#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
#[yoke(prove_covariance_manually)]
pub struct LinearNames<'data> {
#[cfg_attr(feature = "serde", serde(borrow))]
pub names: VarZeroVec<'data, str>,
}
icu_provider::data_struct!(
LinearNames<'_>,
#[cfg(feature = "datagen")]
);
impl LinearNames<'_> {
pub(crate) fn am(&self) -> Option<&str> {
self.names.get(0)
}
pub(crate) fn pm(&self) -> Option<&str> {
self.names.get(1)
}
pub(crate) fn noon(&self) -> Option<&str> {
self.names
.get(2)
.and_then(|s| if s.is_empty() { None } else { Some(s) })
}
pub(crate) fn midnight(&self) -> Option<&str> {
self.names.get(3)
}
}
size_test!(GluePattern, glue_pattern_v1_size, 24);
#[doc = glue_pattern_v1_size!()]
#[derive(Debug, PartialEq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]
#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
#[cfg_attr(feature = "datagen", databake(path = icu_datetime::provider::neo))]
#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
#[yoke(prove_covariance_manually)]
pub struct GluePattern<'data> {
#[cfg_attr(feature = "serde", serde(borrow))]
pub pattern: runtime::GenericPattern<'data>,
}
icu_provider::data_struct!(
GluePattern<'_>,
#[cfg(feature = "datagen")]
);
#[derive(Debug, PartialEq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]
#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
#[cfg_attr(feature = "datagen", databake(path = icu_datetime::provider::neo))]
#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
#[yoke(prove_covariance_manually)]
#[allow(missing_docs)] pub struct DateTimeSkeletons<'data> {
#[allow(missing_docs)] #[cfg_attr(feature = "serde", serde(borrow))]
pub map: ZeroMap<'data, str, PatternULE>,
}
icu_provider::data_struct!(
DateTimeSkeletons<'_>,
#[cfg(feature = "datagen")]
);
#[derive(Debug)]
pub struct YearNamesV1;
impl DynamicDataMarker for YearNamesV1 {
type DataStruct = YearNames<'static>;
}
#[derive(Debug)]
pub struct MonthNamesV1;
impl DynamicDataMarker for MonthNamesV1 {
type DataStruct = MonthNames<'static>;
}