Enum dioxus::prelude::TemplateNode

pub enum TemplateNode {
    Element {
        tag: &'static str,
        namespace: Option<&'static str>,
        attrs: &'static [TemplateAttribute],
        children: &'static [TemplateNode],
    },
    Text {
        text: &'static str,
    },
    Dynamic {
        id: usize,
    },
    DynamicText {
        id: usize,
    },
}

A statically known node in a layout.

This can be created at compile time, saving the VirtualDom time when diffing the tree

Variants

Element

An statically known element in the dom.

In HTML this would be something like <div id="123"> </div>

Fields

tag: &'static str

The name of the element

IE for a div, it would be the string “div”

namespace: Option<&'static str>

The namespace of the element

In HTML, this would be a valid URI that defines a namespace for all elements below it SVG is an example of this namespace

attrs: &'static [TemplateAttribute]

A list of possibly dynamic attributes for this element

An attribute on a DOM node, such as id="my-thing" or href="https://example.com".

children: &'static [TemplateNode]

A list of template nodes that define another set of template nodes

Text

This template node is just a piece of static text

Fields

text: &'static str

The actual text

Dynamic

This template node is unknown, and needs to be created at runtime.

Fields

id: usize

The index of the dynamic node in the VNode’s dynamic_nodes list

DynamicText

This template node is known to be some text, but needs to be created at runtime

This is separate from the pure Dynamic variant for various optimizations

Fields

id: usize

The index of the dynamic node in the VNode’s dynamic_nodes list

Implementations

impl TemplateNode

pub fn dynamic_id(&self) -> Option<usize>

Try to load the dynamic node at the given index

Trait Implementations

impl Clone for TemplateNode

fn clone(&self) -> TemplateNode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TemplateNode

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

Formats the value using the given formatter.

impl Deserialize<'static> for TemplateNode

fn deserialize<__D>( __deserializer: __D ) -> Result<TemplateNode, <__D as Deserializer<'static>>::Error>

where __D: Deserializer<'static>,

Deserialize this value from the given Serde deserializer.

impl Hash for TemplateNode

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for TemplateNode

fn cmp(&self, other: &TemplateNode) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for TemplateNode

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

fn partial_cmp(&self, other: &TemplateNode) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for TemplateNode

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for TemplateNode

impl Eq for TemplateNode

impl StructuralPartialEq for TemplateNode