removed AsyncFileReader impl for std::fs::File, added impls for tokio::fs::File

Author: feefladder

Cargo.toml

@@ -25,10 +25,11 @@ weezl = "0.1.0"
 
 [dev-dependencies]
 tiff = "0.9.1"
-tokio = { version = "1.9", features = ["macros", "fs", "rt-multi-thread"] }
+tokio = { version = "1.9", features = ["macros", "fs", "rt-multi-thread", "io-util"] }
 
 [features]
-default = ["object_store", "reqwest"]
+default = ["object_store", "reqwest", "tokio"]
+tokio = ["dep:tokio"]
 reqwest = ["dep:reqwest"]
 object_store = ["dep:object_store"]
 

src/reader.rs

@@ -1,7 +1,7 @@
 //! Abstractions for network reading.
 
 use std::fmt::Debug;
-use std::io::{Read, Seek};
+use std::io::Read;
 use std::ops::Range;
 use std::sync::Arc;
 
@@ -70,44 +70,28 @@ impl AsyncFileReader for Box<dyn AsyncFileReader + '_> {
     }
 }
 
-impl AsyncFileReader for std::fs::File {
+#[cfg(feature = "tokio")]
+impl AsyncFileReader for tokio::fs::File {
     fn get_bytes(&self, range: Range<u64>) -> BoxFuture<'_, AsyncTiffResult<Bytes>> {
+        use tokio::io::{AsyncReadExt, AsyncSeekExt};
+
         async move {
-            let mut file = self.try_clone()?;
-            file.seek(std::io::SeekFrom::Start(range.start))?;
-            let len = (range.end - range.start) as usize;
-            let mut buf = vec![0u8; len];
-            file.read_exact(&mut buf)?;
-            let res = Bytes::copy_from_slice(&buf);
-            Ok(res)
+            let mut file = (*self).try_clone().await?;
+            file.seek(std::io::SeekFrom::Start(range.start)).await?;
+
+            let to_read = (range.end - range.start).try_into().unwrap();
+            let mut buffer = Vec::with_capacity(to_read);
+            let read = file.take(to_read as u64).read_to_end(&mut buffer).await?;
+            if read != to_read {
+                return Err(AsyncTiffError::EndOfFile(to_read, read));
+            }
+
+            Ok(buffer.into())
         }
         .boxed()
     }
 }
 
-// #[cfg(feature = "tokio")]
-// impl<T: tokio::io::AsyncRead + tokio::io::AsyncSeek + Unpin + Debug + Send + Sync> AsyncFileReader
-//     for T
-// {
-//     fn get_bytes(&self, range: Range<u64>) -> BoxFuture<'_, AsyncTiffResult<Bytes>> {
-//         use tokio::io::{AsyncReadExt, AsyncSeekExt};
-
-//         async move {
-//             self.seek(std::io::SeekFrom::Start(range.start)).await?;
-
-//             let to_read = (range.end - range.start).try_into().unwrap();
-//             let mut buffer = Vec::with_capacity(to_read);
-//             let read = self.take(to_read as u64).read_to_end(&mut buffer).await?;
-//             if read != to_read {
-//                 return Err(AsyncTiffError::EndOfFile(to_read, read));
-//             }
-
-//             Ok(buffer.into())
-//         }
-//         .boxed()
-//     }
-// }
-
 /// An AsyncFileReader that reads from an [`ObjectStore`] instance.
 #[cfg(feature = "object_store")]
 #[derive(Clone, Debug)]

tests/image_tiff/util.rs

@@ -1,11 +1,24 @@
+use async_tiff::TIFF;
+use std::sync::Arc;
+
 #[cfg(feature = "object_store")]
 use async_tiff::reader::ObjectReader;
-use async_tiff::TIFF;
 #[cfg(feature = "object_store")]
 use object_store::local::LocalFileSystem;
 #[cfg(feature = "object_store")]
 use std::env::current_dir;
-use std::sync::Arc;
+
+#[cfg(not(any(feature = "tokio", feature = "object_store")))]
+use async_tiff::{
+    error::{AsyncTiffError, AsyncTiffResult},
+    reader::AsyncFileReader,
+};
+#[cfg(not(any(feature = "tokio", feature = "object_store")))]
+use bytes::Bytes;
+#[cfg(not(any(feature = "tokio", feature = "object_store")))]
+use futures::{future::BoxFuture, FutureExt};
+#[cfg(not(any(feature = "tokio", feature = "object_store")))]
+use std::ops::Range;
 
 const TEST_IMAGE_DIR: &str = "tests/image_tiff/images/";
 
@@ -17,10 +30,49 @@ pub(crate) async fn open_tiff(filename: &str) -> TIFF {
     TIFF::try_open(reader).await.unwrap()
 }
 
-#[cfg(not(feature = "object_store"))]
+#[cfg(all(feature = "tokio", not(feature = "object_store")))]
 pub(crate) async fn open_tiff(filename: &str) -> TIFF {
     // let store = Arc::new(LocalFileSystem::new_with_prefix(current_dir().unwrap()).unwrap());
     let path = format!("{TEST_IMAGE_DIR}/{filename}");
-    let reader = Arc::new(std::fs::File::open(path).expect("could not open file"));
+    let reader = Arc::new(
+        tokio::fs::File::open(path)
+            .await
+            .expect("could not open file"),
+    );
+    TIFF::try_open(reader).await.unwrap()
+}
+
+#[cfg(not(any(feature = "tokio", feature = "object_store")))]
+#[derive(Debug)]
+struct TokioFile(tokio::fs::File);
+#[cfg(not(any(feature = "tokio", feature = "object_store")))]
+impl AsyncFileReader for TokioFile {
+    fn get_bytes(&self, range: Range<u64>) -> BoxFuture<'_, AsyncTiffResult<Bytes>> {
+        use tokio::io::{AsyncReadExt, AsyncSeekExt};
+
+        async move {
+            let mut file = self.0.try_clone().await?;
+            file.seek(std::io::SeekFrom::Start(range.start)).await?;
+
+            let to_read = (range.end - range.start).try_into().unwrap();
+            let mut buffer = Vec::with_capacity(to_read);
+            let read = file.take(to_read as u64).read_to_end(&mut buffer).await?;
+            if read != to_read {
+                return Err(AsyncTiffError::EndOfFile(to_read, read));
+            }
+
+            Ok(buffer.into())
+        }
+        .boxed()
+    }
+}
+#[cfg(not(any(feature = "tokio", feature = "object_store")))]
+pub(crate) async fn open_tiff(filename: &str) -> TIFF {
+    let path = format!("{TEST_IMAGE_DIR}/{filename}");
+    let reader = Arc::new(TokioFile(
+        tokio::fs::File::open(path)
+            .await
+            .expect("could not open file"),
+    ));
     TIFF::try_open(reader).await.unwrap()
 }