Struct dioxus_core::prelude::LazyNodes

pub struct LazyNodes<'a, 'b> { /* private fields */ }

A concrete type provider for closures that build VNode structures.

This struct wraps lazy structs that build VNode trees Normally, we cannot perform a blanket implementation over closures, but if we wrap the closure in a concrete type, we can use it for different branches in matching.

LazyNodes::new(|f| {
       static TEMPLATE: dioxus::core::Template = dioxus::core::Template {
        name: "main.rs:5:5:20", // Source location of the template for hot reloading
        roots: &[
            dioxus::core::TemplateNode::Element {
                tag: dioxus_elements::div::TAG_NAME,
                namespace: dioxus_elements::div::NAME_SPACE,
                attrs: &[],
                children: &[],
            },
        ],
        node_paths: &[],
        attr_paths: &[],
    };
    dioxus::core::VNode {
        parent: None,
        key: None,
        template: std::cell::Cell::new(TEMPLATE),
        root_ids: dioxus::core::exports::bumpalo::collections::Vec::with_capacity_in(
                1usize,
                f.bump(),
            )
            .into(),
        dynamic_nodes: f.bump().alloc([]),
        dynamic_attrs: f.bump().alloc([]),
    })
}

Find more information about how to construct VNode at https://dioxuslabs.com/learn/0.4/contributing/walkthrough_readme#the-rsx-macro

Implementations

impl<'a, 'b> LazyNodes<'a, 'b>

pub fn new(val: impl FnOnce(&'a ScopeState) -> VNode<'a> + 'b) -> Self

Create a new LazyNodes closure, optimistically placing it onto the stack.

If the closure cannot fit into the stack allocation (16 bytes), then it is placed on the heap. Most closures will fit into the stack, and is the most optimal way to use the creation function.

pub fn call(self, f: &'a ScopeState) -> VNode<'a>

Call the closure with the given factory to produce real VNode.

let f = LazyNodes::new(/* Closure for creating VNodes */);

let node = f.call(cac);

Trait Implementations

impl<'a, 'b> IntoDynNode<'a> for LazyNodes<'a, 'b>

fn into_vnode(self, cx: &'a ScopeState) -> DynamicNode<'a>

Consume this item along with a scopestate and produce a DynamicNode