Struct MmapWriter 

pub struct MmapWriter { /* private fields */ }

Memory-mapped MRC writer (requires mmap feature). Memory-mapped MRC file writer.

Writes data directly into a memory-mapped region, letting the OS handle paging and flushing. This is efficient for large files and random-access modifications, but requires the mmap feature.

Example

use mrc::{create, VoxelBlock};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut writer = create("output.mrc")
        .shape([512, 512, 256])
        .mode::<f32>()
        .finish_mmap()?;

    writer.write_block(&VoxelBlock::new(
        [0, 0, 0], [512, 512, 1],
        vec![0.0f32; 512 * 512],
    )?)?;
    Ok(())
}

For most use cases, prefer creating via WriterBuilder::finish_mmap.

Implementations

impl MmapWriter

pub fn shape(&self) -> VolumeShape

Volume dimensions for this writer.

pub fn mode(&self) -> Mode

Voxel data mode for this writer.

Falls back to Mode::Float32 if the header mode value is not recognised.

pub fn header(&self) -> &Header

Reference to the current header.

Modify header fields before calling finalize to change what gets written to disk.

pub fn write_u8_block(&mut self, block: &VoxelBlock<u8>) -> Result<(), Error>

Write a block of u8 data by automatically widening to u16 (Mode 6).

The file must have been created with Mode::Uint16. Each u8 voxel is widened to u16 before writing, matching Python mrcfile’s auto-conversion behaviour for np.uint8 data.

Errors

Returns Error::ModeMismatch if the file mode is not Uint16.

pub fn write_block<T: Voxel>( &mut self, block: &VoxelBlock<T>, ) -> Result<(), Error>

Write a block of voxels to the memory-mapped file.

The type T must match the file’s voxel mode exactly. Supports arbitrary sub-blocks by scattering row-by-row when necessary.

pub fn write_block_parallel<T: Voxel>( &mut self, block: &VoxelBlock<T>, ) -> Result<(), Error>

Write a block with parallel encoding to memory-mapped region.

For non-contiguous blocks (sub-XY slabs), this falls back to the serial write_block implementation.

pub fn write_f16_from_f32( &mut self, block: &VoxelBlock<f32>, ) -> Result<(), Error>

Write an f32 block to a Float16 file.

pub fn update_header_stats(&mut self) -> Result<(), Error>

Scan the written data block and update header statistics.

Unlike Writer::update_header_stats, this does not need to read from disk because the data is already accessible via the memory map.

impl MmapWriter

pub fn finalize(&mut self) -> Result<(), Error>

Finalize the memory-mapped MRC file by writing the header.

This updates the first 1024 bytes of the memory map with the current header and flushes the mapping to disk. Must be called after all write_block calls.

Errors

Returns Error::Io if the flush fails.

Trait Implementations

impl Debug for MmapWriter

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

Formats the value using the given formatter.