Re-organise the blockdevice.rs file.

Author: thejpster

src/blockdevice.rs

@@ -16,40 +16,6 @@ pub struct Block {
     pub contents: [u8; Block::LEN],
 }
 
-/// The linear numeric address of a block (or sector).
-///
-/// The first block on a disk gets `BlockIdx(0)` (which usually contains the
-/// Master Boot Record).
-#[cfg_attr(feature = "defmt-log", derive(defmt::Format))]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct BlockIdx(pub u32);
-
-/// The a number of blocks (or sectors).
-///
-/// Add this to a `BlockIdx` to get an actual address on disk.
-#[cfg_attr(feature = "defmt-log", derive(defmt::Format))]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct BlockCount(pub u32);
-
-/// An iterator returned from `Block::range`.
-pub struct BlockIter {
-    inclusive_end: BlockIdx,
-    current: BlockIdx,
-}
-
-/// A block device - a device which can read and write blocks (or
-/// sectors). Only supports devices which are <= 2 TiB in size.
-pub trait BlockDevice {
-    /// The errors that the `BlockDevice` can return. Must be debug formattable.
-    type Error: core::fmt::Debug;
-    /// Read one or more blocks, starting at the given block index.
-    fn read(&self, blocks: &mut [Block], start_block_idx: BlockIdx) -> Result<(), Self::Error>;
-    /// Write one or more blocks, starting at the given block index.
-    fn write(&self, blocks: &[Block], start_block_idx: BlockIdx) -> Result<(), Self::Error>;
-    /// Determine how many blocks this device can hold.
-    fn num_blocks(&self) -> Result<BlockCount, Self::Error>;
-}
-
 impl Block {
     /// All our blocks are a fixed length of 512 bytes. We do not support
     /// 'Advanced Format' Hard Drives with 4 KiB blocks, nor weird old
@@ -67,64 +33,6 @@ impl Block {
     }
 }
 
-impl Default for Block {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl core::ops::Add<BlockCount> for BlockIdx {
-    type Output = BlockIdx;
-    fn add(self, rhs: BlockCount) -> BlockIdx {
-        BlockIdx(self.0 + rhs.0)
-    }
-}
-
-impl core::ops::AddAssign<BlockCount> for BlockIdx {
-    fn add_assign(&mut self, rhs: BlockCount) {
-        self.0 += rhs.0
-    }
-}
-
-impl core::ops::Add<BlockCount> for BlockCount {
-    type Output = BlockCount;
-    fn add(self, rhs: BlockCount) -> BlockCount {
-        BlockCount(self.0 + rhs.0)
-    }
-}
-
-impl core::ops::AddAssign<BlockCount> for BlockCount {
-    fn add_assign(&mut self, rhs: BlockCount) {
-        self.0 += rhs.0
-    }
-}
-
-impl core::ops::Sub<BlockCount> for BlockIdx {
-    type Output = BlockIdx;
-    fn sub(self, rhs: BlockCount) -> BlockIdx {
-        BlockIdx(self.0 - rhs.0)
-    }
-}
-
-impl core::ops::SubAssign<BlockCount> for BlockIdx {
-    fn sub_assign(&mut self, rhs: BlockCount) {
-        self.0 -= rhs.0
-    }
-}
-
-impl core::ops::Sub<BlockCount> for BlockCount {
-    type Output = BlockCount;
-    fn sub(self, rhs: BlockCount) -> BlockCount {
-        BlockCount(self.0 - rhs.0)
-    }
-}
-
-impl core::ops::SubAssign<BlockCount> for BlockCount {
-    fn sub_assign(&mut self, rhs: BlockCount) {
-        self.0 -= rhs.0
-    }
-}
-
 impl core::ops::Deref for Block {
     type Target = [u8; 512];
     fn deref(&self) -> &[u8; 512] {
@@ -159,6 +67,33 @@ impl core::fmt::Debug for Block {
     }
 }
 
+impl Default for Block {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// A block device - a device which can read and write blocks (or
+/// sectors). Only supports devices which are <= 2 TiB in size.
+pub trait BlockDevice {
+    /// The errors that the `BlockDevice` can return. Must be debug formattable.
+    type Error: core::fmt::Debug;
+    /// Read one or more blocks, starting at the given block index.
+    fn read(&self, blocks: &mut [Block], start_block_idx: BlockIdx) -> Result<(), Self::Error>;
+    /// Write one or more blocks, starting at the given block index.
+    fn write(&self, blocks: &[Block], start_block_idx: BlockIdx) -> Result<(), Self::Error>;
+    /// Determine how many blocks this device can hold.
+    fn num_blocks(&self) -> Result<BlockCount, Self::Error>;
+}
+
+/// The linear numeric address of a block (or sector).
+///
+/// The first block on a disk gets `BlockIdx(0)` (which usually contains the
+/// Master Boot Record).
+#[cfg_attr(feature = "defmt-log", derive(defmt::Format))]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct BlockIdx(pub u32);
+
 impl BlockIdx {
     /// Convert a block index into a 64-bit byte offset from the start of the
     /// volume. Useful if your underlying block device actually works in
@@ -174,6 +109,65 @@ impl BlockIdx {
     }
 }
 
+impl core::ops::Add<BlockCount> for BlockIdx {
+    type Output = BlockIdx;
+    fn add(self, rhs: BlockCount) -> BlockIdx {
+        BlockIdx(self.0 + rhs.0)
+    }
+}
+
+impl core::ops::AddAssign<BlockCount> for BlockIdx {
+    fn add_assign(&mut self, rhs: BlockCount) {
+        self.0 += rhs.0
+    }
+}
+
+impl core::ops::Sub<BlockCount> for BlockIdx {
+    type Output = BlockIdx;
+    fn sub(self, rhs: BlockCount) -> BlockIdx {
+        BlockIdx(self.0 - rhs.0)
+    }
+}
+
+impl core::ops::SubAssign<BlockCount> for BlockIdx {
+    fn sub_assign(&mut self, rhs: BlockCount) {
+        self.0 -= rhs.0
+    }
+}
+
+/// The a number of blocks (or sectors).
+///
+/// Add this to a `BlockIdx` to get an actual address on disk.
+#[cfg_attr(feature = "defmt-log", derive(defmt::Format))]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct BlockCount(pub u32);
+
+impl core::ops::Add<BlockCount> for BlockCount {
+    type Output = BlockCount;
+    fn add(self, rhs: BlockCount) -> BlockCount {
+        BlockCount(self.0 + rhs.0)
+    }
+}
+
+impl core::ops::AddAssign<BlockCount> for BlockCount {
+    fn add_assign(&mut self, rhs: BlockCount) {
+        self.0 += rhs.0
+    }
+}
+
+impl core::ops::Sub<BlockCount> for BlockCount {
+    type Output = BlockCount;
+    fn sub(self, rhs: BlockCount) -> BlockCount {
+        BlockCount(self.0 - rhs.0)
+    }
+}
+
+impl core::ops::SubAssign<BlockCount> for BlockCount {
+    fn sub_assign(&mut self, rhs: BlockCount) {
+        self.0 -= rhs.0
+    }
+}
+
 impl BlockCount {
     /// How many blocks are required to hold this many bytes.
     ///
@@ -200,6 +194,12 @@ impl BlockCount {
     }
 }
 
+/// An iterator returned from `Block::range`.
+pub struct BlockIter {
+    inclusive_end: BlockIdx,
+    current: BlockIdx,
+}
+
 impl BlockIter {
     /// Create a new `BlockIter`, from the given start block, through (and
     /// including) the given end block.