Struct dodrio::Cached

pub struct Cached<R> where
    R: Default,  { /* fields omitted */ }

A renderable that supports caching for when rendering is expensive but can generate the same DOM tree.

Example

The TodoMVC example caches individual todo items.

Implementations

impl<R> Cached<R> where
    R: Default, 

pub fn new(inner: R) -> Cached<R>

Construct a new Cached<R> of an inner R.

Example

use dodrio::{Cached, Node, Render, RenderContext};

#[derive(Default)]
pub struct Counter {
    count: u32,
}

impl<'a> Render<'a> for Counter {
    fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
        // ...
    }
}

// Create a render-able counter.
let counter = Counter { count: 0 };

// And cache its rendering!
let cached_counter = Cached::new(counter);

pub fn invalidate(cached: &Self)

Invalidate the cached rendering.

This method should be called whenever the inner R must be re-rendered, and the cached Node from the last time R::render was invoked can no longer be re-used.

Example

The Cached<Hello> component must have its cache invalidated whenever the who string is changed, or else the cached rendering will keep displaying greetings to old whos.

use dodrio::{bumpalo, Cached, Node, Render, RenderContext};

/// A component that renders to "<p>Hello, {who}!</p>"
#[derive(Default)]
pub struct Hello {
    who: String
}

impl<'a> Render<'a> for Hello {
    fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
        use dodrio::builder::*;
        let greeting = bumpalo::format!(in cx.bump, "Hello, {}!", self.who);
        p(&cx)
            .children([text(greeting.into_bump_str())])
            .finish()
    }
}

/// Whenever a `Cached<Hello>`'s `who` is updated, we need to invalidate the
/// cache so that we don't keep displaying greetings to old `who`s.
pub fn set_who(hello: &mut Cached<Hello>, who: String) {
    hello.who = who;
    Cached::invalidate(hello);
}

pub fn into_inner(cached: Self) -> R

Convert a Cached<R> back into a plain R.

Trait Implementations

impl<R: Clone> Clone for Cached<R> where
    R: Default, 

fn clone(&self) -> Cached<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug> Debug for Cached<R> where
    R: Default, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<R: Default> Default for Cached<R> where
    R: Default, 

fn default() -> Cached<R>

Returns the "default value" for a type.

impl<R> Deref for Cached<R> where
    R: Default, 

type Target = R

The resulting type after dereferencing.

fn deref(&self) -> &R

Dereferences the value.

impl<R> DerefMut for Cached<R> where
    R: Default, 

fn deref_mut(&mut self) -> &mut R

Mutably dereferences the value.

impl<'a, R> Render<'a> for Cached<R> where
    R: 'static + Default + for<'b> Render<'b>, 

fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a>

Render self as a virtual DOM. Use the given context's Bump for temporary allocations.