Separate out prefetching to a trait and brings back regular Iterator/Stream for Generator.

Author: zbraniecki

fluent-fallback/examples/simple-fallback.rs

@@ -22,7 +22,7 @@ use std::{env, fs, io, path::PathBuf, str::FromStr};
 
 use fluent_bundle::{FluentArgs, FluentBundle, FluentResource, FluentValue};
 use fluent_fallback::{
-    generator::{BundleGenerator, BundleIterator, BundleStream, FluentBundleResult},
+    generator::{BundleGenerator, FluentBundleResult},
     Localization,
 };
 use fluent_langneg::{negotiate_languages, NegotiationStrategy};
@@ -178,8 +178,6 @@ struct BundleIter {
     res_ids: Vec<String>,
 }
 
-impl BundleIterator<FluentResource> for BundleIter {}
-
 impl Iterator for BundleIter {
     type Item = FluentBundleResult<FluentResource>;
 
@@ -214,8 +212,6 @@ impl Iterator for BundleIter {
     }
 }
 
-impl BundleStream<FluentResource> for BundleIter {}
-
 impl futures::Stream for BundleIter {
     type Item = FluentBundleResult<FluentResource>;
 

fluent-fallback/src/cache.rs

@@ -6,14 +6,14 @@ use std::{
     task::Poll,
 };
 
-use crate::generator::{BundleIterator, BundleStream};
+use crate::generator::BundleIterator;
 use chunky_vec::ChunkyVec;
 use futures::{ready, Stream};
 use pin_cell::{PinCell, PinMut};
 
 pub struct Cache<I, R>
 where
-    I: BundleIterator<R>,
+    I: Iterator,
 {
     iter: RefCell<I>,
     items: UnsafeCell<ChunkyVec<I::Item>>,
@@ -22,7 +22,7 @@ where
 
 impl<I, R> Cache<I, R>
 where
-    I: BundleIterator<R>,
+    I: Iterator,
 {
     pub fn new(iter: I) -> Self {
         Self {
@@ -53,23 +53,28 @@ where
             (*items).push_get(new_value)
         }
     }
+}
 
+impl<I, R> Cache<I, R>
+where
+    I: BundleIterator + Iterator,
+{
     pub fn prefetch(&self) {
         self.iter.borrow_mut().prefetch();
     }
 }
 
 pub struct CacheIter<'a, I, R>
 where
-    I: BundleIterator<R>,
+    I: Iterator,
 {
     cache: &'a Cache<I, R>,
     curr: usize,
 }
 
 impl<'a, I, R> Iterator for CacheIter<'a, I, R>
 where
-    I: BundleIterator<R>,
+    I: Iterator,
 {
     type Item = &'a I::Item;
 
@@ -101,7 +106,7 @@ where
 
 impl<'a, I, R> IntoIterator for &'a Cache<I, R>
 where
-    I: BundleIterator<R>,
+    I: Iterator,
 {
     type Item = &'a I::Item;
     type IntoIter = CacheIter<'a, I, R>;
@@ -118,7 +123,7 @@ where
 
 pub struct AsyncCache<S, R>
 where
-    S: BundleStream<R>,
+    S: Stream,
 {
     stream: PinCell<S>,
     items: UnsafeCell<ChunkyVec<S::Item>>,
@@ -127,7 +132,7 @@ where
 
 impl<S, R> AsyncCache<S, R>
 where
-    S: BundleStream<R>,
+    S: Stream,
 {
     pub fn new(stream: S) -> Self {
         Self {
@@ -165,7 +170,12 @@ where
             curr: 0,
         }
     }
+}
 
+impl<S, R> AsyncCache<S, R>
+where
+    S: BundleIterator + Stream,
+{
     pub fn prefetch(&self) {
         let pin = unsafe { Pin::new_unchecked(&self.stream) };
         unsafe { PinMut::as_mut(&mut pin.borrow_mut()).get_unchecked_mut() }.prefetch();
@@ -174,7 +184,7 @@ where
 
 impl<S, R> AsyncCache<S, R>
 where
-    S: BundleStream<R>,
+    S: Stream,
 {
     // Helper function that gets the next value from wrapped stream.
     fn poll_next_item(&self, cx: &mut Context<'_>) -> Poll<Option<S::Item>> {
@@ -185,15 +195,15 @@ where
 
 pub struct AsyncCacheStream<'a, S, R>
 where
-    S: BundleStream<R>,
+    S: Stream,
 {
     cache: &'a AsyncCache<S, R>,
     curr: usize,
 }
 
 impl<'a, S, R> Stream for AsyncCacheStream<'a, S, R>
 where
-    S: BundleStream<R>,
+    S: Stream,
 {
     type Item = &'a S::Item;
 

fluent-fallback/src/generator.rs

@@ -4,18 +4,14 @@ use std::borrow::Borrow;
 
 pub type FluentBundleResult<R> = Result<FluentBundle<R>, (FluentBundle<R>, Vec<FluentError>)>;
 
-pub trait BundleIterator<R>: Iterator<Item = FluentBundleResult<R>> {
-    fn prefetch(&mut self) {}
-}
-
-pub trait BundleStream<R>: Stream<Item = FluentBundleResult<R>> {
+pub trait BundleIterator {
     fn prefetch(&mut self) {}
 }
 
 pub trait BundleGenerator {
     type Resource: Borrow<FluentResource>;
-    type Iter: BundleIterator<Self::Resource>;
-    type Stream: BundleStream<Self::Resource>;
+    type Iter: Iterator<Item = FluentBundleResult<Self::Resource>>;
+    type Stream: Stream<Item = FluentBundleResult<Self::Resource>>;
 
     // Can we make it a slice?
     fn bundles_iter(&self, res_ids: Vec<String>) -> Self::Iter;

fluent-fallback/src/localization.rs

@@ -1,6 +1,6 @@
 use crate::cache::{AsyncCache, Cache};
 use crate::errors::LocalizationError;
-use crate::generator::BundleGenerator;
+use crate::generator::{BundleGenerator, BundleIterator};
 use crate::types::{L10nAttribute, L10nKey, L10nMessage};
 use fluent_bundle::{FluentArgs, FluentBundle, FluentError};
 use once_cell::sync::OnceCell;
@@ -17,6 +17,8 @@ where
 impl<G> Bundles<G>
 where
     G: BundleGenerator,
+    G::Iter: BundleIterator,
+    G::Stream: BundleIterator,
 {
     fn prefetch(&self) {
         match self {
@@ -83,11 +85,6 @@ where
         self.res_ids.len()
     }
 
-    pub fn prefetch(&self) {
-        let bundles = self.get_bundles();
-        bundles.prefetch();
-    }
-
     pub fn set_async(&mut self) {
         if self.sync {
             self.bundles.take();
@@ -172,6 +169,18 @@ where
     }
 }
 
+impl<G> Localization<G>
+where
+    G: BundleGenerator,
+    G::Iter: BundleIterator,
+    G::Stream: BundleIterator,
+{
+    pub fn prefetch(&self) {
+        let bundles = self.get_bundles();
+        bundles.prefetch();
+    }
+}
+
 impl<G> Localization<G>
 where
     G: BundleGenerator,

fluent-fallback/tests/localization_test.rs

@@ -3,7 +3,7 @@ use std::fs;
 
 use fluent_bundle::{FluentBundle, FluentResource};
 use fluent_fallback::{
-    generator::{BundleGenerator, BundleIterator, BundleStream, FluentBundleResult},
+    generator::{BundleGenerator, FluentBundleResult},
     Localization,
 };
 use std::cell::RefCell;
@@ -46,8 +46,6 @@ struct BundleIter {
     res_ids: Vec<String>,
 }
 
-impl BundleIterator<FluentResource> for BundleIter {}
-
 impl Iterator for BundleIter {
     type Item = FluentBundleResult<FluentResource>;
 
@@ -78,8 +76,6 @@ impl Iterator for BundleIter {
     }
 }
 
-impl BundleStream<FluentResource> for BundleIter {}
-
 impl futures::Stream for BundleIter {
     type Item = FluentBundleResult<FluentResource>;
 

fluent-resmgr/src/resource_manager.rs

@@ -1,8 +1,6 @@
 use elsa::FrozenMap;
 use fluent_bundle::{FluentBundle, FluentResource};
-use fluent_fallback::generator::{
-    BundleGenerator, BundleIterator, BundleStream, FluentBundleResult,
-};
+use fluent_fallback::generator::{BundleGenerator, FluentBundleResult};
 use futures::stream::Stream;
 use std::fs;
 use std::io;
@@ -85,9 +83,6 @@ pub struct BundleIter {
     resource_ids: Vec<String>,
 }
 
-impl BundleIterator<FluentResource> for BundleIter {
-}
-
 impl Iterator for BundleIter {
     type Item = FluentBundleResult<FluentResource>;
 
@@ -106,9 +101,6 @@ impl Iterator for BundleIter {
     }
 }
 
-impl BundleStream<FluentResource> for BundleIter {
-}
-
 impl Stream for BundleIter {
     type Item = FluentBundleResult<FluentResource>;
 

fluent-resmgr/tests/localization_test.rs

@@ -1,7 +1,7 @@
 use fluent_fallback::Localization;
 use fluent_resmgr::resource_manager::ResourceManager;
-use unic_langid::langid;
 use std::borrow::Cow;
+use unic_langid::langid;
 
 #[test]
 fn localization_format_value() {