Rename to PrefetchBuffer

Author: kylebarron

python/src/tiff.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use async_tiff::metadata::{PrefetchMetadataFetch, TiffMetadataReader};
+use async_tiff::metadata::{PrefetchBuffer, TiffMetadataReader};
 use async_tiff::reader::AsyncFileReader;
 use async_tiff::TIFF;
 use pyo3::exceptions::PyIndexError;
@@ -32,9 +32,7 @@ impl PyTIFF {
         let reader = store.into_async_file_reader(path);
 
         let cog_reader = future_into_py(py, async move {
-            let metadata_fetch = PrefetchMetadataFetch::new(reader.clone(), prefetch)
-                .await
-                .unwrap();
+            let metadata_fetch = PrefetchBuffer::new(reader.clone(), prefetch).await.unwrap();
             let mut metadata_reader = TiffMetadataReader::try_open(&metadata_fetch).await.unwrap();
             let ifds = metadata_reader
                 .read_all_ifds(&metadata_fetch)

src/cog.rs

@@ -24,7 +24,7 @@ mod test {
     use std::sync::Arc;
 
     use crate::decoder::DecoderRegistry;
-    use crate::metadata::{PrefetchMetadataFetch, TiffMetadataReader};
+    use crate::metadata::{PrefetchBuffer, TiffMetadataReader};
     use crate::reader::{AsyncFileReader, ObjectReader};
 
     use super::*;
@@ -38,7 +38,7 @@ mod test {
         let path = object_store::path::Path::parse("m_4007307_sw_18_060_20220803.tif").unwrap();
         let store = Arc::new(LocalFileSystem::new_with_prefix(folder).unwrap());
         let reader = Arc::new(ObjectReader::new(store, path)) as Arc<dyn AsyncFileReader>;
-        let prefetch_reader = PrefetchMetadataFetch::new(reader.clone(), 32 * 1024)
+        let prefetch_reader = PrefetchBuffer::new(reader.clone(), 32 * 1024)
             .await
             .unwrap();
         let mut metadata_reader = TiffMetadataReader::try_open(&prefetch_reader)

src/metadata/fetch.rs

@@ -25,22 +25,25 @@ impl<T: AsyncFileReader> MetadataFetch for T {
     }
 }
 
-/// A [`MetadataFetch`] that caches the first `prefetch` bytes of a file.
+/// Buffering for the first `N` bytes of a file.
+///
+/// This is designed so that the async requests made by the underlying tag reader get intercepted
+/// here and served from the existing buffer when possible.
 #[derive(Debug)]
-pub struct PrefetchMetadataFetch<F: MetadataFetch> {
+pub struct PrefetchBuffer<F: MetadataFetch> {
     fetch: F,
     buffer: Bytes,
 }
 
-impl<F: MetadataFetch> PrefetchMetadataFetch<F> {
-    /// Construct a new PrefetchMetadataFetch, catching the first `prefetch` bytes of the file.
+impl<F: MetadataFetch> PrefetchBuffer<F> {
+    /// Construct a new PrefetchBuffer, catching the first `prefetch` bytes of the file.
     pub async fn new(fetch: F, prefetch: u64) -> AsyncTiffResult<Self> {
         let buffer = fetch.fetch(0..prefetch).await?;
         Ok(Self { fetch, buffer })
     }
 }
 
-impl<F: MetadataFetch> MetadataFetch for PrefetchMetadataFetch<F> {
+impl<F: MetadataFetch> MetadataFetch for PrefetchBuffer<F> {
     fn fetch(&self, range: Range<u64>) -> BoxFuture<'_, AsyncTiffResult<Bytes>> {
         if range.start < self.buffer.len() as _ {
             if range.end < self.buffer.len() as _ {

src/metadata/mod.rs

@@ -10,7 +10,7 @@
 //!
 //! use object_store::local::LocalFileSystem;
 //!
-//! use async_tiff::metadata::{PrefetchMetadataFetch, TiffMetadataReader};
+//! use async_tiff::metadata::{PrefetchBuffer, TiffMetadataReader};
 //! use async_tiff::reader::ObjectReader;
 //!
 //! // Create new Arc<dyn ObjectStore>
@@ -22,13 +22,13 @@
 //!     "tests/image_tiff/images/tiled-jpeg-rgb-u8.tif".into(),
 //! );
 //!
-//! // Use PrefetchMetadataFetch to ensure that a given number of bytes at the start of the
+//! // Use PrefetchBuffer to ensure that a given number of bytes at the start of the
 //! // file are prefetched.
 //! //
 //! // This or a similar caching layer should **always** be used and ensures that the
 //! // underlying read calls that the TiffMetadataReader makes don't translate to actual
 //! // network fetches.
-//! let prefetch_reader = PrefetchMetadataFetch::new(reader.clone(), 32 * 1024)
+//! let prefetch_reader = PrefetchBuffer::new(reader.clone(), 32 * 1024)
 //!     .await
 //!     .unwrap();
 //!
@@ -52,12 +52,12 @@
 //! [`MetadataFetch`] implementation.
 //!
 //! Thus, it is **imperative to always supply some sort of caching, prefetching, or buffering**
-//! middleware when reading metadata. [`PrefetchMetadataFetch`] is an example of this, which
+//! middleware when reading metadata. [`PrefetchBuffer`] is an example of this, which
 //! fetches the first `N` bytes out of a file.
 //!
 
 mod fetch;
 mod reader;
 
-pub use fetch::{MetadataFetch, PrefetchMetadataFetch};
+pub use fetch::{MetadataFetch, PrefetchBuffer};
 pub use reader::{ImageFileDirectoryReader, TiffMetadataReader};