Enum Mutation

pub enum Mutation {
    AppendChildren {
        id: ElementId,
        m: usize,
    },
    AssignId {
        path: &'static [u8],
        id: ElementId,
    },
    CreatePlaceholder {
        id: ElementId,
    },
    CreateTextNode {
        value: String,
        id: ElementId,
    },
    LoadTemplate {
        index: usize,
        id: ElementId,
    },
    ReplaceWith {
        id: ElementId,
        m: usize,
    },
    ReplacePlaceholder {
        path: &'static [u8],
        m: usize,
    },
    InsertAfter {
        id: ElementId,
        m: usize,
    },
    InsertBefore {
        id: ElementId,
        m: usize,
    },
    SetAttribute {
        name: &'static str,
        ns: Option<&'static str>,
        value: AttributeValue,
        id: ElementId,
    },
    SetText {
        value: String,
        id: ElementId,
    },
    NewEventListener {
        name: String,
        id: ElementId,
    },
    RemoveEventListener {
        name: String,
        id: ElementId,
    },
    Remove {
        id: ElementId,
    },
    PushRoot {
        id: ElementId,
    },
}

A Mutation represents a single instruction for the renderer to use to modify the UI tree to match the state of the Dioxus VirtualDom.

These edits can be serialized and sent over the network or through any interface

Variants

AppendChildren

Add these m children to the target element

Fields

id: ElementId

The ID of the element being mounted to

m: usize

The number of nodes on the stack to append to the target element

AssignId

Assign the element at the given path the target ElementId.

The path is in the form of a list of indices based on children. Templates cannot have more than 255 children per element, hence the use of a single byte.

Fields

path: &'static [u8]

The path of the child of the topmost node on the stack

A path of [] represents the topmost node. A path of [0] represents the first child. [0,1,2] represents 1st child’s 2nd child’s 3rd child.

id: ElementId

The ID we’re assigning to this element/placeholder.

This will be used later to modify the element or replace it with another element.

CreatePlaceholder

Create a placeholder in the DOM that we will use later.

Dioxus currently requires the use of placeholders to maintain a re-entrance point for things like list diffing

Fields

id: ElementId

The ID we’re assigning to this element/placeholder.

This will be used later to modify the element or replace it with another element.

CreateTextNode

Create a node specifically for text with the given value

Fields

value: String

The text content of this text node

id: ElementId

The ID we’re assigning to this specific text nodes

This will be used later to modify the element or replace it with another element.

LoadTemplate

Load and clone an existing node from a template with a given ID

Dioxus guarantees that the renderer will have already been provided the template. When the template is picked up in the template list, it should be saved under its “name” - here, the name

Fields

index: usize

Which root are we loading from the template?

The template is stored as a list of nodes. This index represents the position of that root

id: ElementId

The ID we’re assigning to this element being loaded from the template

This will be used later to move the element around in lists

ReplaceWith

Replace the target element (given by its ID) with the topmost m nodes on the stack

Fields

id: ElementId

The ID of the node we’re going to replace with

m: usize

The number of nodes on the stack to replace the target element with

ReplacePlaceholder

Replace an existing element in the template at the given path with the m nodes on the stack

Fields

path: &'static [u8]

The path of the child of the topmost node on the stack

A path of [] represents the topmost node. A path of [0] represents the first child. [0,1,2] represents 1st child’s 2nd child’s 3rd child.

m: usize

The number of nodes on the stack to replace the target element with

InsertAfter

Insert a number of nodes after a given node.

Fields

id: ElementId

The ID of the node to insert after.

m: usize

The number of nodes on the stack to insert after the target node.

InsertBefore

Insert a number of nodes before a given node.

Fields

id: ElementId

The ID of the node to insert before.

m: usize

The number of nodes on the stack to insert before the target node.

SetAttribute

Set the value of a node’s attribute.

Fields

name: &'static str

The name of the attribute to set.

ns: Option<&'static str>

The (optional) namespace of the attribute. For instance, “style” is in the “style” namespace.

value: AttributeValue

The value of the attribute.

id: ElementId

The ID of the node to set the attribute of.

SetText

Set the textcontent of a node.

Fields

value: String

The textcontent of the node

id: ElementId

The ID of the node to set the textcontent of.

NewEventListener

Create a new Event Listener.

Fields

name: String

The name of the event to listen for.

id: ElementId

The ID of the node to attach the listener to.

RemoveEventListener

Remove an existing Event Listener.

Fields

name: String

The name of the event to remove.

id: ElementId

The ID of the node to remove.

Remove

Remove a particular node from the DOM

Fields

id: ElementId

The ID of the node to remove.

PushRoot

Push the given root node onto our stack.

Fields

id: ElementId

The ID of the root node to push.

Trait Implementations

impl Debug for Mutation

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

Formats the value using the given formatter.

impl PartialEq for Mutation

fn eq(&self, other: &Mutation) -> 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 StructuralPartialEq for Mutation