Enum Node

pub enum Node<MSG> {
    Element(Element<MSG>),
    Leaf(Leaf<MSG>),
}

represents a node in a virtual dom A node could be an element which can contain one or more children of nodes. A node could also be just a text node which contains a string

Much of the types are Generics

Namespace - is the type for the namespace, this will be &’static str when used in html based virtual dom implementation Tag - is the type for the element tag, this will be &’static str when used in html based virtual dom impmenentation AttributeName - is the type for the attribute name, this will be &’static str when used in html based virtual dom implementation AttributeValue - is the type for the value of the attribute, this will be String, f64, or just another generics that suits the implementing library which used mt-dom for just dom-diffing purposes

Variants

Element(Element<MSG>)

Element variant of a virtual node

Leaf(Leaf<MSG>)

A Leaf node

Implementations

impl<MSG> Node<MSG>

pub fn map_msg<F, MSG2>(self, cb: F) -> Node<MSG2>

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

map the msg of this node such that Node becomes Node

impl<MSG> Node<MSG>

pub fn render_with_indent( &self, buffer: &mut dyn Write, indent: usize, compressed: bool, ) -> Result<(), Error>

render the node to a writable buffer

pub fn render(&self, buffer: &mut dyn Write) -> Result<(), Error>

render the node to a writable buffer

pub fn render_to_string(&self) -> String

render compressed html to string

pub fn render_to_string_pretty(&self) -> String

render to string with nice indention

impl<MSG> Node<MSG>

pub fn take_element(self) -> Option<Element<MSG>>

consume self and return the element if it is an element variant None if it is a text node

pub fn leaf(&self) -> Option<&Leaf<MSG>>

returns a reference to the Leaf if the node is a Leaf variant

pub fn is_element(&self) -> bool

returns true if the node is an element variant

pub fn is_leaf(&self) -> bool

returns true if the node is a Leaf

pub fn is_text(&self) -> bool

returns true if this is a text node

pub fn as_text(&self) -> Option<&str>

return the text if this is text node leaf

pub fn as_symbol(&self) -> Option<&str>

return the html entity if it is a symbol variant

pub fn element_mut(&mut self) -> Option<&mut Element<MSG>>

Get a mutable reference to the element, if this node is an element node

pub fn element_ref(&self) -> Option<&Element<MSG>>

returns a reference to the element if this is an element node

pub fn with_children( self, children: impl IntoIterator<Item = Node<MSG>>, ) -> Node<MSG>

Consume a mutable self and add a children to this node it if is an element will have no effect if it is a text node. This is used in building the nodes in a builder pattern

pub fn add_children( &mut self, children: impl IntoIterator<Item = Node<MSG>>, ) -> Result<(), Error>

add children but not consume self

pub fn with_attributes( self, attributes: impl IntoIterator<Item = Attribute<MSG>>, ) -> Node<MSG>

add attributes to the node and returns itself this is used in view building

pub fn add_attributes( &mut self, attributes: impl IntoIterator<Item = Attribute<MSG>>, ) -> Result<(), Error>

add attributes using a mutable reference to self

pub fn attributes(&self) -> Option<&[Attribute<MSG>]>

get the attributes of this node returns None if it is a text node

pub fn tag(&self) -> Option<&&'static str>

returns the tag of this node if it is an element otherwise None if it is a text node

pub fn children(&self) -> &[Node<MSG>]

return the children of this node if it is an element returns None if it is a text node

pub fn children_count(&self) -> usize

Return the count of the children of this node

pub fn children_mut(&mut self) -> Option<&mut [Node<MSG>]>

return the children of this node if it is an element returns None if it is a text node

pub fn swap_remove_child(&mut self, index: usize) -> Node<MSG>

Removes an child node from this element and returns it.

The removed child is replaced by the last child of the element’s children.

Panics

Panics if this is a text node

pub fn swap_children(&mut self, a: usize, b: usize)

Swaps the 2 child node in this element

Arguments

• a - The index of the first child node
• b - The index of the second child node

Panics

Panics if both a and b are out of bounds Panics if this is a text node

pub fn node_count(&self) -> usize

Returns the total number of nodes on this node tree, that is counting the direct and indirect child nodes of this node.

pub fn descendant_node_count(&self) -> usize

only count the descendant node

pub fn set_attributes( &mut self, attributes: impl IntoIterator<Item = Attribute<MSG>>, ) -> Result<(), Error>

remove the existing attributes and set with the new value

pub fn merge_attributes( self, attributes: impl IntoIterator<Item = Attribute<MSG>>, ) -> Node<MSG>

merge to existing attributes if the attribute name already exist

pub fn attribute_value( &self, name: &&'static str, ) -> Option<Vec<&AttributeValue<MSG>>>

return the attribute values of this node which match the attribute name name

pub fn first_value(&self, att_name: &&'static str) -> Option<&Value>

get the first value of the attribute which has the name att_name of this node

pub fn skip_diff(&self) -> Option<SkipDiff>

return the skip diff if this node has one

pub fn unwrap_template(self) -> Node<MSG>

pub fn unwrap_template_ref(&self) -> &Node<MSG>

pub fn is_template(&self) -> bool

returns true if this node is a templated view

Trait Implementations

impl<MSG> Clone for Node<MSG>

fn clone(&self) -> Node<MSG>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<MSG> Debug for Node<MSG>

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

Formats the value using the given formatter.

impl<MSG> From<Arc> for Node<MSG>

fn from(arc: Arc) -> Node<MSG>

Converts to this type from the input type.

impl<MSG> From<CellText> for Node<MSG>

fn from(ct: CellText) -> Node<MSG>

Converts to this type from the input type.

impl<MSG> From<Circle> for Node<MSG>

fn from(c: Circle) -> Node<MSG>

Converts to this type from the input type.

impl<MSG> From<Fragment> for Node<MSG>

fn from(fragment: Fragment) -> Node<MSG>

Converts to this type from the input type.

impl<MSG> From<Line> for Node<MSG>

fn from(line: Line) -> Node<MSG>

Converts to this type from the input type.

impl<MSG> From<MarkerLine> for Node<MSG>

fn from(ml: MarkerLine) -> Node<MSG>

Converts to this type from the input type.

impl<MSG> From<Polygon> for Node<MSG>

fn from(pl: Polygon) -> Node<MSG>

Converts to this type from the input type.

impl<MSG> From<Rect> for Node<MSG>

fn from(r: Rect) -> Node<MSG>

Converts to this type from the input type.

impl<MSG> From<Text> for Node<MSG>

fn from(t: Text) -> Node<MSG>

Converts to this type from the input type.

impl<MSG> PartialEq for Node<MSG>

fn eq(&self, __other: &Node<MSG>) -> 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<MSG> Eq for Node<MSG>