Enum freya::prelude::TemplateNode

pub enum TemplateNode<'a> {
    Element {
        tag: &'a str,
        namespace: Option<&'a str>,
        attrs: &'a [TemplateAttribute<'a>],
        children: &'a [TemplateNode<'a>],
    },
    Text {
        text: &'a 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

Fields

tag: &'a str

The name of the element

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

namespace: Option<&'a 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: &'a [TemplateAttribute<'a>]

A list of possibly dynamic attribues for this element

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

children: &'a [TemplateNode<'a>]

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

An statically known element in the dom.

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

Text

Fields

text: &'a str

The actual text

This template node is just a piece of static text

Dynamic

Fields

id: usize

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

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

DynamicText

Fields

id: usize

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

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

Trait Implementations

impl<'a> Clone for TemplateNode<'a>

fn clone(&self) -> TemplateNode<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TemplateNode<'a>

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

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for TemplateNode<'a>where 'de: 'a,

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

Deserialize this value from the given Serde deserializer.

impl<'a> Hash for TemplateNode<'a>

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<'a> Ord for TemplateNode<'a>

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<'a> PartialEq<TemplateNode<'a>> for TemplateNode<'a>

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

fn partial_cmp(&self, other: &TemplateNode<'a>) -> 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<'a> Serialize for TemplateNode<'a>

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<'a> Copy for TemplateNode<'a>

impl<'a> Eq for TemplateNode<'a>

impl<'a> StructuralEq for TemplateNode<'a>

impl<'a> StructuralPartialEq for TemplateNode<'a>