made cachereader

Author: feefladder

src/reader.rs

@@ -207,6 +207,63 @@ impl AsyncFileReader for PrefetchReader {
     }
 }
 
+
+/// reader that holds a cache. Because of interior mutability, it will always
+/// lock the cache (twice) for each get_bytes. This also special-cases
+/// get_tile_bytes
+/// When doing metadata fetches, it will fetch twice the requested size for the cache
+///
+#[derive(Debug)]
+pub struct CacheReader {
+    reader: Arc<dyn AsyncFileReader>,
+    cache: Arc<Mutex<(Range<u64>, Bytes)>>, // not sure if this should be an async_mutex on wasm-like environments to prevent blocking the main thread
+}
+
+impl CacheReader {
+    /// creates a ew cachereader with empty cache
+    pub fn new(reader: Arc<dyn AsyncFileReader>) -> Self {
+        Self {
+            reader,
+            cache: Arc::new(Mutex::new((0..0, Bytes::new()))),
+        }
+    }
+}
+
+impl AsyncFileReader for CacheReader {
+    fn get_bytes(&self, range: Range<u64>) -> BoxFuture<'_, AsyncTiffResult<Bytes>> {
+        {
+            let lock = self.cache.lock().unwrap_or_else(|e| e.into_inner());
+            // check for cache
+            if range.start >= lock.0.start /*&& range.start < lock.0.end*/ && range.end <= lock.0.end
+            {
+                let usize_range =
+                    (range.start - lock.0.start) as usize..(range.end - lock.0.start) as usize;
+                let result = lock.1.slice(usize_range);
+                return async { Ok(result) }.boxed();
+            } else {
+                println!("range {:?} doesn't contain {range:?}", lock.0);
+            }
+        }
+        async move {
+            let range_len = range.end - range.start;
+            // this is based on a geometric series, since each overview is 1/2
+            // the size, the n of tiles (~area) of the next overview is 1/4
+            // however, due to the edges, this underestimates, and we'd rather
+            // over-estimate I think?
+            // So we add the edge of the next overview as well, which would give
+            // 1.5*isqrt, so we round up.
+            let full_len = 2 * range_len + 2 * range_len.isqrt();
+            let new_range = range.start..range.start + full_len;
+            println!("range {range:?} requested, fetching {new_range:?}");
+            let res = self.reader.get_bytes(new_range.clone()).await?;
+            let mut lock = self.cache.lock().unwrap_or_else(|e| e.into_inner());
+            *lock = (new_range, res.clone());
+            Ok(res.slice(0..(range.end - range.start) as usize))
+        }
+        .boxed()
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 pub(crate) enum Endianness {
     LittleEndian,