BufferProvider is DynamicDataProvider<BufferMarker> (#4992)

unicode-org · Jun 3, 2024 · fffa624 · fffa624
1 parent fc8d2fe
commit fffa624
Show file tree

Hide file tree

Showing 13 changed files with 18 additions and 185 deletions.
diff --git a/provider/adapters/src/either.rs b/provider/adapters/src/either.rs
@@ -33,21 +33,6 @@ impl<P0: AnyProvider, P1: AnyProvider> AnyProvider for EitherProvider<P0, P1> {
     }
 }
 
-impl<P0: BufferProvider, P1: BufferProvider> BufferProvider for EitherProvider<P0, P1> {
-    #[inline]
-    fn load_buffer(
-        &self,
-        key: DataKey,
-        req: DataRequest,
-    ) -> Result<DataResponse<BufferMarker>, DataError> {
-        use EitherProvider::*;
-        match self {
-            A(p) => p.load_buffer(key, req),
-            B(p) => p.load_buffer(key, req),
-        }
-    }
-}
-
 impl<M: DataMarker, P0: DynamicDataProvider<M>, P1: DynamicDataProvider<M>> DynamicDataProvider<M>
     for EitherProvider<P0, P1>
 {

diff --git a/provider/adapters/src/empty.rs b/provider/adapters/src/empty.rs
@@ -60,16 +60,6 @@ impl AnyProvider for EmptyDataProvider {
     }
 }
 
-impl BufferProvider for EmptyDataProvider {
-    fn load_buffer(
-        &self,
-        key: DataKey,
-        base_req: DataRequest,
-    ) -> Result<DataResponse<BufferMarker>, DataError> {
-        Err(self.error_kind.with_req(key, base_req))
-    }
-}
-
 impl<M> DynamicDataProvider<M> for EmptyDataProvider
 where
     M: DataMarker,

diff --git a/provider/adapters/src/fallback/mod.rs b/provider/adapters/src/fallback/mod.rs
@@ -249,24 +249,6 @@ where
     }
 }
 
-impl<P> BufferProvider for LocaleFallbackProvider<P>
-where
-    P: BufferProvider,
-{
-    fn load_buffer(
-        &self,
-        key: DataKey,
-        base_req: DataRequest,
-    ) -> Result<DataResponse<BufferMarker>, DataError> {
-        self.run_fallback(
-            key,
-            base_req,
-            |req| self.inner.load_buffer(key, req),
-            |res| &mut res.metadata,
-        )
-    }
-}
-
 impl<P, M> DynamicDataProvider<M> for LocaleFallbackProvider<P>
 where
     P: DynamicDataProvider<M>,

diff --git a/provider/adapters/src/filter/mod.rs b/provider/adapters/src/filter/mod.rs
@@ -99,26 +99,6 @@ where
     }
 }
 
-impl<D, F> BufferProvider for RequestFilterDataProvider<D, F>
-where
-    F: Fn(DataRequest) -> bool,
-    D: BufferProvider,
-{
-    fn load_buffer(
-        &self,
-        key: DataKey,
-        req: DataRequest,
-    ) -> Result<DataResponse<BufferMarker>, DataError> {
-        if (self.predicate)(req) {
-            self.inner.load_buffer(key, req)
-        } else {
-            Err(DataErrorKind::FilteredResource
-                .with_str_context(self.filter_name)
-                .with_req(key, req))
-        }
-    }
-}
-
 impl<D, F> AnyProvider for RequestFilterDataProvider<D, F>
 where
     F: Fn(DataRequest) -> bool,

diff --git a/provider/adapters/src/fork/by_error.rs b/provider/adapters/src/fork/by_error.rs
@@ -45,27 +45,6 @@ impl<P0, P1, F> ForkByErrorProvider<P0, P1, F> {
     }
 }
 
-impl<P0, P1, F> BufferProvider for ForkByErrorProvider<P0, P1, F>
-where
-    P0: BufferProvider,
-    P1: BufferProvider,
-    F: ForkByErrorPredicate,
-{
-    fn load_buffer(
-        &self,
-        key: DataKey,
-        req: DataRequest,
-    ) -> Result<DataResponse<BufferMarker>, DataError> {
-        let result = self.0.load_buffer(key, req);
-        match result {
-            Ok(ok) => return Ok(ok),
-            Err(err) if !self.2.test(key, Some(req), err) => return Err(err),
-            _ => (),
-        };
-        self.1.load_buffer(key, req)
-    }
-}
-
 impl<P0, P1, F> AnyProvider for ForkByErrorProvider<P0, P1, F>
 where
     P0: AnyProvider,
@@ -169,29 +148,6 @@ impl<P, F> MultiForkByErrorProvider<P, F> {
     }
 }
 
-impl<P, F> BufferProvider for MultiForkByErrorProvider<P, F>
-where
-    P: BufferProvider,
-    F: ForkByErrorPredicate,
-{
-    fn load_buffer(
-        &self,
-        key: DataKey,
-        req: DataRequest,
-    ) -> Result<DataResponse<BufferMarker>, DataError> {
-        let mut last_error = F::UNIT_ERROR.with_key(key);
-        for provider in self.providers.iter() {
-            let result = provider.load_buffer(key, req);
-            match result {
-                Ok(ok) => return Ok(ok),
-                Err(err) if !self.predicate.test(key, Some(req), err) => return Err(err),
-                Err(err) => last_error = err,
-            };
-        }
-        Err(last_error)
-    }
-}
-
 impl<P, F> AnyProvider for MultiForkByErrorProvider<P, F>
 where
     P: AnyProvider,

diff --git a/provider/adapters/src/fork/mod.rs b/provider/adapters/src/fork/mod.rs
@@ -65,8 +65,8 @@ use predicates::MissingDataKeyPredicate;
 /// use icu_provider_adapters::fork::ForkByKeyProvider;
 ///
 /// struct DummyBufferProvider;
-/// impl BufferProvider for DummyBufferProvider {
-///     fn load_buffer(
+/// impl DynamicDataProvider<BufferMarker> for DummyBufferProvider {
+///     fn load_data(
 ///         &self,
 ///         key: DataKey,
 ///         req: DataRequest,

diff --git a/provider/blob/benches/blob_version_bench.rs b/provider/blob/benches/blob_version_bench.rs
@@ -29,7 +29,7 @@ fn blob_version_bench(c: &mut Criterion) {
         b.iter(|| {
             for (locale, key_attributes) in black_box(&locales).iter() {
                 black_box(&provider)
-                    .load_buffer(
+                    .load_data(
                         HelloWorldV1Marker::KEY,
                         DataRequest {
                             locale,
@@ -46,7 +46,7 @@ fn blob_version_bench(c: &mut Criterion) {
         b.iter(|| {
             for (locale, key_attributes) in black_box(&locales).iter() {
                 black_box(&provider)
-                    .load_buffer(
+                    .load_data(
                         HelloWorldV1Marker::KEY,
                         DataRequest {
                             locale,

diff --git a/provider/blob/src/blob_data_provider.rs b/provider/blob/src/blob_data_provider.rs
@@ -119,8 +119,8 @@ impl BlobDataProvider {
     }
 }
 
-impl BufferProvider for BlobDataProvider {
-    fn load_buffer(
+impl DynamicDataProvider<BufferMarker> for BlobDataProvider {
+    fn load_data(
         &self,
         key: DataKey,
         req: DataRequest,
@@ -169,7 +169,7 @@ mod test {
 
             assert!(
                 matches!(
-                    provider.load_buffer(HelloWorldV1Marker::KEY, Default::default()),
+                    provider.load_data(HelloWorldV1Marker::KEY, Default::default()),
                     Err(DataError {
                         kind: DataErrorKind::MissingLocale,
                         ..
@@ -201,7 +201,7 @@ mod test {
 
             assert!(
                 matches!(
-                    provider.load_buffer(
+                    provider.load_data(
                         HelloSingletonV1Marker::KEY,
                         DataRequest {
                             locale: &icu_locale_core::langid!("de").into(),
@@ -218,7 +218,7 @@ mod test {
 
             assert!(
                 matches!(
-                    provider.load_buffer(HelloSingletonV1Marker::KEY, Default::default()),
+                    provider.load_data(HelloSingletonV1Marker::KEY, Default::default()),
                     Err(DataError {
                         kind: DataErrorKind::MissingLocale,
                         ..

diff --git a/provider/blob/src/export/iter.rs b/provider/blob/src/export/iter.rs
@@ -8,16 +8,6 @@ use crate::BlobDataProvider;
 use icu_provider::datagen::*;
 use icu_provider::prelude::*;
 
-impl DynamicDataProvider<BufferMarker> for BlobDataProvider {
-    fn load_data(
-        &self,
-        key: DataKey,
-        req: DataRequest,
-    ) -> Result<DataResponse<BufferMarker>, DataError> {
-        self.load_buffer(key, req)
-    }
-}
-
 impl IterableDynamicDataProvider<BufferMarker> for BlobDataProvider {
     fn supported_requests_for_key(
         &self,

diff --git a/provider/core/src/buf.rs b/provider/core/src/buf.rs
@@ -53,7 +53,7 @@ impl DataMarker for BufferMarker {
 /// assert_eq!(
 ///     serde_json::from_slice::<HelloWorldV1>(
 ///         buffer_provider
-///             .load_buffer(HelloWorldV1Marker::KEY, req)
+///             .load_data(HelloWorldV1Marker::KEY, req)
 ///             .expect("load should succeed")
 ///             .take_payload()
 ///             .unwrap()
@@ -84,59 +84,9 @@ impl DataMarker for BufferMarker {
 /// ```
 ///
 /// [`as_deserializing()`]: AsDeserializingBufferProvider::as_deserializing
-pub trait BufferProvider {
-    /// Loads a [`DataPayload`]`<`[`BufferMarker`]`>` according to the key and request.
-    fn load_buffer(
-        &self,
-        key: DataKey,
-        req: DataRequest,
-    ) -> Result<DataResponse<BufferMarker>, DataError>;
-}
-
-impl<'a, T: BufferProvider + ?Sized> BufferProvider for &'a T {
-    #[inline]
-    fn load_buffer(
-        &self,
-        key: DataKey,
-        req: DataRequest,
-    ) -> Result<DataResponse<BufferMarker>, DataError> {
-        (**self).load_buffer(key, req)
-    }
-}
-
-impl<T: BufferProvider + ?Sized> BufferProvider for alloc::boxed::Box<T> {
-    #[inline]
-    fn load_buffer(
-        &self,
-        key: DataKey,
-        req: DataRequest,
-    ) -> Result<DataResponse<BufferMarker>, DataError> {
-        (**self).load_buffer(key, req)
-    }
-}
-
-impl<T: BufferProvider + ?Sized> BufferProvider for alloc::rc::Rc<T> {
-    #[inline]
-    fn load_buffer(
-        &self,
-        key: DataKey,
-        req: DataRequest,
-    ) -> Result<DataResponse<BufferMarker>, DataError> {
-        (**self).load_buffer(key, req)
-    }
-}
+pub trait BufferProvider: DynamicDataProvider<BufferMarker> {}
 
-#[cfg(target_has_atomic = "ptr")]
-impl<T: BufferProvider + ?Sized> BufferProvider for alloc::sync::Arc<T> {
-    #[inline]
-    fn load_buffer(
-        &self,
-        key: DataKey,
-        req: DataRequest,
-    ) -> Result<DataResponse<BufferMarker>, DataError> {
-        (**self).load_buffer(key, req)
-    }
-}
+impl<P: DynamicDataProvider<BufferMarker> + ?Sized> BufferProvider for P {}
 
 /// An enum expressing all Serde formats known to ICU4X.
 #[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]

diff --git a/provider/core/src/hello_world.rs b/provider/core/src/hello_world.rs
@@ -185,7 +185,7 @@ icu_provider::impl_dynamic_data_provider!(HelloWorldProvider, [HelloWorldV1Marke
 ///
 /// let german_hello_world = HelloWorldProvider
 ///     .into_json_provider()
-///     .load_buffer(HelloWorldV1Marker::KEY, DataRequest {
+///     .load_data(HelloWorldV1Marker::KEY, DataRequest {
 ///         locale: &langid!("de").into(),
 ///         ..Default::default()
 ///     })
@@ -198,8 +198,8 @@ icu_provider::impl_dynamic_data_provider!(HelloWorldProvider, [HelloWorldV1Marke
 pub struct HelloWorldJsonProvider;
 
 #[cfg(feature = "deserialize_json")]
-impl BufferProvider for HelloWorldJsonProvider {
-    fn load_buffer(
+impl DynamicDataProvider<BufferMarker> for HelloWorldJsonProvider {
+    fn load_data(
         &self,
         key: DataKey,
         req: DataRequest,

diff --git a/provider/core/src/serde/mod.rs b/provider/core/src/serde/mod.rs
@@ -165,7 +165,7 @@ where
     /// - `deserialize_postcard_1`
     /// - `deserialize_bincode_1`
     fn load_data(&self, key: DataKey, req: DataRequest) -> Result<DataResponse<M>, DataError> {
-        let buffer_response = BufferProvider::load_buffer(self.0, key, req)?;
+        let buffer_response = self.0.load_data(key, req)?;
         let buffer_format = buffer_response.metadata.buffer_format.ok_or_else(|| {
             DataError::custom("BufferProvider didn't set BufferFormat").with_req(key, req)
         })?;

diff --git a/provider/fs/src/fs_data_provider.rs b/provider/fs/src/fs_data_provider.rs
@@ -62,8 +62,8 @@ impl FsDataProvider {
     }
 }
 
-impl BufferProvider for FsDataProvider {
-    fn load_buffer(
+impl DynamicDataProvider<BufferMarker> for FsDataProvider {
+    fn load_data(
         &self,
         key: DataKey,
         req: DataRequest,