Enum sauron::vdom::PatchType

pub enum PatchType<'a, MSG> {
    InsertBeforeNode {
        nodes: Vec<Cow<'a, Node<MSG>>>,
    },
    InsertAfterNode {
        nodes: Vec<&'a Node<MSG>>,
    },
    AppendChildren {
        children: Vec<&'a Node<MSG>>,
    },
    ClearChildren,
    RemoveNode,
    MoveBeforeNode {
        nodes_path: Vec<TreePath>,
    },
    MoveAfterNode {
        nodes_path: Vec<TreePath>,
    },
    ReplaceNode {
        replacement: Vec<&'a Node<MSG>>,
    },
    AddAttributes {
        attrs: Vec<&'a Attribute<MSG>>,
    },
    RemoveAttributes {
        attrs: Vec<&'a Attribute<MSG>>,
    },
}

the patch variant

Variants

InsertBeforeNode

insert the nodes before the node at patch_path

Fields

nodes: Vec<Cow<'a, Node<MSG>>>

the nodes to be inserted before patch_path

InsertAfterNode

insert the nodes after the node at patch_path

Fields

nodes: Vec<&'a Node<MSG>>

the nodes to be inserted after the patch_path

AppendChildren

Append a vector of child nodes to a parent node id at patch_path

Fields

children: Vec<&'a Node<MSG>>

children nodes to be appended and their corresponding new_node_idx

ClearChildren

clear the chilren of this node,

RemoveNode

remove the target node

MoveBeforeNode

remove the nodes pointed at these nodes_path and move them before target_element pointed at patch_path

Fields

nodes_path: Vec<TreePath>

before this target location

MoveAfterNode

remove the the nodes pointed at these nodes_path and move them after the target_element pointed at patch_path

Fields

nodes_path: Vec<TreePath>

after this target location

ReplaceNode

ReplaceNode a node with another node. This typically happens when a node’s tag changes. ex:

becomes

Fields

replacement: Vec<&'a Node<MSG>>

the node that will replace the target node

AddAttributes

Add attributes that the new node has that the old node does not Note: the attributes is not a reference since attributes of same name are merged to produce a new unify attribute

Fields

attrs: Vec<&'a Attribute<MSG>>

the attributes to be patched into the target node

RemoveAttributes

Remove attributes that the old node had that the new node doesn’t

Fields

attrs: Vec<&'a Attribute<MSG>>

attributes that are to be removed from this target node

Implementations

impl<'a, MSG> PatchType<'a, MSG>

pub fn map_msg<F, MSG2>(self, cb: F) -> PatchType<'a, MSG2>

where F: Fn(MSG) -> MSG2 + Clone + 'static, MSG2: 'static, MSG: 'static,

map the msg of this patch_type such that PatchType<MSG> becomes PatchType<MSG2>

Trait Implementations

impl<'a, MSG> Clone for PatchType<'a, MSG>

fn clone(&self) -> PatchType<'a, MSG>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, MSG> Debug for PatchType<'a, MSG>

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

Formats the value using the given formatter.

impl<'a, MSG> PartialEq for PatchType<'a, MSG>

fn eq(&self, __other: &PatchType<'a, MSG>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a, MSG> Eq for PatchType<'a, MSG>