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 maintain separate implementations of IntoVNode.

LazyNodes::new(|f| f.element("div", [], [], [] None))

Implementations

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

pub fn new(val: impl FnOnce(NodeFactory<'a>) -> 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 new_boxed<F>(_val: F) -> Self where
    F: FnOnce(NodeFactory<'a>) -> VNode<'a> + 'b, 

Create a new LazyNodes closure, but force it onto the heap.

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

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

let f = LazyNodes::new(move |f| f.element("div", [], [], [] None));

let fac = NodeFactory::new(&cx);

let node = f.call(cac);

Trait Implementations

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

type Item = LazyNodes<'a, 'b>

The type of the elements being iterated over.

type IntoIter = Once<Self::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

fn into_vnode(self, cx: NodeFactory<'a>) -> VNode<'a>

Convert this into a VNode, using the NodeFactory as a source of allocation