Enum DiffOp 

pub enum DiffOp {
    Insert {
        path: Vec<usize>,
        index: usize,
        type_id: TypeId,
        props_hash: u64,
    },
    Remove {
        path: Vec<usize>,
    },
    Update {
        path: Vec<usize>,
        new_props_hash: u64,
    },
    Move {
        from_path: Vec<usize>,
        to_path: Vec<usize>,
    },
    Replace {
        path: Vec<usize>,
        new_type_id: TypeId,
        new_props_hash: u64,
    },
}

Operation to apply during reconciliation.

Variants

Insert

Insert a new widget at path

Fields

path: Vec<usize>

Path to parent (indices from root)

index: usize

Index to insert at

type_id: TypeId

Type of widget to insert

props_hash: u64

Props hash of the new widget

Remove

Remove widget at path

Fields

path: Vec<usize>

Path to widget to remove

Update

Update widget properties at path

Fields

path: Vec<usize>

Path to widget to update

new_props_hash: u64

New props hash

Move

Move widget from one position to another

Fields

from_path: Vec<usize>

Old path

to_path: Vec<usize>

New path

Replace

Replace widget with different type

Fields

path: Vec<usize>

Path to widget to replace

new_type_id: TypeId

New type ID

new_props_hash: u64

New props hash

Trait Implementations

impl Clone for DiffOp

fn clone(&self) -> DiffOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DiffOp

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

Formats the value using the given formatter.

impl PartialEq for DiffOp

fn eq(&self, other: &DiffOp) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for DiffOp

impl StructuralPartialEq for DiffOp