Struct freya::prelude::Template

pub struct Template<'a> {
    pub name: &'a str,
    pub roots: &'a [TemplateNode<'a>],
    pub node_paths: &'a [&'a [u8]],
    pub attr_paths: &'a [&'a [u8]],
}

A static layout of a UI tree that describes a set of dynamic and static nodes.

This is the core innovation in Dioxus. Most UIs are made of static nodes, yet participate in diffing like any dynamic node. This struct can be created at compile time. It promises that its name is unique, allow Dioxus to use its static description of the UI to skip immediately to the dynamic nodes during diffing.

For this to work properly, the Template::name must be unique across your entire project. This can be done via variety of ways, with the suggested approach being the unique code location (file, line, col, etc).

Fields

name: &'a str

The name of the template. This must be unique across your entire program for template diffing to work properly

If two templates have the same name, it’s likely that Dioxus will panic when diffing.

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

The list of template nodes that make up the template

Unlike react, calls to rsx! can have multiple roots. This list supports that paradigm.

node_paths: &'a [&'a [u8]]

The paths of each node relative to the root of the template.

These will be one segment shorter than the path sent to the renderer since those paths are relative to the topmost element, not the roots field.

attr_paths: &'a [&'a [u8]]

The paths of each dynamic attribute relative to the root of the template

These will be one segment shorter than the path sent to the renderer since those paths are relative to the topmost element, not the roots field.

Implementations

impl<'a> Template<'a>

pub fn is_completely_dynamic(&self) -> bool

Is this template worth caching at all, since it’s completely runtime?

There’s no point in saving templates that are completely dynamic, since they’ll be recreated every time anyway.

Trait Implementations

impl<'a> Clone for Template<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Template<'a>

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

Formats the value using the given formatter.

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

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

Deserialize this value from the given Serde deserializer.

impl<'a> Hash for Template<'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 Template<'a>

fn cmp(&self, other: &Template<'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<Template<'a>> for Template<'a>

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

fn partial_cmp(&self, other: &Template<'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 Template<'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 Template<'a>

impl<'a> Eq for Template<'a>

impl<'a> StructuralEq for Template<'a>

impl<'a> StructuralPartialEq for Template<'a>