intl/icu_capi/src/properties_sets.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 #[diplomat::bridge]
   6 pub mod ffi {
   7     use crate::provider::ffi::ICU4XDataProvider;
   8     use alloc::boxed::Box;
   9     use core::str;
  10     use icu_properties::sets;
  11
  12     use crate::errors::ffi::ICU4XError;
  13     use crate::properties_iter::ffi::CodePointRangeIterator;
  14
  15     #[diplomat::opaque]
  16     /// An ICU4X Unicode Set Property object, capable of querying whether a code point is contained in a set based on a Unicode property.
  17     #[diplomat::rust_link(icu::properties, Mod)]
  18     #[diplomat::rust_link(icu::properties::sets::CodePointSetData, Struct)]
  19     #[diplomat::rust_link(icu::properties::sets::CodePointSetData::from_data, FnInStruct, hidden)]
  20     #[diplomat::rust_link(icu::properties::sets::CodePointSetDataBorrowed, Struct)]
  21     pub struct ICU4XCodePointSetData(pub sets::CodePointSetData);
  22
  23     impl ICU4XCodePointSetData {
  24         /// Checks whether the code point is in the set.
  25         #[diplomat::rust_link(
  26             icu::properties::sets::CodePointSetDataBorrowed::contains,
  27             FnInStruct
  28         )]
  29         pub fn contains(&self, cp: DiplomatChar) -> bool {
  30             self.0.as_borrowed().contains32(cp)
  31         }
  32         /// Checks whether the code point (specified as a 32 bit integer, in UTF-32) is in the set.
  33         #[diplomat::rust_link(
  34             icu::properties::sets::CodePointSetDataBorrowed::contains32,
  35             FnInStruct,
  36             hidden
  37         )]
  38         #[diplomat::attr(dart, disable)]
  39         pub fn contains32(&self, cp: u32) -> bool {
  40             self.contains(cp)
  41         }
  42
  43         /// Produces an iterator over ranges of code points contained in this set
  44         #[diplomat::rust_link(
  45             icu::properties::sets::CodePointSetDataBorrowed::iter_ranges,
  46             FnInStruct
  47         )]
  48         pub fn iter_ranges<'a>(&'a self) -> Box<CodePointRangeIterator<'a>> {
  49             Box::new(CodePointRangeIterator(Box::new(
  50                 self.0.as_borrowed().iter_ranges(),
  51             )))
  52         }
  53
  54         /// Produces an iterator over ranges of code points not contained in this set
  55         #[diplomat::rust_link(
  56             icu::properties::sets::CodePointSetDataBorrowed::iter_ranges_complemented,
  57             FnInStruct
  58         )]
  59         pub fn iter_ranges_complemented<'a>(&'a self) -> Box<CodePointRangeIterator<'a>> {
  60             Box::new(CodePointRangeIterator(Box::new(
  61                 self.0.as_borrowed().iter_ranges_complemented(),
  62             )))
  63         }
  64
  65         /// which is a mask with the same format as the `U_GC_XX_MASK` mask in ICU4C
  66         #[diplomat::rust_link(icu::properties::sets::for_general_category_group, Fn)]
  67         #[diplomat::rust_link(icu::properties::sets::load_for_general_category_group, Fn, hidden)]
  68         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "for_general_category_group")]
  69         pub fn load_for_general_category_group(
  70             provider: &ICU4XDataProvider,
  71             group: u32,
  72         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
  73             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
  74                 sets::for_general_category_group [r => Ok(r)],
  75                 sets::load_for_general_category_group,
  76                 provider,
  77                 group.into(),
  78             )?)))
  79         }
  80
  81         #[diplomat::rust_link(icu::properties::sets::ascii_hex_digit, Fn)]
  82         #[diplomat::rust_link(icu::properties::sets::load_ascii_hex_digit, Fn, hidden)]
  83         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "ascii_hex_digit")]
  84         pub fn load_ascii_hex_digit(
  85             provider: &ICU4XDataProvider,
  86         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
  87             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
  88                 sets::ascii_hex_digit [r => Ok(r.static_to_owned())],
  89                 sets::load_ascii_hex_digit,
  90                 provider
  91             )?)))
  92         }
  93
  94         #[diplomat::rust_link(icu::properties::sets::alnum, Fn)]
  95         #[diplomat::rust_link(icu::properties::sets::load_alnum, Fn, hidden)]
  96         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "alnum")]
  97         pub fn load_alnum(
  98             provider: &ICU4XDataProvider,
  99         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 100             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 101                 sets::alnum [r => Ok(r.static_to_owned())],
 102                 sets::load_alnum,
 103                 provider
 104             )?)))
 105         }
 106
 107         #[diplomat::rust_link(icu::properties::sets::alphabetic, Fn)]
 108         #[diplomat::rust_link(icu::properties::sets::load_alphabetic, Fn, hidden)]
 109         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "alphabetic")]
 110         pub fn load_alphabetic(
 111             provider: &ICU4XDataProvider,
 112         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 113             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 114                 sets::alphabetic [r => Ok(r.static_to_owned())],
 115                 sets::load_alphabetic,
 116                 provider
 117             )?)))
 118         }
 119
 120         #[diplomat::rust_link(icu::properties::sets::bidi_control, Fn)]
 121         #[diplomat::rust_link(icu::properties::sets::load_bidi_control, Fn, hidden)]
 122         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "bidi_control")]
 123         pub fn load_bidi_control(
 124             provider: &ICU4XDataProvider,
 125         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 126             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 127                 sets::bidi_control [r => Ok(r.static_to_owned())],
 128                 sets::load_bidi_control,
 129                 provider
 130             )?)))
 131         }
 132
 133         #[diplomat::rust_link(icu::properties::sets::bidi_mirrored, Fn)]
 134         #[diplomat::rust_link(icu::properties::sets::load_bidi_mirrored, Fn, hidden)]
 135         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "bidi_mirrored")]
 136         pub fn load_bidi_mirrored(
 137             provider: &ICU4XDataProvider,
 138         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 139             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 140                 sets::bidi_mirrored [r => Ok(r.static_to_owned())],
 141                 sets::load_bidi_mirrored,
 142                 provider
 143             )?)))
 144         }
 145
 146         #[diplomat::rust_link(icu::properties::sets::blank, Fn)]
 147         #[diplomat::rust_link(icu::properties::sets::load_blank, Fn, hidden)]
 148         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "blank")]
 149         pub fn load_blank(
 150             provider: &ICU4XDataProvider,
 151         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 152             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 153                 sets::blank [r => Ok(r.static_to_owned())],
 154                 sets::load_blank,
 155                 provider
 156             )?)))
 157         }
 158
 159         #[diplomat::rust_link(icu::properties::sets::cased, Fn)]
 160         #[diplomat::rust_link(icu::properties::sets::load_cased, Fn, hidden)]
 161         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "cased")]
 162         pub fn load_cased(
 163             provider: &ICU4XDataProvider,
 164         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 165             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 166                 sets::cased [r => Ok(r.static_to_owned())],
 167                 sets::load_cased,
 168                 provider
 169             )?)))
 170         }
 171
 172         #[diplomat::rust_link(icu::properties::sets::case_ignorable, Fn)]
 173         #[diplomat::rust_link(icu::properties::sets::load_case_ignorable, Fn, hidden)]
 174         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "case_ignorable")]
 175         pub fn load_case_ignorable(
 176             provider: &ICU4XDataProvider,
 177         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 178             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 179                 sets::case_ignorable [r => Ok(r.static_to_owned())],
 180                 sets::load_case_ignorable,
 181                 provider
 182             )?)))
 183         }
 184
 185         #[diplomat::rust_link(icu::properties::sets::full_composition_exclusion, Fn)]
 186         #[diplomat::rust_link(icu::properties::sets::load_full_composition_exclusion, Fn, hidden)]
 187         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "full_composition_exclusion")]
 188         pub fn load_full_composition_exclusion(
 189             provider: &ICU4XDataProvider,
 190         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 191             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 192                 sets::full_composition_exclusion [r => Ok(r.static_to_owned())],
 193                 sets::load_full_composition_exclusion,
 194                 provider
 195             )?)))
 196         }
 197
 198         #[diplomat::rust_link(icu::properties::sets::changes_when_casefolded, Fn)]
 199         #[diplomat::rust_link(icu::properties::sets::load_changes_when_casefolded, Fn, hidden)]
 200         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "changes_when_casefolded")]
 201         pub fn load_changes_when_casefolded(
 202             provider: &ICU4XDataProvider,
 203         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 204             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 205                 sets::changes_when_casefolded [r => Ok(r.static_to_owned())],
 206                 sets::load_changes_when_casefolded,
 207                 provider
 208             )?)))
 209         }
 210
 211         #[diplomat::rust_link(icu::properties::sets::changes_when_casemapped, Fn)]
 212         #[diplomat::rust_link(icu::properties::sets::load_changes_when_casemapped, Fn, hidden)]
 213         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "changes_when_casemapped")]
 214         pub fn load_changes_when_casemapped(
 215             provider: &ICU4XDataProvider,
 216         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 217             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 218                 sets::changes_when_casemapped [r => Ok(r.static_to_owned())],
 219                 sets::load_changes_when_casemapped,
 220                 provider
 221             )?)))
 222         }
 223
 224         #[diplomat::rust_link(icu::properties::sets::changes_when_nfkc_casefolded, Fn)]
 225         #[diplomat::rust_link(icu::properties::sets::load_changes_when_nfkc_casefolded, Fn, hidden)]
 226         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "changes_when_nfkc_casefolded")]
 227         pub fn load_changes_when_nfkc_casefolded(
 228             provider: &ICU4XDataProvider,
 229         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 230             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 231                 sets::changes_when_nfkc_casefolded [r => Ok(r.static_to_owned())],
 232                 sets::load_changes_when_nfkc_casefolded,
 233                 provider
 234             )?)))
 235         }
 236
 237         #[diplomat::rust_link(icu::properties::sets::changes_when_lowercased, Fn)]
 238         #[diplomat::rust_link(icu::properties::sets::load_changes_when_lowercased, Fn, hidden)]
 239         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "changes_when_lowercased")]
 240         pub fn load_changes_when_lowercased(
 241             provider: &ICU4XDataProvider,
 242         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 243             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 244                 sets::changes_when_lowercased [r => Ok(r.static_to_owned())],
 245                 sets::load_changes_when_lowercased,
 246                 provider
 247             )?)))
 248         }
 249
 250         #[diplomat::rust_link(icu::properties::sets::changes_when_titlecased, Fn)]
 251         #[diplomat::rust_link(icu::properties::sets::load_changes_when_titlecased, Fn, hidden)]
 252         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "changes_when_titlecased")]
 253         pub fn load_changes_when_titlecased(
 254             provider: &ICU4XDataProvider,
 255         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 256             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 257                 sets::changes_when_titlecased [r => Ok(r.static_to_owned())],
 258                 sets::load_changes_when_titlecased,
 259                 provider
 260             )?)))
 261         }
 262
 263         #[diplomat::rust_link(icu::properties::sets::changes_when_uppercased, Fn)]
 264         #[diplomat::rust_link(icu::properties::sets::load_changes_when_uppercased, Fn, hidden)]
 265         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "changes_when_uppercased")]
 266         pub fn load_changes_when_uppercased(
 267             provider: &ICU4XDataProvider,
 268         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 269             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 270                 sets::changes_when_uppercased [r => Ok(r.static_to_owned())],
 271                 sets::load_changes_when_uppercased,
 272                 provider
 273             )?)))
 274         }
 275
 276         #[diplomat::rust_link(icu::properties::sets::dash, Fn)]
 277         #[diplomat::rust_link(icu::properties::sets::load_dash, Fn, hidden)]
 278         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "dash")]
 279         pub fn load_dash(
 280             provider: &ICU4XDataProvider,
 281         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 282             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 283                 sets::dash [r => Ok(r.static_to_owned())],
 284                 sets::load_dash,
 285                 provider
 286             )?)))
 287         }
 288
 289         #[diplomat::rust_link(icu::properties::sets::deprecated, Fn)]
 290         #[diplomat::rust_link(icu::properties::sets::load_deprecated, Fn, hidden)]
 291         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "deprecated")]
 292         pub fn load_deprecated(
 293             provider: &ICU4XDataProvider,
 294         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 295             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 296                 sets::deprecated [r => Ok(r.static_to_owned())],
 297                 sets::load_deprecated,
 298                 provider
 299             )?)))
 300         }
 301
 302         #[diplomat::rust_link(icu::properties::sets::default_ignorable_code_point, Fn)]
 303         #[diplomat::rust_link(icu::properties::sets::load_default_ignorable_code_point, Fn, hidden)]
 304         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "default_ignorable_code_point")]
 305         pub fn load_default_ignorable_code_point(
 306             provider: &ICU4XDataProvider,
 307         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 308             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 309                 sets::default_ignorable_code_point [r => Ok(r.static_to_owned())],
 310                 sets::load_default_ignorable_code_point,
 311                 provider
 312             )?)))
 313         }
 314
 315         #[diplomat::rust_link(icu::properties::sets::diacritic, Fn)]
 316         #[diplomat::rust_link(icu::properties::sets::load_diacritic, Fn, hidden)]
 317         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "diacritic")]
 318         pub fn load_diacritic(
 319             provider: &ICU4XDataProvider,
 320         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 321             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 322                 sets::diacritic [r => Ok(r.static_to_owned())],
 323                 sets::load_diacritic,
 324                 provider
 325             )?)))
 326         }
 327
 328         #[diplomat::rust_link(icu::properties::sets::emoji_modifier_base, Fn)]
 329         #[diplomat::rust_link(icu::properties::sets::load_emoji_modifier_base, Fn, hidden)]
 330         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "emoji_modifier_base")]
 331         pub fn load_emoji_modifier_base(
 332             provider: &ICU4XDataProvider,
 333         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 334             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 335                 sets::emoji_modifier_base [r => Ok(r.static_to_owned())],
 336                 sets::load_emoji_modifier_base,
 337                 provider
 338             )?)))
 339         }
 340
 341         #[diplomat::rust_link(icu::properties::sets::emoji_component, Fn)]
 342         #[diplomat::rust_link(icu::properties::sets::load_emoji_component, Fn, hidden)]
 343         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "emoji_component")]
 344         pub fn load_emoji_component(
 345             provider: &ICU4XDataProvider,
 346         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 347             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 348                 sets::emoji_component [r => Ok(r.static_to_owned())],
 349                 sets::load_emoji_component,
 350                 provider
 351             )?)))
 352         }
 353
 354         #[diplomat::rust_link(icu::properties::sets::emoji_modifier, Fn)]
 355         #[diplomat::rust_link(icu::properties::sets::load_emoji_modifier, Fn, hidden)]
 356         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "emoji_modifier")]
 357         pub fn load_emoji_modifier(
 358             provider: &ICU4XDataProvider,
 359         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 360             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 361                 sets::emoji_modifier [r => Ok(r.static_to_owned())],
 362                 sets::load_emoji_modifier,
 363                 provider
 364             )?)))
 365         }
 366
 367         #[diplomat::rust_link(icu::properties::sets::emoji, Fn)]
 368         #[diplomat::rust_link(icu::properties::sets::load_emoji, Fn, hidden)]
 369         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "emoji")]
 370         pub fn load_emoji(
 371             provider: &ICU4XDataProvider,
 372         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 373             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 374                 sets::emoji [r => Ok(r.static_to_owned())],
 375                 sets::load_emoji,
 376                 provider
 377             )?)))
 378         }
 379
 380         #[diplomat::rust_link(icu::properties::sets::emoji_presentation, Fn)]
 381         #[diplomat::rust_link(icu::properties::sets::load_emoji_presentation, Fn, hidden)]
 382         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "emoji_presentation")]
 383         pub fn load_emoji_presentation(
 384             provider: &ICU4XDataProvider,
 385         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 386             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 387                 sets::emoji_presentation [r => Ok(r.static_to_owned())],
 388                 sets::load_emoji_presentation,
 389                 provider
 390             )?)))
 391         }
 392
 393         #[diplomat::rust_link(icu::properties::sets::extender, Fn)]
 394         #[diplomat::rust_link(icu::properties::sets::load_extender, Fn, hidden)]
 395         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "extender")]
 396         pub fn load_extender(
 397             provider: &ICU4XDataProvider,
 398         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 399             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 400                 sets::extender [r => Ok(r.static_to_owned())],
 401                 sets::load_extender,
 402                 provider
 403             )?)))
 404         }
 405
 406         #[diplomat::rust_link(icu::properties::sets::extended_pictographic, Fn)]
 407         #[diplomat::rust_link(icu::properties::sets::load_extended_pictographic, Fn, hidden)]
 408         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "extended_pictographic")]
 409         pub fn load_extended_pictographic(
 410             provider: &ICU4XDataProvider,
 411         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 412             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 413                 sets::extended_pictographic [r => Ok(r.static_to_owned())],
 414                 sets::load_extended_pictographic,
 415                 provider
 416             )?)))
 417         }
 418
 419         #[diplomat::rust_link(icu::properties::sets::graph, Fn)]
 420         #[diplomat::rust_link(icu::properties::sets::load_graph, Fn, hidden)]
 421         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "graph")]
 422         pub fn load_graph(
 423             provider: &ICU4XDataProvider,
 424         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 425             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 426                 sets::graph [r => Ok(r.static_to_owned())],
 427                 sets::load_graph,
 428                 provider
 429             )?)))
 430         }
 431
 432         #[diplomat::rust_link(icu::properties::sets::grapheme_base, Fn)]
 433         #[diplomat::rust_link(icu::properties::sets::load_grapheme_base, Fn, hidden)]
 434         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "grapheme_base")]
 435         pub fn load_grapheme_base(
 436             provider: &ICU4XDataProvider,
 437         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 438             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 439                 sets::grapheme_base [r => Ok(r.static_to_owned())],
 440                 sets::load_grapheme_base,
 441                 provider
 442             )?)))
 443         }
 444
 445         #[diplomat::rust_link(icu::properties::sets::grapheme_extend, Fn)]
 446         #[diplomat::rust_link(icu::properties::sets::load_grapheme_extend, Fn, hidden)]
 447         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "grapheme_extend")]
 448         pub fn load_grapheme_extend(
 449             provider: &ICU4XDataProvider,
 450         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 451             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 452                 sets::grapheme_extend [r => Ok(r.static_to_owned())],
 453                 sets::load_grapheme_extend,
 454                 provider
 455             )?)))
 456         }
 457
 458         #[diplomat::rust_link(icu::properties::sets::grapheme_link, Fn)]
 459         #[diplomat::rust_link(icu::properties::sets::load_grapheme_link, Fn, hidden)]
 460         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "grapheme_link")]
 461         pub fn load_grapheme_link(
 462             provider: &ICU4XDataProvider,
 463         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 464             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 465                 sets::grapheme_link [r => Ok(r.static_to_owned())],
 466                 sets::load_grapheme_link,
 467                 provider
 468             )?)))
 469         }
 470
 471         #[diplomat::rust_link(icu::properties::sets::hex_digit, Fn)]
 472         #[diplomat::rust_link(icu::properties::sets::load_hex_digit, Fn, hidden)]
 473         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "hex_digit")]
 474         pub fn load_hex_digit(
 475             provider: &ICU4XDataProvider,
 476         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 477             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 478                 sets::hex_digit [r => Ok(r.static_to_owned())],
 479                 sets::load_hex_digit,
 480                 provider
 481             )?)))
 482         }
 483
 484         #[diplomat::rust_link(icu::properties::sets::hyphen, Fn)]
 485         #[diplomat::rust_link(icu::properties::sets::load_hyphen, Fn, hidden)]
 486         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "hyphen")]
 487         pub fn load_hyphen(
 488             provider: &ICU4XDataProvider,
 489         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 490             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 491                 sets::hyphen [r => Ok(r.static_to_owned())],
 492                 sets::load_hyphen,
 493                 provider
 494             )?)))
 495         }
 496
 497         #[diplomat::rust_link(icu::properties::sets::id_continue, Fn)]
 498         #[diplomat::rust_link(icu::properties::sets::load_id_continue, Fn, hidden)]
 499         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "id_continue")]
 500         pub fn load_id_continue(
 501             provider: &ICU4XDataProvider,
 502         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 503             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 504                 sets::id_continue [r => Ok(r.static_to_owned())],
 505                 sets::load_id_continue,
 506                 provider
 507             )?)))
 508         }
 509
 510         #[diplomat::rust_link(icu::properties::sets::ideographic, Fn)]
 511         #[diplomat::rust_link(icu::properties::sets::load_ideographic, Fn, hidden)]
 512         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "ideographic")]
 513         pub fn load_ideographic(
 514             provider: &ICU4XDataProvider,
 515         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 516             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 517                 sets::ideographic [r => Ok(r.static_to_owned())],
 518                 sets::load_ideographic,
 519                 provider
 520             )?)))
 521         }
 522
 523         #[diplomat::rust_link(icu::properties::sets::id_start, Fn)]
 524         #[diplomat::rust_link(icu::properties::sets::load_id_start, Fn, hidden)]
 525         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "id_start")]
 526         pub fn load_id_start(
 527             provider: &ICU4XDataProvider,
 528         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 529             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 530                 sets::id_start [r => Ok(r.static_to_owned())],
 531                 sets::load_id_start,
 532                 provider
 533             )?)))
 534         }
 535
 536         #[diplomat::rust_link(icu::properties::sets::ids_binary_operator, Fn)]
 537         #[diplomat::rust_link(icu::properties::sets::load_ids_binary_operator, Fn, hidden)]
 538         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "ids_binary_operator")]
 539         pub fn load_ids_binary_operator(
 540             provider: &ICU4XDataProvider,
 541         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 542             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 543                 sets::ids_binary_operator [r => Ok(r.static_to_owned())],
 544                 sets::load_ids_binary_operator,
 545                 provider
 546             )?)))
 547         }
 548
 549         #[diplomat::rust_link(icu::properties::sets::ids_trinary_operator, Fn)]
 550         #[diplomat::rust_link(icu::properties::sets::load_ids_trinary_operator, Fn, hidden)]
 551         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "ids_trinary_operator")]
 552         pub fn load_ids_trinary_operator(
 553             provider: &ICU4XDataProvider,
 554         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 555             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 556                 sets::ids_trinary_operator [r => Ok(r.static_to_owned())],
 557                 sets::load_ids_trinary_operator,
 558                 provider
 559             )?)))
 560         }
 561
 562         #[diplomat::rust_link(icu::properties::sets::join_control, Fn)]
 563         #[diplomat::rust_link(icu::properties::sets::load_join_control, Fn, hidden)]
 564         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "join_control")]
 565         pub fn load_join_control(
 566             provider: &ICU4XDataProvider,
 567         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 568             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 569                 sets::join_control [r => Ok(r.static_to_owned())],
 570                 sets::load_join_control,
 571                 provider
 572             )?)))
 573         }
 574
 575         #[diplomat::rust_link(icu::properties::sets::logical_order_exception, Fn)]
 576         #[diplomat::rust_link(icu::properties::sets::load_logical_order_exception, Fn, hidden)]
 577         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "logical_order_exception")]
 578         pub fn load_logical_order_exception(
 579             provider: &ICU4XDataProvider,
 580         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 581             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 582                 sets::logical_order_exception [r => Ok(r.static_to_owned())],
 583                 sets::load_logical_order_exception,
 584                 provider
 585             )?)))
 586         }
 587
 588         #[diplomat::rust_link(icu::properties::sets::lowercase, Fn)]
 589         #[diplomat::rust_link(icu::properties::sets::load_lowercase, Fn, hidden)]
 590         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "lowercase")]
 591         pub fn load_lowercase(
 592             provider: &ICU4XDataProvider,
 593         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 594             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 595                 sets::lowercase [r => Ok(r.static_to_owned())],
 596                 sets::load_lowercase,
 597                 provider
 598             )?)))
 599         }
 600
 601         #[diplomat::rust_link(icu::properties::sets::math, Fn)]
 602         #[diplomat::rust_link(icu::properties::sets::load_math, Fn, hidden)]
 603         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "math")]
 604         pub fn load_math(
 605             provider: &ICU4XDataProvider,
 606         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 607             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 608                 sets::math [r => Ok(r.static_to_owned())],
 609                 sets::load_math,
 610                 provider
 611             )?)))
 612         }
 613
 614         #[diplomat::rust_link(icu::properties::sets::noncharacter_code_point, Fn)]
 615         #[diplomat::rust_link(icu::properties::sets::load_noncharacter_code_point, Fn, hidden)]
 616         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "noncharacter_code_point")]
 617         pub fn load_noncharacter_code_point(
 618             provider: &ICU4XDataProvider,
 619         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 620             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 621                 sets::noncharacter_code_point [r => Ok(r.static_to_owned())],
 622                 sets::load_noncharacter_code_point,
 623                 provider
 624             )?)))
 625         }
 626
 627         #[diplomat::rust_link(icu::properties::sets::nfc_inert, Fn)]
 628         #[diplomat::rust_link(icu::properties::sets::load_nfc_inert, Fn, hidden)]
 629         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "nfc_inert")]
 630         pub fn load_nfc_inert(
 631             provider: &ICU4XDataProvider,
 632         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 633             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 634                 sets::nfc_inert [r => Ok(r.static_to_owned())],
 635                 sets::load_nfc_inert,
 636                 provider
 637             )?)))
 638         }
 639
 640         #[diplomat::rust_link(icu::properties::sets::nfd_inert, Fn)]
 641         #[diplomat::rust_link(icu::properties::sets::load_nfd_inert, Fn, hidden)]
 642         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "nfd_inert")]
 643         pub fn load_nfd_inert(
 644             provider: &ICU4XDataProvider,
 645         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 646             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 647                 sets::nfd_inert [r => Ok(r.static_to_owned())],
 648                 sets::load_nfd_inert,
 649                 provider
 650             )?)))
 651         }
 652
 653         #[diplomat::rust_link(icu::properties::sets::nfkc_inert, Fn)]
 654         #[diplomat::rust_link(icu::properties::sets::load_nfkc_inert, Fn, hidden)]
 655         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "nfkc_inert")]
 656         pub fn load_nfkc_inert(
 657             provider: &ICU4XDataProvider,
 658         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 659             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 660                 sets::nfkc_inert [r => Ok(r.static_to_owned())],
 661                 sets::load_nfkc_inert,
 662                 provider
 663             )?)))
 664         }
 665
 666         #[diplomat::rust_link(icu::properties::sets::nfkd_inert, Fn)]
 667         #[diplomat::rust_link(icu::properties::sets::load_nfkd_inert, Fn, hidden)]
 668         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "nfkd_inert")]
 669         pub fn load_nfkd_inert(
 670             provider: &ICU4XDataProvider,
 671         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 672             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 673                 sets::nfkd_inert [r => Ok(r.static_to_owned())],
 674                 sets::load_nfkd_inert,
 675                 provider
 676             )?)))
 677         }
 678
 679         #[diplomat::rust_link(icu::properties::sets::pattern_syntax, Fn)]
 680         #[diplomat::rust_link(icu::properties::sets::load_pattern_syntax, Fn, hidden)]
 681         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "pattern_syntax")]
 682         pub fn load_pattern_syntax(
 683             provider: &ICU4XDataProvider,
 684         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 685             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 686                 sets::pattern_syntax [r => Ok(r.static_to_owned())],
 687                 sets::load_pattern_syntax,
 688                 provider
 689             )?)))
 690         }
 691
 692         #[diplomat::rust_link(icu::properties::sets::pattern_white_space, Fn)]
 693         #[diplomat::rust_link(icu::properties::sets::load_pattern_white_space, Fn, hidden)]
 694         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "pattern_white_space")]
 695         pub fn load_pattern_white_space(
 696             provider: &ICU4XDataProvider,
 697         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 698             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 699                 sets::pattern_white_space [r => Ok(r.static_to_owned())],
 700                 sets::load_pattern_white_space,
 701                 provider
 702             )?)))
 703         }
 704
 705         #[diplomat::rust_link(icu::properties::sets::prepended_concatenation_mark, Fn)]
 706         #[diplomat::rust_link(icu::properties::sets::load_prepended_concatenation_mark, Fn, hidden)]
 707         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "prepended_concatenation_mark")]
 708         pub fn load_prepended_concatenation_mark(
 709             provider: &ICU4XDataProvider,
 710         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 711             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 712                 sets::prepended_concatenation_mark [r => Ok(r.static_to_owned())],
 713                 sets::load_prepended_concatenation_mark,
 714                 provider
 715             )?)))
 716         }
 717
 718         #[diplomat::rust_link(icu::properties::sets::print, Fn)]
 719         #[diplomat::rust_link(icu::properties::sets::load_print, Fn, hidden)]
 720         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "print")]
 721         pub fn load_print(
 722             provider: &ICU4XDataProvider,
 723         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 724             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 725                 sets::print [r => Ok(r.static_to_owned())],
 726                 sets::load_print,
 727                 provider
 728             )?)))
 729         }
 730
 731         #[diplomat::rust_link(icu::properties::sets::quotation_mark, Fn)]
 732         #[diplomat::rust_link(icu::properties::sets::load_quotation_mark, Fn, hidden)]
 733         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "quotation_mark")]
 734         pub fn load_quotation_mark(
 735             provider: &ICU4XDataProvider,
 736         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 737             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 738                 sets::quotation_mark [r => Ok(r.static_to_owned())],
 739                 sets::load_quotation_mark,
 740                 provider
 741             )?)))
 742         }
 743
 744         #[diplomat::rust_link(icu::properties::sets::radical, Fn)]
 745         #[diplomat::rust_link(icu::properties::sets::load_radical, Fn, hidden)]
 746         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "radical")]
 747         pub fn load_radical(
 748             provider: &ICU4XDataProvider,
 749         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 750             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 751                 sets::radical [r => Ok(r.static_to_owned())],
 752                 sets::load_radical,
 753                 provider
 754             )?)))
 755         }
 756
 757         #[diplomat::rust_link(icu::properties::sets::regional_indicator, Fn)]
 758         #[diplomat::rust_link(icu::properties::sets::load_regional_indicator, Fn, hidden)]
 759         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "regional_indicator")]
 760         pub fn load_regional_indicator(
 761             provider: &ICU4XDataProvider,
 762         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 763             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 764                 sets::regional_indicator [r => Ok(r.static_to_owned())],
 765                 sets::load_regional_indicator,
 766                 provider
 767             )?)))
 768         }
 769
 770         #[diplomat::rust_link(icu::properties::sets::soft_dotted, Fn)]
 771         #[diplomat::rust_link(icu::properties::sets::load_soft_dotted, Fn, hidden)]
 772         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "soft_dotted")]
 773         pub fn load_soft_dotted(
 774             provider: &ICU4XDataProvider,
 775         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 776             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 777                 sets::soft_dotted [r => Ok(r.static_to_owned())],
 778                 sets::load_soft_dotted,
 779                 provider
 780             )?)))
 781         }
 782
 783         #[diplomat::rust_link(icu::properties::sets::segment_starter, Fn)]
 784         #[diplomat::rust_link(icu::properties::sets::load_segment_starter, Fn, hidden)]
 785         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "segment_starter")]
 786         pub fn load_segment_starter(
 787             provider: &ICU4XDataProvider,
 788         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 789             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 790                 sets::segment_starter [r => Ok(r.static_to_owned())],
 791                 sets::load_segment_starter,
 792                 provider
 793             )?)))
 794         }
 795
 796         #[diplomat::rust_link(icu::properties::sets::case_sensitive, Fn)]
 797         #[diplomat::rust_link(icu::properties::sets::load_case_sensitive, Fn, hidden)]
 798         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "case_sensitive")]
 799         pub fn load_case_sensitive(
 800             provider: &ICU4XDataProvider,
 801         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 802             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 803                 sets::case_sensitive [r => Ok(r.static_to_owned())],
 804                 sets::load_case_sensitive,
 805                 provider
 806             )?)))
 807         }
 808
 809         #[diplomat::rust_link(icu::properties::sets::sentence_terminal, Fn)]
 810         #[diplomat::rust_link(icu::properties::sets::load_sentence_terminal, Fn, hidden)]
 811         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "sentence_terminal")]
 812         pub fn load_sentence_terminal(
 813             provider: &ICU4XDataProvider,
 814         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 815             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 816                 sets::sentence_terminal [r => Ok(r.static_to_owned())],
 817                 sets::load_sentence_terminal,
 818                 provider
 819             )?)))
 820         }
 821
 822         #[diplomat::rust_link(icu::properties::sets::terminal_punctuation, Fn)]
 823         #[diplomat::rust_link(icu::properties::sets::load_terminal_punctuation, Fn, hidden)]
 824         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "terminal_punctuation")]
 825         pub fn load_terminal_punctuation(
 826             provider: &ICU4XDataProvider,
 827         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 828             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 829                 sets::terminal_punctuation [r => Ok(r.static_to_owned())],
 830                 sets::load_terminal_punctuation,
 831                 provider
 832             )?)))
 833         }
 834
 835         #[diplomat::rust_link(icu::properties::sets::unified_ideograph, Fn)]
 836         #[diplomat::rust_link(icu::properties::sets::load_unified_ideograph, Fn, hidden)]
 837         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "unified_ideograph")]
 838         pub fn load_unified_ideograph(
 839             provider: &ICU4XDataProvider,
 840         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 841             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 842                 sets::unified_ideograph [r => Ok(r.static_to_owned())],
 843                 sets::load_unified_ideograph,
 844                 provider
 845             )?)))
 846         }
 847
 848         #[diplomat::rust_link(icu::properties::sets::uppercase, Fn)]
 849         #[diplomat::rust_link(icu::properties::sets::load_uppercase, Fn, hidden)]
 850         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "uppercase")]
 851         pub fn load_uppercase(
 852             provider: &ICU4XDataProvider,
 853         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 854             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 855                 sets::uppercase [r => Ok(r.static_to_owned())],
 856                 sets::load_uppercase,
 857                 provider
 858             )?)))
 859         }
 860
 861         #[diplomat::rust_link(icu::properties::sets::variation_selector, Fn)]
 862         #[diplomat::rust_link(icu::properties::sets::load_variation_selector, Fn, hidden)]
 863         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "variation_selector")]
 864         pub fn load_variation_selector(
 865             provider: &ICU4XDataProvider,
 866         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 867             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 868                 sets::variation_selector [r => Ok(r.static_to_owned())],
 869                 sets::load_variation_selector,
 870                 provider
 871             )?)))
 872         }
 873
 874         #[diplomat::rust_link(icu::properties::sets::white_space, Fn)]
 875         #[diplomat::rust_link(icu::properties::sets::load_white_space, Fn, hidden)]
 876         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "white_space")]
 877         pub fn load_white_space(
 878             provider: &ICU4XDataProvider,
 879         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 880             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 881                 sets::white_space [r => Ok(r.static_to_owned())],
 882                 sets::load_white_space,
 883                 provider
 884             )?)))
 885         }
 886
 887         #[diplomat::rust_link(icu::properties::sets::xdigit, Fn)]
 888         #[diplomat::rust_link(icu::properties::sets::load_xdigit, Fn, hidden)]
 889         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "xdigit")]
 890         pub fn load_xdigit(
 891             provider: &ICU4XDataProvider,
 892         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 893             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 894                 sets::xdigit [r => Ok(r.static_to_owned())],
 895                 sets::load_xdigit,
 896                 provider
 897             )?)))
 898         }
 899
 900         #[diplomat::rust_link(icu::properties::sets::xid_continue, Fn)]
 901         #[diplomat::rust_link(icu::properties::sets::load_xid_continue, Fn, hidden)]
 902         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "xid_continue")]
 903         pub fn load_xid_continue(
 904             provider: &ICU4XDataProvider,
 905         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 906             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 907                 sets::xid_continue [r => Ok(r.static_to_owned())],
 908                 sets::load_xid_continue,
 909                 provider
 910             )?)))
 911         }
 912
 913         #[diplomat::rust_link(icu::properties::sets::xid_start, Fn)]
 914         #[diplomat::rust_link(icu::properties::sets::load_xid_start, Fn, hidden)]
 915         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "xid_start")]
 916         pub fn load_xid_start(
 917             provider: &ICU4XDataProvider,
 918         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 919             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 920                 sets::xid_start [r => Ok(r.static_to_owned())],
 921                 sets::load_xid_start,
 922                 provider
 923             )?)))
 924         }
 925
 926         /// Loads data for a property specified as a string as long as it is one of the
 927         /// [ECMA-262 binary properties][ecma] (not including Any, ASCII, and Assigned pseudoproperties).
 928         ///
 929         /// Returns `ICU4XError::PropertyUnexpectedPropertyNameError` in case the string does not
 930         /// match any property in the list
 931         ///
 932         /// [ecma]: https://tc39.es/ecma262/#table-binary-unicode-properties
 933         #[diplomat::rust_link(icu::properties::sets::for_ecma262, Fn)]
 934         #[diplomat::rust_link(icu::properties::sets::load_for_ecma262, Fn, hidden)]
 935         #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "for_ecma262")]
 936         pub fn load_for_ecma262(
 937             provider: &ICU4XDataProvider,
 938             property_name: &DiplomatStr,
 939         ) -> Result<Box<ICU4XCodePointSetData>, ICU4XError> {
 940             let name = str::from_utf8(property_name)?;
 941             Ok(Box::new(ICU4XCodePointSetData(call_constructor_unstable!(
 942                 sets::load_for_ecma262 [r => r.map(|r| r.static_to_owned())],
 943                 sets::load_for_ecma262_unstable,
 944                 provider,
 945                 name
 946             )?)))
 947         }
 948     }
 949 }