Struct PartitionDevice 

pub struct PartitionDevice<'a, D> { /* private fields */ }

A device implementation that represents a partition within a larger storage device.

This type wraps a base device and provides access to only a specific region (partition) of that device. It maintains its own position cursor and ensures all operations stay within the partition boundaries. This allows file systems to operate on individual partitions without needing to know about the partition layout.

Note: The partition device does not manage position state internally and does not use atomic operations. Thread safety depends on the underlying base device implementation.

Examples

// Create a memory device for testing
let base_device = MemoryDevice::<512>::new(1024 * 1024);

// Create a partition device for blocks 100-199 (100 blocks of 512 bytes = 51.2KB)
let partition_device = PartitionDevice::new(&base_device, 100, 100, 512);

// Now you can use partition_device like any other device
let data = b"Hello, Partition!";
partition_device.write(data, 0).unwrap();

Implementations

impl<'a, D: BaseOperations> PartitionDevice<'a, D>

pub fn new( base_device: &'a D, start_block: Size, block_count: Size, block_size: u32, ) -> Self

Create a new partition device with explicit byte offset and size.

Arguments

• base_device - The underlying storage device
• start_block - Block index where the partition starts
• block_count - Number of blocks in the partition
• block_size - Size of each block in bytes

Examples

let base_device = MemoryDevice::<512>::new(1024 * 1024);
// Create a partition starting at block 128 (64KB) with 256 blocks (128KB)
let partition = PartitionDevice::new(&base_device, 128, 256, 512);

pub const fn get_block_count(&self) -> u32

Get the number of blocks in this partition.

Returns

The number of blocks in this partition, where each block is of the partition’s configured block size. The number of 512-byte sectors this partition contains.

Examples

let base_device = MemoryDevice::<512>::new(1024 * 1024);
let partition = PartitionDevice::new(&base_device, 100, 50, 512);
assert_eq!(partition.get_block_count(), 50);

pub const fn get_start_lba(&self) -> Size

pub const fn get_base_device(&self) -> &D

Get the base device

pub const fn is_valid(&self) -> bool

Check if the partition device is valid (non-zero size)

Trait Implementations

impl<'a, D> Debug for PartitionDevice<'a, D>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, D: DirectBaseOperations> DirectBaseOperations for PartitionDevice<'a, D>

fn read(&self, buffer: &mut [u8], absolute_position: Size) -> Result<usize>

fn write(&self, buffer: &[u8], absolute_position: Size) -> Result<usize>

fn write_pattern( &self, pattern: &[u8], count: usize, absolute_position: Size, ) -> Result<usize>

fn set_position( &self, current_position: Size, position: &Position, ) -> Result<Size>

fn flush(&self) -> Result<()>

fn control( &self, command: ControlCommandIdentifier, input: &AnyByLayout, output: &mut AnyByLayout, ) -> Result<()>

fn open(&self) -> Result<()>

fn close(&self) -> Result<()>

fn read_until( &self, buffer: &mut [u8], absolute_position: Size, delimiter: &[u8], ) -> Result<usize>

fn write_vectored( &self, buffers: &[&[u8]], absolute_position: Size, ) -> Result<usize>

impl<'a, D: DirectBlockDevice> DirectBlockDevice for PartitionDevice<'a, D>

fn get_block_size(&self) -> Result<u32>

fn get_block_count(&self) -> Result<Size>

impl<'a, D: MountOperations> MountOperations for PartitionDevice<'a, D>

fn mount(&self) -> Result<()>

fn unmount(&self) -> Result<()>