Making IterableResourceProvider return Locales instead of ResourceOptions

docs/tutorials/writing_a_new_data_struct.md

@@ -216,16 +216,16 @@ impl ResourceProvider<FooV1Marker> for FooProvider {
  // Load the data from CLDR JSON and emit it as an ICU4X data struct.
  // This is the core transform operation. This step could take a lot of
  // work, such as pre-parsing patterns, re-organizing the data, etc.
- // This method will be called once per option returned by supported_options.
+ // This method will be called once per option returned by supported_locales.
  // Use internal mutability (RwLock) to avoid duplicating work.
  }
 }
 
 impl IterableResourceProvider<FooV1Marker> for FooProvider {
- fn supported_options(
+ fn supported_locales(
  &self,
- ) -> Result<Vec<ResourceOptions>, DataError> {
- // This should list all supported locales, for example.
+ ) -> Result<Vec<Locale>, DataError> {
+ // This should list all supported locales.
  }
 }
 

provider/adapters/src/either.rs

@@ -80,14 +80,14 @@ impl<M: DataMarker, P0: datagen::IterableDynProvider<M>, P1: datagen::IterableDy
  datagen::IterableDynProvider<M> for EitherProvider<P0, P1>
 {
  #[inline]
- fn supported_options_for_key(
+ fn supported_locales_for_key(
  &self,
  key: ResourceKey,
- ) -> Result<alloc::vec::Vec<ResourceOptions>, DataError> {
+ ) -> Result<alloc::vec::Vec<icu_locid::Locale>, DataError> {
  use EitherProvider::*;
  match self {
- A(p) => p.supported_options_for_key(key),
- B(p) => p.supported_options_for_key(key),
+ A(p) => p.supported_locales_for_key(key),
+ B(p) => p.supported_locales_for_key(key),
  }
  }
 }
@@ -100,11 +100,11 @@ impl<
  > datagen::IterableResourceProvider<M> for EitherProvider<P0, P1>
 {
  #[inline]
- fn supported_options(&self) -> Result<alloc::vec::Vec<ResourceOptions>, DataError> {
+ fn supported_locales(&self) -> Result<alloc::vec::Vec<icu_locid::Locale>, DataError> {
  use EitherProvider::*;
  match self {
- A(p) => p.supported_options(),
- B(p) => p.supported_options(),
+ A(p) => p.supported_locales(),
+ B(p) => p.supported_locales(),
  }
  }
 }

provider/adapters/src/filter/impls.rs

@@ -22,7 +22,7 @@ where
  ///
  /// ```
  /// use icu_locid::LanguageIdentifier;
- /// use icu_locid::{langid, subtags_language as language, locale};
+ /// use icu_locid::{subtags_language as language, locale};
  /// use icu_provider::datagen::*;
  /// use icu_provider::hello_world::*;
  /// use icu_provider::prelude::*;
@@ -55,14 +55,9 @@ where
  /// ));
  ///
  /// // English should not appear in the iterator result:
- /// let supported_langids = provider
- /// .supported_options()
- /// .expect("Should successfully make an iterator of supported locales")
- /// .into_iter()
- /// .map(|options| options.get_langid())
- /// .collect::<Vec<LanguageIdentifier>>();
- /// assert!(supported_langids.contains(&langid!("de")));
- /// assert!(!supported_langids.contains(&langid!("en")));
+ /// let locales = provider.supported_locales().expect("HelloWorldProvider infallible");
+ /// assert!(locales.contains(&locale!("de")));
+ /// assert!(!locales.contains(&locale!("en")));
  /// ```
  pub fn filter_by_langid<'a>(
  self,

provider/adapters/src/filter/mod.rs

@@ -46,7 +46,7 @@ use icu_provider::prelude::*;
 ///
 /// Data requests that are rejected by the filter will return a [`DataError`] with kind
 /// [`FilteredResource`](DataErrorKind::FilteredResource), and they will not be returned
-/// by [`datagen::IterableDynProvider::supported_options_for_key`].
+/// by [`datagen::IterableDynProvider::supported_locales_for_key`].
 ///
 /// Although this struct can be created directly, the traits in this module provide helper
 /// functions for common filtering patterns.
@@ -147,20 +147,19 @@ where
  F: Fn(&DataRequest) -> bool,
  D: datagen::IterableDynProvider<M>,
 {
- fn supported_options_for_key(
+ fn supported_locales_for_key(
  &self,
  key: ResourceKey,
- ) -> Result<alloc::vec::Vec<ResourceOptions>, DataError> {
- self.inner.supported_options_for_key(key).map(|vec| {
+ ) -> Result<alloc::vec::Vec<icu_locid::Locale>, DataError> {
+ self.inner.supported_locales_for_key(key).map(|vec| {
  // Use filter_map instead of filter to avoid cloning the options
  vec.into_iter()
- .filter_map(move |options| {
- let request = DataRequest {
- options,
+ .filter_map(move |locale| {
+ if (self.predicate)(&DataRequest {
+ options: (&locale).into(),
  metadata: Default::default(),
- };
- if (self.predicate)(&request) {
- Some(request.options)
+ }) {
+ Some(locale)
  } else {
  None
  }
@@ -177,17 +176,16 @@ where
  F: Fn(&DataRequest) -> bool,
  D: datagen::IterableResourceProvider<M>,
 {
- fn supported_options(&self) -> Result<alloc::vec::Vec<ResourceOptions>, DataError> {
- self.inner.supported_options().map(|vec| {
+ fn supported_locales(&self) -> Result<alloc::vec::Vec<icu_locid::Locale>, DataError> {
+ self.inner.supported_locales().map(|vec| {
  // Use filter_map instead of filter to avoid cloning the options
  vec.into_iter()
- .filter_map(move |options| {
- let request = DataRequest {
- options,
+ .filter_map(move |locale| {
+ if (self.predicate)(&DataRequest {
+ options: (&locale).into(),
  metadata: Default::default(),
- };
- if (self.predicate)(&request) {
- Some(request.options)
+ }) {
+ Some(locale)
  } else {
  None
  }

provider/adapters/src/fork/by_key.rs

@@ -6,6 +6,8 @@
 
 use alloc::vec::Vec;
 #[cfg(feature = "datagen")]
+use icu_locid::Locale;
+#[cfg(feature = "datagen")]
 use icu_provider::datagen;
 use icu_provider::prelude::*;
 
@@ -170,15 +172,12 @@ where
  P0: datagen::IterableDynProvider<M>,
  P1: datagen::IterableDynProvider<M>,
 {
- fn supported_options_for_key(
- &self,
- key: ResourceKey,
- ) -> Result<Vec<ResourceOptions>, DataError> {
- let result = self.0.supported_options_for_key(key);
+ fn supported_locales_for_key(&self, key: ResourceKey) -> Result<Vec<Locale>, DataError> {
+ let result = self.0.supported_locales_for_key(key);
  if !result_is_err_missing_resource_key(&result) {
  return result;
  }
- self.1.supported_options_for_key(key)
+ self.1.supported_locales_for_key(key)
  }
 }
 
@@ -304,12 +303,9 @@ where
  M: DataMarker,
  P: datagen::IterableDynProvider<M>,
 {
- fn supported_options_for_key(
- &self,
- key: ResourceKey,
- ) -> Result<Vec<ResourceOptions>, DataError> {
+ fn supported_locales_for_key(&self, key: ResourceKey) -> Result<Vec<Locale>, DataError> {
  for provider in self.providers.iter() {
- let result = provider.supported_options_for_key(key);
+ let result = provider.supported_locales_for_key(key);
  if !result_is_err_missing_resource_key(&result) {
  return result;
  }

provider/core/src/data_provider/test.rs

@@ -68,7 +68,7 @@ impl ResourceProvider<HelloWorldV1Marker> for DataWarehouse {
 }
 
 impl IterableResourceProvider<HelloWorldV1Marker> for DataWarehouse {
- fn supported_options(&self) -> Result<Vec<ResourceOptions>, DataError> {
+ fn supported_locales(&self) -> Result<Vec<icu_locid::Locale>, DataError> {
  Ok(vec![Default::default()])
  }
 }
@@ -100,7 +100,7 @@ impl ResourceProvider<HelloWorldV1Marker> for DataProvider2 {
 }
 
 impl IterableResourceProvider<HelloWorldV1Marker> for DataProvider2 {
- fn supported_options(&self) -> Result<Vec<ResourceOptions>, DataError> {
+ fn supported_locales(&self) -> Result<Vec<icu_locid::Locale>, DataError> {
  Ok(vec![Default::default()])
  }
 }
@@ -115,7 +115,7 @@ impl ResourceProvider<HelloAltMarker> for DataProvider2 {
 }
 
 impl IterableResourceProvider<HelloAltMarker> for DataProvider2 {
- fn supported_options(&self) -> Result<Vec<ResourceOptions>, DataError> {
+ fn supported_locales(&self) -> Result<Vec<icu_locid::Locale>, DataError> {
  Ok(vec![Default::default()])
  }
 }

provider/core/src/datagen/iter.rs

@@ -5,37 +5,32 @@
 //! Collection of iteration APIs for data providers.
 
 use crate::prelude::*;
+use icu_locid::Locale;
 
-/// A [`DynProvider`] that can iterate over all supported [`ResourceOptions`] for a certain key.
+/// A [`DynProvider`] that can iterate over all supported [`Locale`]s for a certain key.
 ///
 /// Implementing this trait means that a data provider knows all of the data it can successfully
 /// return from a load request.
 pub trait IterableDynProvider<M: DataMarker>: DynProvider<M> {
- /// Given a [`ResourceKey`], returns a list of [`ResourceOptions`].
- fn supported_options_for_key(
- &self,
- key: ResourceKey,
- ) -> Result<Vec<ResourceOptions>, DataError>;
+ /// Given a [`ResourceKey`], returns a list of [`Locale`]s.
+ fn supported_locales_for_key(&self, key: ResourceKey) -> Result<Vec<Locale>, DataError>;
 }
 
-/// A [`ResourceProvider`] that can iterate over all supported [`ResourceOptions`] for a certain key.
+/// A [`ResourceProvider`] that can iterate over all supported [`Locale`]s for a certain key.
 ///
 /// Implementing this trait means that a data provider knows all of the data it can successfully
 /// return from a load request.
 pub trait IterableResourceProvider<M: ResourceMarker>: ResourceProvider<M> {
- /// Returns a list of [`ResourceOptions`].
- fn supported_options(&self) -> Result<Vec<ResourceOptions>, DataError>;
+ /// Returns a list of [`Locale`]s.
+ fn supported_locales(&self) -> Result<Vec<Locale>, DataError>;
 }
 
 impl<M, P> IterableDynProvider<M> for Box<P>
 where
  M: DataMarker,
  P: IterableDynProvider<M> + ?Sized,
 {
- fn supported_options_for_key(
- &self,
- key: ResourceKey,
- ) -> Result<Vec<ResourceOptions>, DataError> {
- (**self).supported_options_for_key(key)
+ fn supported_locales_for_key(&self, key: ResourceKey) -> Result<Vec<Locale>, DataError> {
+ (**self).supported_locales_for_key(key)
  }
 }

provider/core/src/datagen/mod.rs

@@ -58,7 +58,7 @@ macro_rules! make_exportable_provider {
  );
 
  impl $crate::datagen::IterableDynProvider<$crate::datagen::ExportMarker> for $provider {
- fn supported_options_for_key(&self, key: $crate::ResourceKey) -> Result<Vec<$crate::ResourceOptions>, $crate::DataError> {
+ fn supported_locales_for_key(&self, key: $crate::ResourceKey) -> Result<Vec<icu_locid::Locale>, $crate::DataError> {
  #![allow(non_upper_case_globals)]
  // Reusing the struct names as identifiers
  $(
@@ -67,7 +67,7 @@ macro_rules! make_exportable_provider {
  match key.get_hash() {
  $(
  $struct_m => {
- $crate::datagen::IterableResourceProvider::<$struct_m>::supported_options(self)
+ $crate::datagen::IterableResourceProvider::<$struct_m>::supported_locales(self)
  }
  )+,
  _ => Err($crate::DataErrorKind::MissingResourceKey.with_key(key))

provider/core/src/dynutil.rs

@@ -71,9 +71,9 @@ where
 /// }
 ///
 /// impl IterableResourceProvider<HelloWorldV1Marker> for MyProvider {
-/// fn supported_options(
+/// fn supported_locales(
 /// &self,
-/// ) -> Result<Vec<ResourceOptions>, DataError> {
+/// ) -> Result<Vec<icu_locid::Locale>, DataError> {
 /// Ok(vec![Default::default()])
 /// }
 /// }
@@ -122,8 +122,8 @@ where
 /// }
 ///
 /// impl IterableDynProvider<HelloWorldV1Marker> for MyProvider {
-/// fn supported_options_for_key(&self, _: ResourceKey)
-/// -> Result<Vec<ResourceOptions>, DataError> {
+/// fn supported_locales_for_key(&self, _: ResourceKey)
+/// -> Result<Vec<icu_locid::Locale>, DataError> {
 /// Ok(vec![Default::default()])
 /// }
 /// }

provider/core/src/hello_world.rs

@@ -156,40 +156,35 @@ impl BufferProvider for HelloWorldJsonProvider {
 
 #[cfg(feature = "datagen")]
 impl IterableResourceProvider<HelloWorldV1Marker> for HelloWorldProvider {
- fn supported_options(&self) -> Result<Vec<ResourceOptions>, DataError> {
+ fn supported_locales(&self) -> Result<Vec<icu_locid::Locale>, DataError> {
  #[allow(clippy::unwrap_used)] // datagen
- Ok(Self::DATA
- .iter()
- .map(|(s, _)| s.parse::<icu_locid::LanguageIdentifier>().unwrap())
- .map(ResourceOptions::from)
- .collect())
+ Ok(Self::DATA.iter().map(|(s, _)| s.parse().unwrap()).collect())
  }
 }
 
 #[test]
 fn test_iter() {
  use icu_locid::locale;
- let supported_langids: Vec<ResourceOptions> = HelloWorldProvider.supported_options().unwrap();
 
  assert_eq!(
- supported_langids,
- vec![
- locale!("bn").into(),
- locale!("cs").into(),
- locale!("de").into(),
- locale!("el").into(),
- locale!("en").into(),
- locale!("eo").into(),
- locale!("fa").into(),
- locale!("fi").into(),
- locale!("is").into(),
- locale!("ja").into(),
- locale!("la").into(),
- locale!("pt").into(),
- locale!("ro").into(),
- locale!("ru").into(),
- locale!("vi").into(),
- locale!("zh").into()
- ]
+ HelloWorldProvider.supported_locales(),
+ Ok(vec![
+ locale!("bn"),
+ locale!("cs"),
+ locale!("de"),
+ locale!("el"),
+ locale!("en"),
+ locale!("eo"),
+ locale!("fa"),
+ locale!("fi"),
+ locale!("is"),
+ locale!("ja"),
+ locale!("la"),
+ locale!("pt"),
+ locale!("ro"),
+ locale!("ru"),
+ locale!("vi"),
+ locale!("zh"),
+ ]),
  );
 }

provider/datagen/src/lib.rs

@@ -280,10 +280,11 @@ pub fn datagen(
 
  keys.into_par_iter().try_for_each(|&key| {
  log::info!("Writing key: {}", key);
- let options = provider
- .supported_options_for_key(key)
+ let locales = provider
+ .supported_locales_for_key(key)
  .map_err(|e| e.with_key(key))?;
- let res = options.into_par_iter().try_for_each(|options| {
+ let res = locales.into_par_iter().try_for_each(|locale| {
+ let options = ResourceOptions::from(locale);
  let req = DataRequest {
  options: options.clone(),
  metadata: Default::default(),

provider/datagen/src/transform/cldr/calendar/japanese.rs

@@ -5,7 +5,7 @@
 use crate::transform::cldr::cldr_serde;
 use crate::SourceData;
 use icu_calendar::provider::*;
-use icu_locid::langid;
+use icu_locid::{langid, Locale};
 use icu_provider::datagen::IterableResourceProvider;
 use icu_provider::prelude::*;
 use std::collections::BTreeMap;
@@ -194,7 +194,7 @@ fn era_to_code(original: &str, year: i32) -> Result<TinyStr16, String> {
 icu_provider::make_exportable_provider!(JapaneseErasProvider, [JapaneseErasV1Marker,]);
 
 impl IterableResourceProvider<JapaneseErasV1Marker> for JapaneseErasProvider {
- fn supported_options(&self) -> Result<Vec<ResourceOptions>, DataError> {
+ fn supported_locales(&self) -> Result<Vec<Locale>, DataError> {
  Ok(vec![Default::default()])
  }
 }