Add a general BlockCache.

Avoids needing to stack allocate 512 byte blocks.

Author: thejpster

src/blockdevice.rs

@@ -86,6 +86,78 @@ pub trait BlockDevice {
     fn num_blocks(&self) -> Result<BlockCount, Self::Error>;
 }
 
+/// A caching layer for block devices
+///
+/// Caches a single block.
+#[derive(Debug)]
+pub struct BlockCache<D> {
+    block_device: D,
+    block: [Block; 1],
+    block_idx: Option<BlockIdx>,
+}
+
+impl<D> BlockCache<D>
+where
+    D: BlockDevice,
+{
+    /// Create a new block cache
+    pub fn new(block_device: D) -> BlockCache<D> {
+        BlockCache {
+            block_device,
+            block: [Block::new()],
+            block_idx: None,
+        }
+    }
+
+    /// Read a block, and return a reference to it.
+    pub fn read(&mut self, block_idx: BlockIdx) -> Result<&Block, D::Error> {
+        if self.block_idx != Some(block_idx) {
+            self.block_device.read(&mut self.block, block_idx)?;
+            self.block_idx = Some(block_idx);
+        }
+        Ok(&self.block[0])
+    }
+
+    /// Read a block, and return a reference to it.
+    pub fn read_mut(&mut self, block_idx: BlockIdx) -> Result<&mut Block, D::Error> {
+        if self.block_idx != Some(block_idx) {
+            self.block_device.read(&mut self.block, block_idx)?;
+            self.block_idx = Some(block_idx);
+        }
+        Ok(&mut self.block[0])
+    }
+
+    /// Write back a block you read with [`Self::read_mut`] and then modified.
+    pub fn write_back(&mut self) -> Result<(), D::Error> {
+        self.block_device.write(
+            &self.block,
+            self.block_idx.expect("write_back with no read"),
+        )
+    }
+
+    /// Access a blank sector
+    pub fn blank_mut(&mut self, block_idx: BlockIdx) -> &mut Block {
+        self.block_idx = Some(block_idx);
+        for b in self.block[0].iter_mut() {
+            *b = 0;
+        }
+        &mut self.block[0]
+    }
+
+    /// Access the block device
+    pub fn block_device(&mut self) -> &mut D {
+        // invalidate the cache
+        self.block_idx = None;
+        // give them the block device
+        &mut self.block_device
+    }
+
+    /// Get the block device back
+    pub fn free(self) -> D {
+        self.block_device
+    }
+}
+
 /// The linear numeric address of a block (or sector).
 ///
 /// The first block on a disk gets `BlockIdx(0)` (which usually contains the

src/fat/mod.rs

@@ -14,35 +14,6 @@ pub enum FatType {
     Fat32,
 }
 
-pub(crate) struct BlockCache {
-    block: Block,
-    idx: Option<BlockIdx>,
-}
-impl BlockCache {
-    pub fn empty() -> Self {
-        BlockCache {
-            block: Block::new(),
-            idx: None,
-        }
-    }
-    pub(crate) fn read<D>(
-        &mut self,
-        block_device: &D,
-        block_idx: BlockIdx,
-    ) -> Result<&Block, Error<D::Error>>
-    where
-        D: BlockDevice,
-    {
-        if Some(block_idx) != self.idx {
-            self.idx = Some(block_idx);
-            block_device
-                .read(core::slice::from_mut(&mut self.block), block_idx)
-                .map_err(Error::DeviceError)?;
-        }
-        Ok(&self.block)
-    }
-}
-
 mod bpb;
 mod info;
 mod ondiskdirentry;
@@ -53,8 +24,6 @@ pub use info::{Fat16Info, Fat32Info, FatSpecificInfo, InfoSector};
 pub use ondiskdirentry::OnDiskDirEntry;
 pub use volume::{parse_volume, FatVolume, VolumeName};
 
-use crate::{Block, BlockDevice, BlockIdx, Error};
-
 // ****************************************************************************
 //
 // Unit Tests