Separate prefetch to sync and async

Author: zbraniecki

fluent-fallback/Cargo.toml

@@ -23,6 +23,7 @@ fluent-bundle = { version = "0.14", path = "../fluent-bundle" }
 futures = "0.3"
 pin-cell = { git = "https://github.com/withoutboats/pin-cell", rev = "4d5803d83c6b3bffd62c9e73a0ceaf5ec6f01495" }
 once_cell = "1.5"
+async-trait = "0.1"
 
 [dev-dependencies]
 fluent-langneg = "0.13"

fluent-fallback/src/cache.rs

@@ -6,7 +6,7 @@ use std::{
     task::Poll,
 };
 
-use crate::generator::BundleIterator;
+use crate::generator::{BundleIterator, BundleStream};
 use chunky_vec::ChunkyVec;
 use futures::{ready, Stream};
 use pin_cell::{PinCell, PinMut};
@@ -60,7 +60,7 @@ where
     I: BundleIterator + Iterator,
 {
     pub fn prefetch(&self) {
-        self.iter.borrow_mut().prefetch();
+        self.iter.borrow_mut().prefetch_sync();
     }
 }
 
@@ -174,11 +174,13 @@ where
 
 impl<S, R> AsyncCache<S, R>
 where
-    S: BundleIterator + Stream,
+    S: BundleStream + Stream,
 {
-    pub fn prefetch(&self) {
+    pub async fn prefetch(&self) {
         let pin = unsafe { Pin::new_unchecked(&self.stream) };
-        unsafe { PinMut::as_mut(&mut pin.borrow_mut()).get_unchecked_mut() }.prefetch();
+        unsafe { PinMut::as_mut(&mut pin.borrow_mut()).get_unchecked_mut() }
+            .prefetch_async()
+            .await
     }
 }
 

fluent-fallback/src/generator.rs

@@ -5,7 +5,12 @@ use std::borrow::Borrow;
 pub type FluentBundleResult<R> = Result<FluentBundle<R>, (FluentBundle<R>, Vec<FluentError>)>;
 
 pub trait BundleIterator {
-    fn prefetch(&mut self) {}
+    fn prefetch_sync(&mut self) {}
+}
+
+#[async_trait::async_trait(?Send)]
+pub trait BundleStream {
+    async fn prefetch_async(&mut self) {}
 }
 
 pub trait BundleGenerator {

fluent-fallback/src/localization.rs

@@ -1,6 +1,6 @@
 use crate::cache::{AsyncCache, Cache};
 use crate::errors::LocalizationError;
-use crate::generator::{BundleGenerator, BundleIterator};
+use crate::generator::{BundleGenerator, BundleIterator, BundleStream};
 use crate::types::{L10nAttribute, L10nKey, L10nMessage};
 use fluent_bundle::{FluentArgs, FluentBundle, FluentError};
 use once_cell::sync::OnceCell;
@@ -18,12 +18,26 @@ impl<G> Bundles<G>
 where
     G: BundleGenerator,
     G::Iter: BundleIterator,
-    G::Stream: BundleIterator,
 {
-    fn prefetch(&self) {
+    fn prefetch_sync(&self) {
         match self {
             Self::Iter(iter) => iter.prefetch(),
-            Self::Stream(stream) => stream.prefetch(),
+            Self::Stream(_) => todo!(),
+        }
+    }
+}
+
+impl<G> Bundles<G>
+where
+    G: BundleGenerator,
+    G::Stream: BundleStream,
+{
+    async fn prefetch_async(&self) {
+        match self {
+            Self::Iter(_) => {
+                todo!();
+            }
+            Self::Stream(stream) => stream.prefetch().await,
         }
     }
 }
@@ -173,11 +187,21 @@ impl<G> Localization<G>
 where
     G: BundleGenerator,
     G::Iter: BundleIterator,
-    G::Stream: BundleIterator,
 {
-    pub fn prefetch(&self) {
+    pub fn prefetch_sync(&self) {
+        let bundles = self.get_bundles();
+        bundles.prefetch_sync();
+    }
+}
+
+impl<G> Localization<G>
+where
+    G: BundleGenerator,
+    G::Stream: BundleStream,
+{
+    pub async fn prefetch_async(&self) {
         let bundles = self.get_bundles();
-        bundles.prefetch();
+        bundles.prefetch_async().await
     }
 }