Struct BufferDiff 

pub struct BufferDiff { /* private fields */ }

The diff between two buffers.

Contains the list of (x, y) positions where cells differ.

Implementations

impl BufferDiff

pub fn new() -> Self

Create an empty diff.

pub fn with_capacity(capacity: usize) -> Self

Create a diff with pre-allocated capacity.

pub fn full(width: u16, height: u16) -> Self

Create a diff that marks every cell as changed.

Useful for full-screen redraws where the previous buffer is unknown (e.g., after resize or initial present).

pub fn compute(old: &Buffer, new: &Buffer) -> Self

Compute the diff between two buffers.

Uses row-major scan for cache efficiency. Both buffers must have the same dimensions.

Optimizations

• Row-skip fast path: unchanged rows are detected via slice equality and skipped entirely. For typical UI updates where most rows are static, this eliminates the majority of per-cell work.
• Blockwise row scan: rows with sparse edits are scanned in coarse blocks, skipping unchanged blocks and only diving into the blocks that differ.
• Direct slice iteration: row slices are computed once per row instead of calling get_unchecked(x, y) per cell, eliminating repeated y * width + x index arithmetic.
• Branchless cell comparison: bits_eq uses bitwise AND to avoid branch mispredictions in the inner loop.

Panics

Debug-asserts that both buffers have identical dimensions.

pub fn compute_into(&mut self, old: &Buffer, new: &Buffer)

Compute the diff into an existing buffer to reuse allocation.

pub fn compute_dirty(old: &Buffer, new: &Buffer) -> Self

Compute the diff between two buffers using dirty-row hints.

Only rows marked dirty in new are compared cell-by-cell. Clean rows are skipped entirely (O(1) per clean row).

This is sound provided the dirty tracking invariant holds: for all y, if any cell in row y changed, then new.is_row_dirty(y).

Falls back to full comparison for rows marked dirty, so false positives (marking a row dirty when it didn’t actually change) are safe — they only cost the per-cell scan for that row.

pub fn compute_dirty_into(&mut self, old: &Buffer, new: &Buffer)

Compute the dirty-row diff into an existing buffer to reuse allocation.

pub fn len(&self) -> usize

Number of changed cells.

pub fn is_empty(&self) -> bool

Check if no cells changed.

pub fn changes(&self) -> &[(u16, u16)]

Get the list of changed positions.

pub fn last_tile_stats(&self) -> Option<TileDiffStats>

Access the last tile diagnostics from a dirty diff pass.

pub fn tile_config_mut(&mut self) -> &mut TileDiffConfig

Mutably access tile diff configuration.

pub fn runs(&self) -> Vec<ChangeRun>

Convert point changes into contiguous runs.

Consecutive x positions on the same row are coalesced into a single run. This enables efficient cursor positioning in the presenter.

pub fn runs_into(&self, out: &mut Vec<ChangeRun>)

Like runs() but writes into a caller-provided buffer, avoiding per-frame allocation when the buffer is reused across frames.

pub fn iter(&self) -> impl Iterator<Item = (u16, u16)> + '_

Iterate over changed positions.

pub fn clear(&mut self)

Clear the diff, removing all recorded changes.

Trait Implementations

impl Clone for BufferDiff

fn clone(&self) -> BufferDiff

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BufferDiff

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

Formats the value using the given formatter.

impl Default for BufferDiff

fn default() -> BufferDiff

Returns the “default value” for a type.