updated AsyncFileReader trait and impls to not have Send futures in wasm

Author: feefladder

Cargo.toml

@@ -9,6 +9,7 @@ description = "Low-level asynchronous TIFF reader."
 readme = "README.md"
 
 [dependencies]
+async-trait = "0.1.88"
 byteorder = "1"
 bytes = "1.7.0"
 flate2 = "1.0.20"

src/reader.rs

@@ -5,10 +5,11 @@ use std::io::Read;
 use std::ops::Range;
 use std::sync::Arc;
 
+use async_trait::async_trait;
 use byteorder::{BigEndian, LittleEndian, ReadBytesExt};
 use bytes::buf::Reader;
 use bytes::{Buf, Bytes};
-use futures::future::{BoxFuture, FutureExt, TryFutureExt};
+use futures::future::TryFutureExt;
 #[cfg(feature = "object_store")]
 use object_store::ObjectStore;
 
@@ -30,41 +31,36 @@ use crate::error::{AsyncTiffError, AsyncTiffResult};
 /// [`ObjectStore`]: object_store::ObjectStore
 ///
 /// [`tokio::fs::File`]: https://docs.rs/tokio/latest/tokio/fs/struct.File.html
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 pub trait AsyncFileReader: Debug + Send + Sync {
     /// Retrieve the bytes in `range`
-    fn get_bytes(&self, range: Range<u64>) -> BoxFuture<'_, AsyncTiffResult<Bytes>>;
+    async fn get_bytes(&self, range: Range<u64>) -> AsyncTiffResult<Bytes>;
 
     /// Retrieve multiple byte ranges. The default implementation will call `get_bytes`
     /// sequentially
-    fn get_byte_ranges(
-        &self,
-        ranges: Vec<Range<u64>>,
-    ) -> BoxFuture<'_, AsyncTiffResult<Vec<Bytes>>> {
-        async move {
-            let mut result = Vec::with_capacity(ranges.len());
-
-            for range in ranges.into_iter() {
-                let data = self.get_bytes(range).await?;
-                result.push(data);
-            }
+    async fn get_byte_ranges(&self, ranges: Vec<Range<u64>>) -> AsyncTiffResult<Vec<Bytes>> {
+        let mut result = Vec::with_capacity(ranges.len());
 
-            Ok(result)
+        for range in ranges.into_iter() {
+            let data = self.get_bytes(range).await?;
+            result.push(data);
         }
-        .boxed()
+
+        Ok(result)
     }
 }
 
 /// This allows Box<dyn AsyncFileReader + '_> to be used as an AsyncFileReader,
-impl AsyncFileReader for Box<dyn AsyncFileReader + '_> {
-    fn get_bytes(&self, range: Range<u64>) -> BoxFuture<'_, AsyncTiffResult<Bytes>> {
-        self.as_ref().get_bytes(range)
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl AsyncFileReader for Box<dyn AsyncFileReader> {
+    async fn get_bytes(&self, range: Range<u64>) -> AsyncTiffResult<Bytes> {
+        self.get_bytes(range).await
     }
 
-    fn get_byte_ranges(
-        &self,
-        ranges: Vec<Range<u64>>,
-    ) -> BoxFuture<'_, AsyncTiffResult<Vec<Bytes>>> {
-        self.as_ref().get_byte_ranges(ranges)
+    async fn get_byte_ranges(&self, ranges: Vec<Range<u64>>) -> AsyncTiffResult<Vec<Bytes>> {
+        self.get_byte_ranges(ranges).await
     }
 }
 
@@ -108,30 +104,29 @@ impl ObjectReader {
     }
 }
 #[cfg(feature = "object_store")]
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl AsyncFileReader for ObjectReader {
-    fn get_bytes(&self, range: Range<u64>) -> BoxFuture<'_, AsyncTiffResult<Bytes>> {
+    async fn get_bytes(&self, range: Range<u64>) -> AsyncTiffResult<Bytes> {
         let range = range.start as _..range.end as _;
         self.store
             .get_range(&self.path, range)
             .map_err(|e| e.into())
-            .boxed()
+            .await
     }
 
-    fn get_byte_ranges(&self, ranges: Vec<Range<u64>>) -> BoxFuture<'_, AsyncTiffResult<Vec<Bytes>>>
+    async fn get_byte_ranges(&self, ranges: Vec<Range<u64>>) -> AsyncTiffResult<Vec<Bytes>>
     where
         Self: Send,
     {
         let ranges = ranges
             .into_iter()
             .map(|r| r.start as _..r.end as _)
             .collect::<Vec<_>>();
-        async move {
-            self.store
-                .get_ranges(&self.path, &ranges)
-                .await
-                .map_err(|e| e.into())
-        }
-        .boxed()
+        self.store
+            .get_ranges(&self.path, &ranges)
+            .await
+            .map_err(|e| e.into())
     }
 }
 
@@ -150,18 +145,20 @@ impl ReqwestReader {
     }
 }
 #[cfg(feature = "reqwest")]
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl AsyncFileReader for ReqwestReader {
-    fn get_bytes(&self, range: Range<u64>) -> BoxFuture<'_, AsyncTiffResult<Bytes>> {
+    async fn get_bytes(&self, range: Range<u64>) -> AsyncTiffResult<Bytes> {
+        // }
+        // fn get_bytes<'async_trait>(&'async_trait self, range: Range<u64>) -> BoxFuture<'async_trait, AsyncTiffResult<Bytes>>
+        // {
         let url = self.url.clone();
         let client = self.client.clone();
         // HTTP range is inclusive, so we need to subtract 1 from the end
         let range = format!("bytes={}-{}", range.start, range.end - 1);
-        async move {
-            let response = client.get(url).header("Range", range).send().await?;
-            let bytes = response.bytes().await?;
-            Ok(bytes)
-        }
-        .boxed()
+        let response = client.get(url).header("Range", range).send().await?;
+        let bytes = response.bytes().await?;
+        Ok(bytes)
     }
 }
 
@@ -180,29 +177,31 @@ impl PrefetchReader {
     }
 }
 
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl AsyncFileReader for PrefetchReader {
-    fn get_bytes(&self, range: Range<u64>) -> BoxFuture<'_, AsyncTiffResult<Bytes>> {
+    async fn get_bytes(&self, range: Range<u64>) -> AsyncTiffResult<Bytes> {
         if range.start < self.buffer.len() as _ {
             if range.end < self.buffer.len() as _ {
                 let usize_range = range.start as usize..range.end as usize;
                 let result = self.buffer.slice(usize_range);
-                async { Ok(result) }.boxed()
+                Ok(result)
             } else {
                 // TODO: reuse partial internal buffer
-                self.reader.get_bytes(range)
+                self.reader.get_bytes(range).await
             }
         } else {
-            self.reader.get_bytes(range)
+            self.reader.get_bytes(range).await
         }
     }
 
-    fn get_byte_ranges(&self, ranges: Vec<Range<u64>>) -> BoxFuture<'_, AsyncTiffResult<Vec<Bytes>>>
+    async fn get_byte_ranges(&self, ranges: Vec<Range<u64>>) -> AsyncTiffResult<Vec<Bytes>>
     where
         Self: Send,
     {
         // In practice, get_byte_ranges is only used for fetching tiles, which are unlikely to
         // overlap a metadata prefetch.
-        self.reader.get_byte_ranges(ranges)
+        self.reader.get_byte_ranges(ranges).await
     }
 }