icu_properties/provider/
names.rs

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//! 🚧 \[Unstable\] Property names-related data for this component
6//!
7//! <div class="stab unstable">
8//! 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
9//! including in SemVer minor releases. While the serde representation of data structs is guaranteed
10//! to be stable, their Rust representation might not be. Use with caution.
11//! </div>
12//!
13//! Read more about data providers: [`icu_provider`]
14
15use icu_locale_core::subtags::Script;
16use icu_provider::prelude::{yoke, zerofrom};
17
18use zerotrie::ZeroTrieSimpleAscii;
19use zerovec::ule::NichedOption;
20use zerovec::{VarZeroVec, ZeroVec};
21
22#[doc = r" `PropertyNameParseBidiClassV1`"]
#[non_exhaustive]
pub struct PropertyNameParseBidiClassV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameParseBidiClassV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseBidiClassV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseBidiClassV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseBidiClassV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
23    /// `PropertyNameParseBidiClassV1`
24    PropertyNameParseBidiClassV1,
25    PropertyValueNameToEnumMap<'static>,
26    is_singleton = true
27);
28#[doc = r" `PropertyNameParseBlockV1`"]
#[non_exhaustive]
pub struct PropertyNameParseBlockV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameParseBlockV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseBlockV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseBlockV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseBlockV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
29    /// `PropertyNameParseBlockV1`
30    PropertyNameParseBlockV1,
31    PropertyValueNameToEnumMap<'static>,
32    is_singleton = true
33);
34#[doc = r" `PropertyNameParseCanonicalCombiningClassV1`"]
#[non_exhaustive]
pub struct PropertyNameParseCanonicalCombiningClassV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameParseCanonicalCombiningClassV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseCanonicalCombiningClassV1
    {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseCanonicalCombiningClassV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseCanonicalCombiningClassV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
35    /// `PropertyNameParseCanonicalCombiningClassV1`
36    PropertyNameParseCanonicalCombiningClassV1,
37    PropertyValueNameToEnumMap<'static>,
38    is_singleton = true
39);
40#[doc = r" `PropertyNameParseEastAsianWidthV1`"]
#[non_exhaustive]
pub struct PropertyNameParseEastAsianWidthV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameParseEastAsianWidthV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseEastAsianWidthV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseEastAsianWidthV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseEastAsianWidthV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
41    /// `PropertyNameParseEastAsianWidthV1`
42    PropertyNameParseEastAsianWidthV1,
43    PropertyValueNameToEnumMap<'static>,
44    is_singleton = true
45);
46#[doc = r" `PropertyNameParseGeneralCategoryMaskV1`"]
#[non_exhaustive]
pub struct PropertyNameParseGeneralCategoryMaskV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameParseGeneralCategoryMaskV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseGeneralCategoryMaskV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseGeneralCategoryMaskV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseGeneralCategoryMaskV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
47    /// `PropertyNameParseGeneralCategoryMaskV1`
48    PropertyNameParseGeneralCategoryMaskV1,
49    PropertyValueNameToEnumMap<'static>,
50    is_singleton = true
51);
52#[doc = r" `PropertyNameParseGeneralCategoryV1`"]
#[non_exhaustive]
pub struct PropertyNameParseGeneralCategoryV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameParseGeneralCategoryV1
    {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseGeneralCategoryV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseGeneralCategoryV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseGeneralCategoryV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
53    /// `PropertyNameParseGeneralCategoryV1`
54    PropertyNameParseGeneralCategoryV1,
55    PropertyValueNameToEnumMap<'static>,
56    is_singleton = true
57);
58#[doc = r" `PropertyNameParseGraphemeClusterBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameParseGraphemeClusterBreakV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameParseGraphemeClusterBreakV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseGraphemeClusterBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseGraphemeClusterBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseGraphemeClusterBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
59    /// `PropertyNameParseGraphemeClusterBreakV1`
60    PropertyNameParseGraphemeClusterBreakV1,
61    PropertyValueNameToEnumMap<'static>,
62    is_singleton = true
63);
64#[doc = r" `PropertyNameParseHangulSyllableTypeV1`"]
#[non_exhaustive]
pub struct PropertyNameParseHangulSyllableTypeV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameParseHangulSyllableTypeV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseHangulSyllableTypeV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseHangulSyllableTypeV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseHangulSyllableTypeV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
65    /// `PropertyNameParseHangulSyllableTypeV1`
66    PropertyNameParseHangulSyllableTypeV1,
67    PropertyValueNameToEnumMap<'static>,
68    is_singleton = true
69);
70#[doc = r" `PropertyNameParseIndicSyllabicCategoryV1`"]
#[non_exhaustive]
pub struct PropertyNameParseIndicSyllabicCategoryV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameParseIndicSyllabicCategoryV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseIndicSyllabicCategoryV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseIndicSyllabicCategoryV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseIndicSyllabicCategoryV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
71    /// `PropertyNameParseIndicSyllabicCategoryV1`
72    PropertyNameParseIndicSyllabicCategoryV1,
73    PropertyValueNameToEnumMap<'static>,
74    is_singleton = true
75);
76#[doc = r" `PropertyNameParseIndicConjunctBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameParseIndicConjunctBreakV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameParseIndicConjunctBreakV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseIndicConjunctBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseIndicConjunctBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseIndicConjunctBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
77    /// `PropertyNameParseIndicConjunctBreakV1`
78    PropertyNameParseIndicConjunctBreakV1,
79    PropertyValueNameToEnumMap<'static>,
80    is_singleton = true
81);
82#[doc = r" `PropertyNameParseJoiningGroupV1`"]
#[non_exhaustive]
pub struct PropertyNameParseJoiningGroupV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameParseJoiningGroupV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseJoiningGroupV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseJoiningGroupV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseJoiningGroupV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
83    /// `PropertyNameParseJoiningGroupV1`
84    PropertyNameParseJoiningGroupV1,
85    PropertyValueNameToEnumMap<'static>,
86    is_singleton = true
87);
88#[doc = r" `PropertyNameParseJoiningTypeV1`"]
#[non_exhaustive]
pub struct PropertyNameParseJoiningTypeV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameParseJoiningTypeV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseJoiningTypeV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseJoiningTypeV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseJoiningTypeV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
89    /// `PropertyNameParseJoiningTypeV1`
90    PropertyNameParseJoiningTypeV1,
91    PropertyValueNameToEnumMap<'static>,
92    is_singleton = true
93);
94#[doc = r" `PropertyNameParseLineBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameParseLineBreakV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameParseLineBreakV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseLineBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseLineBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseLineBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
95    /// `PropertyNameParseLineBreakV1`
96    PropertyNameParseLineBreakV1,
97    PropertyValueNameToEnumMap<'static>,
98    is_singleton = true
99);
100#[doc = r" `PropertyNameParseNumericTypeV1`"]
#[non_exhaustive]
pub struct PropertyNameParseNumericTypeV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameParseNumericTypeV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseNumericTypeV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseNumericTypeV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseNumericTypeV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
101    /// `PropertyNameParseNumericTypeV1`
102    PropertyNameParseNumericTypeV1,
103    PropertyValueNameToEnumMap<'static>,
104    is_singleton = true
105);
106#[doc = r" `PropertyNameParseScriptV1`"]
#[non_exhaustive]
pub struct PropertyNameParseScriptV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameParseScriptV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseScriptV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseScriptV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseScriptV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
107    /// `PropertyNameParseScriptV1`
108    PropertyNameParseScriptV1,
109    PropertyValueNameToEnumMap<'static>,
110    is_singleton = true
111);
112#[doc = r" `PropertyNameParseSentenceBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameParseSentenceBreakV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameParseSentenceBreakV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseSentenceBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseSentenceBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseSentenceBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
113    /// `PropertyNameParseSentenceBreakV1`
114    PropertyNameParseSentenceBreakV1,
115    PropertyValueNameToEnumMap<'static>,
116    is_singleton = true
117);
118#[doc = r" `PropertyNameParseVerticalOrientationV1`"]
#[non_exhaustive]
pub struct PropertyNameParseVerticalOrientationV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameParseVerticalOrientationV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseVerticalOrientationV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseVerticalOrientationV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseVerticalOrientationV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
119    /// `PropertyNameParseVerticalOrientationV1`
120    PropertyNameParseVerticalOrientationV1,
121    PropertyValueNameToEnumMap<'static>,
122    is_singleton = true
123);
124#[doc = r" `PropertyNameParseWordBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameParseWordBreakV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameParseWordBreakV1 {
    type DataStruct = PropertyValueNameToEnumMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameParseWordBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameParseWordBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameParseWordBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
125    /// `PropertyNameParseWordBreakV1`
126    PropertyNameParseWordBreakV1,
127    PropertyValueNameToEnumMap<'static>,
128    is_singleton = true
129);
130#[doc = r" `PropertyNameLongBidiClassV1`"]
#[non_exhaustive]
pub struct PropertyNameLongBidiClassV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameLongBidiClassV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongBidiClassV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongBidiClassV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongBidiClassV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
131    /// `PropertyNameLongBidiClassV1`
132    PropertyNameLongBidiClassV1,
133    PropertyEnumToValueNameLinearMap<'static>,
134    is_singleton = true
135);
136#[doc = r" `PropertyNameShortBidiClassV1`"]
#[non_exhaustive]
pub struct PropertyNameShortBidiClassV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameShortBidiClassV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortBidiClassV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortBidiClassV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortBidiClassV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
137    /// `PropertyNameShortBidiClassV1`
138    PropertyNameShortBidiClassV1,
139    PropertyEnumToValueNameLinearMap<'static>,
140    is_singleton = true
141);
142#[doc = r" `PropertyNameLongBlockV1`"]
#[non_exhaustive]
pub struct PropertyNameLongBlockV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameLongBlockV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongBlockV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongBlockV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongBlockV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
143    /// `PropertyNameLongBlockV1`
144    PropertyNameLongBlockV1,
145    PropertyEnumToValueNameLinearMap<'static>,
146    is_singleton = true
147);
148#[doc = r" `PropertyNameShortBlockV1`"]
#[non_exhaustive]
pub struct PropertyNameShortBlockV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameShortBlockV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortBlockV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortBlockV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortBlockV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
149    /// `PropertyNameShortBlockV1`
150    PropertyNameShortBlockV1,
151    PropertyEnumToValueNameLinearMap<'static>,
152    is_singleton = true
153);
154#[doc = r" `PropertyNameLongEastAsianWidthV1`"]
#[non_exhaustive]
pub struct PropertyNameLongEastAsianWidthV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameLongEastAsianWidthV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongEastAsianWidthV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongEastAsianWidthV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongEastAsianWidthV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
155    /// `PropertyNameLongEastAsianWidthV1`
156    PropertyNameLongEastAsianWidthV1,
157    PropertyEnumToValueNameLinearMap<'static>,
158    is_singleton = true
159);
160#[doc = r" `PropertyNameShortEastAsianWidthV1`"]
#[non_exhaustive]
pub struct PropertyNameShortEastAsianWidthV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameShortEastAsianWidthV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortEastAsianWidthV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortEastAsianWidthV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortEastAsianWidthV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
161    /// `PropertyNameShortEastAsianWidthV1`
162    PropertyNameShortEastAsianWidthV1,
163    PropertyEnumToValueNameLinearMap<'static>,
164    is_singleton = true
165);
166#[doc = r" `PropertyNameLongGeneralCategoryV1`"]
#[non_exhaustive]
pub struct PropertyNameLongGeneralCategoryV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameLongGeneralCategoryV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongGeneralCategoryV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongGeneralCategoryV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongGeneralCategoryV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
167    /// `PropertyNameLongGeneralCategoryV1`
168    PropertyNameLongGeneralCategoryV1,
169    PropertyEnumToValueNameLinearMap<'static>,
170    is_singleton = true
171);
172#[doc = r" `PropertyNameShortGeneralCategoryV1`"]
#[non_exhaustive]
pub struct PropertyNameShortGeneralCategoryV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameShortGeneralCategoryV1
    {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortGeneralCategoryV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortGeneralCategoryV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortGeneralCategoryV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
173    /// `PropertyNameShortGeneralCategoryV1`
174    PropertyNameShortGeneralCategoryV1,
175    PropertyEnumToValueNameLinearMap<'static>,
176    is_singleton = true
177);
178#[doc = r" `PropertyNameLongGraphemeClusterBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameLongGraphemeClusterBreakV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameLongGraphemeClusterBreakV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongGraphemeClusterBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongGraphemeClusterBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongGraphemeClusterBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
179    /// `PropertyNameLongGraphemeClusterBreakV1`
180    PropertyNameLongGraphemeClusterBreakV1,
181    PropertyEnumToValueNameLinearMap<'static>,
182    is_singleton = true
183);
184#[doc = r" `PropertyNameShortGraphemeClusterBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameShortGraphemeClusterBreakV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameShortGraphemeClusterBreakV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortGraphemeClusterBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortGraphemeClusterBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortGraphemeClusterBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
185    /// `PropertyNameShortGraphemeClusterBreakV1`
186    PropertyNameShortGraphemeClusterBreakV1,
187    PropertyEnumToValueNameLinearMap<'static>,
188    is_singleton = true
189);
190#[doc = r" `PropertyNameLongHangulSyllableTypeV1`"]
#[non_exhaustive]
pub struct PropertyNameLongHangulSyllableTypeV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameLongHangulSyllableTypeV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongHangulSyllableTypeV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongHangulSyllableTypeV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongHangulSyllableTypeV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
191    /// `PropertyNameLongHangulSyllableTypeV1`
192    PropertyNameLongHangulSyllableTypeV1,
193    PropertyEnumToValueNameLinearMap<'static>,
194    is_singleton = true
195);
196#[doc = r" `PropertyNameShortHangulSyllableTypeV1`"]
#[non_exhaustive]
pub struct PropertyNameShortHangulSyllableTypeV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameShortHangulSyllableTypeV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortHangulSyllableTypeV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortHangulSyllableTypeV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortHangulSyllableTypeV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
197    /// `PropertyNameShortHangulSyllableTypeV1`
198    PropertyNameShortHangulSyllableTypeV1,
199    PropertyEnumToValueNameLinearMap<'static>,
200    is_singleton = true
201);
202#[doc = r" `PropertyNameLongIndicSyllabicCategoryV1`"]
#[non_exhaustive]
pub struct PropertyNameLongIndicSyllabicCategoryV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameLongIndicSyllabicCategoryV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongIndicSyllabicCategoryV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongIndicSyllabicCategoryV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongIndicSyllabicCategoryV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
203    /// `PropertyNameLongIndicSyllabicCategoryV1`
204    PropertyNameLongIndicSyllabicCategoryV1,
205    PropertyEnumToValueNameLinearMap<'static>,
206    is_singleton = true
207);
208#[doc = r" `PropertyNameShortIndicSyllabicCategoryV1`"]
#[non_exhaustive]
pub struct PropertyNameShortIndicSyllabicCategoryV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameShortIndicSyllabicCategoryV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortIndicSyllabicCategoryV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortIndicSyllabicCategoryV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortIndicSyllabicCategoryV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
209    /// `PropertyNameShortIndicSyllabicCategoryV1`
210    PropertyNameShortIndicSyllabicCategoryV1,
211    PropertyEnumToValueNameLinearMap<'static>,
212    is_singleton = true
213);
214#[doc = r" `PropertyNameLongIndicConjunctBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameLongIndicConjunctBreakV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameLongIndicConjunctBreakV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongIndicConjunctBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongIndicConjunctBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongIndicConjunctBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
215    /// `PropertyNameLongIndicConjunctBreakV1`
216    PropertyNameLongIndicConjunctBreakV1,
217    PropertyEnumToValueNameLinearMap<'static>,
218    is_singleton = true
219);
220#[doc = r" `PropertyNameShortIndicConjunctBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameShortIndicConjunctBreakV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameShortIndicConjunctBreakV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortIndicConjunctBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortIndicConjunctBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortIndicConjunctBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
221    /// `PropertyNameShortIndicConjunctBreakV1`
222    PropertyNameShortIndicConjunctBreakV1,
223    PropertyEnumToValueNameLinearMap<'static>,
224    is_singleton = true
225);
226#[doc = r" `PropertyNameLongJoiningGroupV1`"]
#[non_exhaustive]
pub struct PropertyNameLongJoiningGroupV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameLongJoiningGroupV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongJoiningGroupV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongJoiningGroupV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongJoiningGroupV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
227    /// `PropertyNameLongJoiningGroupV1`
228    PropertyNameLongJoiningGroupV1,
229    PropertyEnumToValueNameLinearMap<'static>,
230    is_singleton = true
231);
232#[doc = r" `PropertyNameShortJoiningGroupV1`"]
#[non_exhaustive]
pub struct PropertyNameShortJoiningGroupV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameShortJoiningGroupV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortJoiningGroupV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortJoiningGroupV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortJoiningGroupV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
233    /// `PropertyNameShortJoiningGroupV1`
234    PropertyNameShortJoiningGroupV1,
235    PropertyEnumToValueNameLinearMap<'static>,
236    is_singleton = true
237);
238#[doc = r" `PropertyNameLongJoiningTypeV1`"]
#[non_exhaustive]
pub struct PropertyNameLongJoiningTypeV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameLongJoiningTypeV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongJoiningTypeV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongJoiningTypeV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongJoiningTypeV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
239    /// `PropertyNameLongJoiningTypeV1`
240    PropertyNameLongJoiningTypeV1,
241    PropertyEnumToValueNameLinearMap<'static>,
242    is_singleton = true
243);
244#[doc = r" `PropertyNameShortJoiningTypeV1`"]
#[non_exhaustive]
pub struct PropertyNameShortJoiningTypeV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameShortJoiningTypeV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortJoiningTypeV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortJoiningTypeV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortJoiningTypeV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
245    /// `PropertyNameShortJoiningTypeV1`
246    PropertyNameShortJoiningTypeV1,
247    PropertyEnumToValueNameLinearMap<'static>,
248    is_singleton = true
249);
250#[doc = r" `PropertyNameLongLineBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameLongLineBreakV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameLongLineBreakV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongLineBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongLineBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongLineBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
251    /// `PropertyNameLongLineBreakV1`
252    PropertyNameLongLineBreakV1,
253    PropertyEnumToValueNameLinearMap<'static>,
254    is_singleton = true
255);
256#[doc = r" `PropertyNameLongNumericTypeV1`"]
#[non_exhaustive]
pub struct PropertyNameLongNumericTypeV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameLongNumericTypeV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongNumericTypeV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongNumericTypeV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongNumericTypeV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
257    /// `PropertyNameLongNumericTypeV1`
258    PropertyNameLongNumericTypeV1,
259    PropertyEnumToValueNameLinearMap<'static>,
260    is_singleton = true,
261);
262#[doc = r" `PropertyNameShortNumericTypeV1`"]
#[non_exhaustive]
pub struct PropertyNameShortNumericTypeV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameShortNumericTypeV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortNumericTypeV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortNumericTypeV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortNumericTypeV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
263    /// `PropertyNameShortNumericTypeV1`
264    PropertyNameShortNumericTypeV1,
265    PropertyEnumToValueNameLinearMap<'static>,
266    is_singleton = true,
267);
268#[doc = r" `PropertyNameShortLineBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameShortLineBreakV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameShortLineBreakV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortLineBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortLineBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortLineBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
269    /// `PropertyNameShortLineBreakV1`
270    PropertyNameShortLineBreakV1,
271    PropertyEnumToValueNameLinearMap<'static>,
272    is_singleton = true
273);
274#[doc = r" `PropertyNameLongScriptV1`"]
#[non_exhaustive]
pub struct PropertyNameLongScriptV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameLongScriptV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongScriptV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongScriptV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongScriptV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
275    /// `PropertyNameLongScriptV1`
276    PropertyNameLongScriptV1,
277    PropertyEnumToValueNameLinearMap<'static>,
278    is_singleton = true
279);
280#[doc = r" `PropertyNameLongSentenceBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameLongSentenceBreakV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameLongSentenceBreakV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongSentenceBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongSentenceBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongSentenceBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
281    /// `PropertyNameLongSentenceBreakV1`
282    PropertyNameLongSentenceBreakV1,
283    PropertyEnumToValueNameLinearMap<'static>,
284    is_singleton = true
285);
286#[doc = r" `PropertyNameShortSentenceBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameShortSentenceBreakV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameShortSentenceBreakV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortSentenceBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortSentenceBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortSentenceBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
287    /// `PropertyNameShortSentenceBreakV1`
288    PropertyNameShortSentenceBreakV1,
289    PropertyEnumToValueNameLinearMap<'static>,
290    is_singleton = true
291);
292#[doc = r" `PropertyNameLongVerticalOrientationV1`"]
#[non_exhaustive]
pub struct PropertyNameLongVerticalOrientationV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameLongVerticalOrientationV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongVerticalOrientationV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongVerticalOrientationV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongVerticalOrientationV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
293    /// `PropertyNameLongVerticalOrientationV1`
294    PropertyNameLongVerticalOrientationV1,
295    PropertyEnumToValueNameLinearMap<'static>,
296    is_singleton = true
297);
298#[doc = r" `PropertyNameShortVerticalOrientationV1`"]
#[non_exhaustive]
pub struct PropertyNameShortVerticalOrientationV1;
impl ::icu_provider::DynamicDataMarker for
    PropertyNameShortVerticalOrientationV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortVerticalOrientationV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortVerticalOrientationV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortVerticalOrientationV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
299    /// `PropertyNameShortVerticalOrientationV1`
300    PropertyNameShortVerticalOrientationV1,
301    PropertyEnumToValueNameLinearMap<'static>,
302    is_singleton = true
303);
304#[doc = r" `PropertyNameLongWordBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameLongWordBreakV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameLongWordBreakV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameLongWordBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameLongWordBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameLongWordBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
305    /// `PropertyNameLongWordBreakV1`
306    PropertyNameLongWordBreakV1,
307    PropertyEnumToValueNameLinearMap<'static>,
308    is_singleton = true
309);
310#[doc = r" `PropertyNameShortWordBreakV1`"]
#[non_exhaustive]
pub struct PropertyNameShortWordBreakV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameShortWordBreakV1 {
    type DataStruct = PropertyEnumToValueNameLinearMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortWordBreakV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortWordBreakV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortWordBreakV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
311    /// `PropertyNameShortWordBreakV1`
312    PropertyNameShortWordBreakV1,
313    PropertyEnumToValueNameLinearMap<'static>,
314    is_singleton = true
315);
316#[cfg(feature = "alloc")]
317icu_provider::data_marker!(
318    /// `PropertyNameLongCanonicalCombiningClassV1`
319    PropertyNameLongCanonicalCombiningClassV1,
320    PropertyEnumToValueNameSparseMap<'static>,
321    is_singleton = true,
322);
323#[cfg(feature = "alloc")]
324icu_provider::data_marker!(
325    /// `PropertyNameShortCanonicalCombiningClassV1`
326    PropertyNameShortCanonicalCombiningClassV1,
327    PropertyEnumToValueNameSparseMap<'static>,
328    is_singleton = true,
329);
330#[doc = r" `PropertyNameShortScriptV1`"]
#[non_exhaustive]
pub struct PropertyNameShortScriptV1;
impl ::icu_provider::DynamicDataMarker for PropertyNameShortScriptV1 {
    type DataStruct = PropertyScriptToIcuScriptMap<'static>;
}
impl ::icu_provider::DataMarker for PropertyNameShortScriptV1 {
    const INFO: ::icu_provider::DataMarkerInfo =
        {
            #[allow(unused_mut)]
            let mut info =
                const {
                        ::icu_provider::DataMarkerInfo::from_id(match ::icu_provider::marker::DataMarkerId::from_name("PropertyNameShortScriptV1")
                                {
                                Ok(path) => path,
                                Err(_) => {
                                    ::core::panicking::panic_fmt(format_args!("Invalid marker name: PropertyNameShortScriptV1"));
                                }
                            })
                    };
            { info.is_singleton = true; }
            info
        };
}icu_provider::data_marker!(
331    /// `PropertyNameShortScriptV1`
332    PropertyNameShortScriptV1,
333    PropertyScriptToIcuScriptMap<'static>,
334    is_singleton = true,
335);
336
337/// A set of characters and strings which share a particular property value.
338///
339/// <div class="stab unstable">
340/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
341/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
342/// to be stable, their Rust representation might not be. Use with caution.
343/// </div>
344#[derive(#[automatically_derived]impl<'data> ::core::fmt::Debug for
    PropertyValueNameToEnumMap<'data> {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field1_finish(f,
            "PropertyValueNameToEnumMap map", &&self.map)
    }
}Debug, #[automatically_derived]impl<'data> ::core::clone::Clone for
    PropertyValueNameToEnumMap<'data> {
    #[inline]
    fn clone(&self) -> Self {
        PropertyValueNameToEnumMap {
            map: ::core::clone::Clone::clone(&self.map),
        }
    }
}Clone, #[automatically_derived]impl<'data> ::core::marker::StructuralPartialEq for
    PropertyValueNameToEnumMap<'data> {
}
#[automatically_derived]impl<'data> ::core::cmp::PartialEq for
    PropertyValueNameToEnumMap<'data> {
    #[inline]
    fn eq(&self, other: &Self) -> bool { self.map == other.map }
}PartialEq, unsafe impl<'yoke> yoke::Yokeable<'yoke> for
    PropertyValueNameToEnumMap<'static> where  {
    type Output = PropertyValueNameToEnumMap<'yoke>;
    #[inline]
    fn transform(&'yoke self) -> &'yoke Self::Output {
        if false { let _: *const &'yoke Self::Output = &raw const self; }
        self
    }
    #[inline]
    fn transform_owned(self) -> Self::Output { self }
    #[inline]
    unsafe fn make(from: Self::Output) -> Self {
        ::core::mem::transmute::<Self::Output, Self>(from)
    }
    #[inline]
    fn transform_mut<F>(&'yoke mut self, f: F) where F: 'static +
        for<'_yoke> FnOnce(&'_yoke mut Self::Output) {
        let y = unsafe { &mut *(self as *mut Self as *mut Self::Output) };
        f(y)
    }
}yoke::Yokeable, impl<'zf, 'zf_inner>
    zerofrom::ZeroFrom<'zf, PropertyValueNameToEnumMap<'zf_inner>> for
    PropertyValueNameToEnumMap<'zf> where  {
    fn zero_from(this: &'zf PropertyValueNameToEnumMap<'zf_inner>) -> Self {
        match *this {
            PropertyValueNameToEnumMap { map: ref __binding_0 } => {
                PropertyValueNameToEnumMap {
                    map: <ZeroTrieSimpleAscii<ZeroVec<'zf, u8>> as
                            zerofrom::ZeroFrom<'zf,
                            ZeroTrieSimpleAscii<ZeroVec<'zf_inner,
                            u8>>>>::zero_from(__binding_0),
                }
            }
        }
    }
}zerofrom::ZeroFrom)]
345#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
346#[cfg_attr(feature = "datagen", databake(path = icu_properties::provider::names))]
347#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
348pub struct PropertyValueNameToEnumMap<'data> {
349    /// A map from names to their value discriminant
350    #[cfg_attr(feature = "serde", serde(borrow))]
351    pub map: ZeroTrieSimpleAscii<ZeroVec<'data, u8>>,
352}
353
354impl ::icu_provider::ule::MaybeAsVarULE for PropertyValueNameToEnumMap<'_> {
    type EncodedStruct = [()];
}icu_provider::data_struct!(
355    PropertyValueNameToEnumMap<'_>,
356    #[cfg(feature = "datagen")]
357);
358
359/// A mapping of property values to their names. A single instance of this map will only cover
360/// either long or short names, determined whilst loading data.
361///
362/// <div class="stab unstable">
363/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
364/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
365/// to be stable, their Rust representation might not be. Use with caution.
366/// </div>
367#[derive(Debug, Clone, PartialEq, yoke::Yokeable, zerofrom::ZeroFrom)]
368#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
369#[cfg_attr(feature = "datagen", databake(path = icu_properties::provider::names))]
370#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
371#[yoke(prove_covariance_manually)]
372#[cfg(feature = "alloc")]
373pub struct PropertyEnumToValueNameSparseMap<'data> {
374    /// A map from the value discriminant to the names
375    #[cfg_attr(feature = "serde", serde(borrow))]
376    pub map: zerovec::ZeroMap<'data, u16, str>,
377}
378
379#[cfg(feature = "alloc")]
380icu_provider::data_struct!(
381    PropertyEnumToValueNameSparseMap<'_>,
382    #[cfg(feature = "datagen")]
383);
384
385/// A mapping of property values to their names. A single instance of this map will only cover
386/// either long or short names, determined whilst loading data.
387///
388/// <div class="stab unstable">
389/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
390/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
391/// to be stable, their Rust representation might not be. Use with caution.
392/// </div>
393#[derive(#[automatically_derived]impl<'data> ::core::fmt::Debug for
    PropertyEnumToValueNameLinearMap<'data> {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field1_finish(f,
            "PropertyEnumToValueNameLinearMap map", &&self.map)
    }
}Debug, #[automatically_derived]impl<'data> ::core::clone::Clone for
    PropertyEnumToValueNameLinearMap<'data> {
    #[inline]
    fn clone(&self) -> Self {
        PropertyEnumToValueNameLinearMap {
            map: ::core::clone::Clone::clone(&self.map),
        }
    }
}Clone, #[automatically_derived]impl<'data> ::core::marker::StructuralPartialEq for
    PropertyEnumToValueNameLinearMap<'data> {
}
#[automatically_derived]impl<'data> ::core::cmp::PartialEq for
    PropertyEnumToValueNameLinearMap<'data> {
    #[inline]
    fn eq(&self, other: &Self) -> bool { self.map == other.map }
}PartialEq, unsafe impl<'yoke> yoke::Yokeable<'yoke> for
    PropertyEnumToValueNameLinearMap<'static> where  {
    type Output = PropertyEnumToValueNameLinearMap<'yoke>;
    #[inline]
    fn transform(&'yoke self) -> &'yoke Self::Output {
        if false {
            #[allow(dead_code)]
            fn __yoke_derive_require_yokeable<'yoke: 'yoke,
                T: yoke::Yokeable<'yoke>>(_t: *const &'yoke T) {}
            match self {
                PropertyEnumToValueNameLinearMap { map: __binding_0 } => {
                    __yoke_derive_require_yokeable::<'yoke,
                            VarZeroVec<'static, str>>(&raw const __binding_0);
                }
            }
        }
        let output =
            unsafe {
                ::core::mem::transmute::<&'yoke Self,
                        &'yoke Self::Output>(self)
            };
        if false {
            #[allow(dead_code)]
            fn __yoke_derive_require_static<'yoke: 'yoke,
                T: 'static>(_t: *const &'yoke T) {}
            match output {
                PropertyEnumToValueNameLinearMap { map: __binding_0 } => {}
            }
        }
        output
    }
    #[inline]
    fn transform_owned(self) -> Self::Output {
        unsafe { ::core::mem::transmute::<Self, Self::Output>(self) }
    }
    #[inline]
    unsafe fn make(from: Self::Output) -> Self {
        unsafe { ::core::mem::transmute::<Self::Output, Self>(from) }
    }
    #[inline]
    fn transform_mut<F>(&'yoke mut self, f: F) where F: 'static +
        for<'_yoke> FnOnce(&'_yoke mut Self::Output) {
        let y = unsafe { &mut *(self as *mut Self as *mut Self::Output) };
        f(y)
    }
}yoke::Yokeable, impl<'zf, 'zf_inner>
    zerofrom::ZeroFrom<'zf, PropertyEnumToValueNameLinearMap<'zf_inner>> for
    PropertyEnumToValueNameLinearMap<'zf> where  {
    fn zero_from(this: &'zf PropertyEnumToValueNameLinearMap<'zf_inner>)
        -> Self {
        match *this {
            PropertyEnumToValueNameLinearMap { map: ref __binding_0 } => {
                PropertyEnumToValueNameLinearMap {
                    map: <VarZeroVec<'zf, str> as
                            zerofrom::ZeroFrom<'zf,
                            VarZeroVec<'zf_inner, str>>>::zero_from(__binding_0),
                }
            }
        }
    }
}zerofrom::ZeroFrom)]
394#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
395#[cfg_attr(feature = "datagen", databake(path = icu_properties::provider::names))]
396#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
397#[yoke(prove_covariance_manually)]
398pub struct PropertyEnumToValueNameLinearMap<'data> {
399    /// A map from the value discriminant (the index) to the names, for mostly
400    /// contiguous data. Empty strings count as missing.
401    #[cfg_attr(feature = "serde", serde(borrow))]
402    pub map: VarZeroVec<'data, str>,
403}
404
405impl ::icu_provider::ule::MaybeAsVarULE for
    PropertyEnumToValueNameLinearMap<'_> {
    type EncodedStruct = [()];
}icu_provider::data_struct!(
406    PropertyEnumToValueNameLinearMap<'_>,
407    #[cfg(feature = "datagen")]
408);
409
410/// A mapping of property values to their names. A single instance of this map will only cover
411/// either long or short names, determined whilst loading data.
412///
413/// <div class="stab unstable">
414/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
415/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
416/// to be stable, their Rust representation might not be. Use with caution.
417/// </div>
418#[derive(#[automatically_derived]impl<'data> ::core::fmt::Debug for
    PropertyScriptToIcuScriptMap<'data> {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field1_finish(f,
            "PropertyScriptToIcuScriptMap map", &&self.map)
    }
}Debug, #[automatically_derived]impl<'data> ::core::clone::Clone for
    PropertyScriptToIcuScriptMap<'data> {
    #[inline]
    fn clone(&self) -> Self {
        PropertyScriptToIcuScriptMap {
            map: ::core::clone::Clone::clone(&self.map),
        }
    }
}Clone, #[automatically_derived]impl<'data> ::core::marker::StructuralPartialEq for
    PropertyScriptToIcuScriptMap<'data> {
}
#[automatically_derived]impl<'data> ::core::cmp::PartialEq for
    PropertyScriptToIcuScriptMap<'data> {
    #[inline]
    fn eq(&self, other: &Self) -> bool { self.map == other.map }
}PartialEq, unsafe impl<'yoke> yoke::Yokeable<'yoke> for
    PropertyScriptToIcuScriptMap<'static> where  {
    type Output = PropertyScriptToIcuScriptMap<'yoke>;
    #[inline]
    fn transform(&'yoke self) -> &'yoke Self::Output {
        if false {
            #[allow(dead_code)]
            fn __yoke_derive_require_yokeable<'yoke: 'yoke,
                T: yoke::Yokeable<'yoke>>(_t: *const &'yoke T) {}
            match self {
                PropertyScriptToIcuScriptMap { map: __binding_0 } => {
                    __yoke_derive_require_yokeable::<'yoke,
                            ZeroVec<'static,
                            NichedOption<Script, 4>>>(&raw const __binding_0);
                }
            }
        }
        let output =
            unsafe {
                ::core::mem::transmute::<&'yoke Self,
                        &'yoke Self::Output>(self)
            };
        if false {
            #[allow(dead_code)]
            fn __yoke_derive_require_static<'yoke: 'yoke,
                T: 'static>(_t: *const &'yoke T) {}
            match output {
                PropertyScriptToIcuScriptMap { map: __binding_0 } => {}
            }
        }
        output
    }
    #[inline]
    fn transform_owned(self) -> Self::Output {
        unsafe { ::core::mem::transmute::<Self, Self::Output>(self) }
    }
    #[inline]
    unsafe fn make(from: Self::Output) -> Self {
        unsafe { ::core::mem::transmute::<Self::Output, Self>(from) }
    }
    #[inline]
    fn transform_mut<F>(&'yoke mut self, f: F) where F: 'static +
        for<'_yoke> FnOnce(&'_yoke mut Self::Output) {
        let y = unsafe { &mut *(self as *mut Self as *mut Self::Output) };
        f(y)
    }
}yoke::Yokeable, impl<'zf, 'zf_inner>
    zerofrom::ZeroFrom<'zf, PropertyScriptToIcuScriptMap<'zf_inner>> for
    PropertyScriptToIcuScriptMap<'zf> where  {
    fn zero_from(this: &'zf PropertyScriptToIcuScriptMap<'zf_inner>) -> Self {
        match *this {
            PropertyScriptToIcuScriptMap { map: ref __binding_0 } => {
                PropertyScriptToIcuScriptMap {
                    map: <ZeroVec<'zf, NichedOption<Script, 4>> as
                            zerofrom::ZeroFrom<'zf,
                            ZeroVec<'zf_inner,
                            NichedOption<Script, 4>>>>::zero_from(__binding_0),
                }
            }
        }
    }
}zerofrom::ZeroFrom)]
419#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
420#[cfg_attr(feature = "datagen", databake(path = icu_properties::provider::names))]
421#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
422#[yoke(prove_covariance_manually)]
423pub struct PropertyScriptToIcuScriptMap<'data> {
424    /// A map from the value discriminant (the index) to the names, for mostly
425    /// contiguous data. Empty strings count as missing.
426    #[cfg_attr(feature = "serde", serde(borrow))]
427    pub map: ZeroVec<'data, NichedOption<Script, 4>>,
428}
429
430impl ::icu_provider::ule::MaybeAsVarULE for PropertyScriptToIcuScriptMap<'_> {
    type EncodedStruct = [()];
}icu_provider::data_struct!(
431    PropertyScriptToIcuScriptMap<'_>,
432    #[cfg(feature = "datagen")]
433);
icu_properties/provider/names.rs

icu_properties/provider/
names.rs
