wip: adjust memoization
This commit is contained in:
Jonathan Kelley committed
1 parent
934de21dd6
commit
e2e4d431e1
15 files changed
+932
-703
No files matched your search
@@ -0,0 +1,875 @@
|
||||
use futures_channel::mpsc::UnboundedSender;
|
||||
use fxhash::{FxHashMap, FxHashSet};
|
||||
use slab::Slab;
|
||||
use std::{
|
||||
any::{Any, TypeId},
|
||||
borrow::Borrow,
|
||||
cell::{Cell, RefCell},
|
||||
collections::HashMap,
|
||||
future::Future,
|
||||
pin::Pin,
|
||||
rc::Rc,
|
||||
};
|
||||
|
||||
use crate::{innerlude::*, unsafe_utils::extend_vnode};
|
||||
use bumpalo::{boxed::Box as BumpBox, Bump};
|
||||
|
||||
pub(crate) type FcSlot = *const ();
|
||||
|
||||
pub(crate) struct Heuristic {
|
||||
hook_arena_size: usize,
|
||||
node_arena_size: usize,
|
||||
}
|
||||
|
||||
// a slab-like arena with stable references even when new scopes are allocated
|
||||
// uses a bump arena as a backing
|
||||
//
|
||||
// has an internal heuristics engine to pre-allocate arenas to the right size
|
||||
pub(crate) struct ScopeArena {
|
||||
pub pending_futures: RefCell<FxHashSet<ScopeId>>,
|
||||
pub scope_counter: Cell<usize>,
|
||||
pub sender: UnboundedSender<SchedulerMsg>,
|
||||
pub bump: Bump,
|
||||
pub scopes: RefCell<FxHashMap<ScopeId, *mut ScopeState>>,
|
||||
pub heuristics: RefCell<FxHashMap<FcSlot, Heuristic>>,
|
||||
pub free_scopes: RefCell<Vec<*mut ScopeState>>,
|
||||
pub nodes: RefCell<Slab<*const VNode<'static>>>,
|
||||
}
|
||||
|
||||
impl ScopeArena {
|
||||
pub(crate) fn new(sender: UnboundedSender<SchedulerMsg>) -> Self {
|
||||
let bump = Bump::new();
|
||||
|
||||
// allocate a container for the root element
|
||||
// this will *never* show up in the diffing process
|
||||
// todo: figure out why this is necessary. i forgot. whoops.
|
||||
let el = bump.alloc(VElement {
|
||||
tag_name: "root",
|
||||
namespace: None,
|
||||
key: None,
|
||||
dom_id: Cell::new(Some(ElementId(0))),
|
||||
parent_id: Default::default(),
|
||||
listeners: &[],
|
||||
attributes: &[],
|
||||
children: &[],
|
||||
});
|
||||
|
||||
let node = bump.alloc(VNode::Element(el));
|
||||
let mut nodes = Slab::new();
|
||||
let root_id = nodes.insert(unsafe { std::mem::transmute(node as *const _) });
|
||||
|
||||
debug_assert_eq!(root_id, 0);
|
||||
|
||||
Self {
|
||||
scope_counter: Cell::new(0),
|
||||
bump,
|
||||
pending_futures: RefCell::new(FxHashSet::default()),
|
||||
scopes: RefCell::new(FxHashMap::default()),
|
||||
heuristics: RefCell::new(FxHashMap::default()),
|
||||
free_scopes: RefCell::new(Vec::new()),
|
||||
nodes: RefCell::new(nodes),
|
||||
sender,
|
||||
}
|
||||
}
|
||||
|
||||
/// Safety:
|
||||
/// - Obtaining a mutable refernece to any Scope is unsafe
|
||||
/// - Scopes use interior mutability when sharing data into components
|
||||
pub(crate) fn get_scope(&self, id: ScopeId) -> Option<&ScopeState> {
|
||||
unsafe { self.scopes.borrow().get(&id).map(|f| &**f) }
|
||||
}
|
||||
|
||||
pub(crate) fn get_scope_raw(&self, id: ScopeId) -> Option<*mut ScopeState> {
|
||||
self.scopes.borrow().get(&id).copied()
|
||||
}
|
||||
|
||||
pub(crate) fn new_with_key(
|
||||
&self,
|
||||
fc_ptr: *const (),
|
||||
vcomp: Box<dyn AnyProps>,
|
||||
parent_scope: Option<ScopeId>,
|
||||
container: ElementId,
|
||||
subtree: u32,
|
||||
) -> ScopeId {
|
||||
let new_scope_id = ScopeId(self.scope_counter.get());
|
||||
self.scope_counter.set(self.scope_counter.get() + 1);
|
||||
let parent_scope = parent_scope.map(|f| self.get_scope_raw(f)).flatten();
|
||||
let height = parent_scope
|
||||
.as_ref()
|
||||
.map(|f| unsafe { &**f })
|
||||
.map(|f| f.height + 1)
|
||||
.unwrap_or_default();
|
||||
|
||||
/*
|
||||
This scopearena aggressively reuse old scopes when possible.
|
||||
We try to minimize the new allocations for props/arenas.
|
||||
|
||||
However, this will probably lead to some sort of fragmentation.
|
||||
I'm not exactly sure how to improve this today.
|
||||
*/
|
||||
match self.free_scopes.borrow_mut().pop() {
|
||||
// No free scope, make a new scope
|
||||
None => {
|
||||
let (node_capacity, hook_capacity) = self
|
||||
.heuristics
|
||||
.borrow()
|
||||
.get(&fc_ptr)
|
||||
.map(|h| (h.node_arena_size, h.hook_arena_size))
|
||||
.unwrap_or_default();
|
||||
|
||||
let frames = [BumpFrame::new(node_capacity), BumpFrame::new(node_capacity)];
|
||||
|
||||
let scope = self.bump.alloc(ScopeState {
|
||||
sender: self.sender.clone(),
|
||||
container,
|
||||
our_arena_idx: new_scope_id,
|
||||
parent_scope,
|
||||
height,
|
||||
frames,
|
||||
subtree: Cell::new(subtree),
|
||||
is_subtree_root: Cell::new(false),
|
||||
|
||||
props: vcomp,
|
||||
generation: 0.into(),
|
||||
|
||||
shared_contexts: Default::default(),
|
||||
|
||||
items: RefCell::new(SelfReferentialItems {
|
||||
listeners: Default::default(),
|
||||
borrowed_props: Default::default(),
|
||||
tasks: Default::default(),
|
||||
}),
|
||||
|
||||
hook_arena: Bump::new(),
|
||||
hook_vals: RefCell::new(Vec::with_capacity(hook_capacity)),
|
||||
hook_idx: Default::default(),
|
||||
});
|
||||
|
||||
let any_item = self.scopes.borrow_mut().insert(new_scope_id, scope);
|
||||
debug_assert!(any_item.is_none());
|
||||
}
|
||||
|
||||
// Reuse a free scope
|
||||
Some(old_scope) => {
|
||||
let scope = unsafe { &mut *old_scope };
|
||||
scope.props.set(vcomp);
|
||||
scope.parent_scope = parent_scope;
|
||||
scope.height = height;
|
||||
scope.subtree = Cell::new(subtree);
|
||||
scope.our_arena_idx = new_scope_id;
|
||||
scope.container = container;
|
||||
let any_item = self.scopes.borrow_mut().insert(new_scope_id, scope);
|
||||
debug_assert!(any_item.is_none());
|
||||
}
|
||||
}
|
||||
|
||||
new_scope_id
|
||||
}
|
||||
|
||||
// Removes a scope and its descendents from the arena
|
||||
pub fn try_remove(&self, id: ScopeId) -> Option<()> {
|
||||
self.ensure_drop_safety(id);
|
||||
|
||||
// Safety:
|
||||
// - ensure_drop_safety ensures that no references to this scope are in use
|
||||
// - this raw pointer is removed from the map
|
||||
let scope = unsafe { &mut *self.scopes.borrow_mut().remove(&id).unwrap() };
|
||||
scope.reset();
|
||||
|
||||
todo!("drop");
|
||||
// unsafe { &*scope.render.get() }.release();
|
||||
|
||||
self.free_scopes.borrow_mut().push(scope);
|
||||
|
||||
Some(())
|
||||
}
|
||||
|
||||
pub fn reserve_node<'a>(&self, node: &'a VNode<'a>) -> ElementId {
|
||||
let mut els = self.nodes.borrow_mut();
|
||||
let entry = els.vacant_entry();
|
||||
let key = entry.key();
|
||||
let id = ElementId(key);
|
||||
let node = unsafe { extend_vnode(node) };
|
||||
entry.insert(node as *const _);
|
||||
id
|
||||
}
|
||||
|
||||
pub fn update_node<'a>(&self, node: &'a VNode<'a>, id: ElementId) {
|
||||
let node = unsafe { extend_vnode(node) };
|
||||
*self.nodes.borrow_mut().get_mut(id.0).unwrap() = node;
|
||||
}
|
||||
|
||||
pub fn collect_garbage(&self, id: ElementId) {
|
||||
self.nodes.borrow_mut().remove(id.0);
|
||||
}
|
||||
|
||||
/// This method cleans up any references to data held within our hook list. This prevents mutable aliasing from
|
||||
/// causing UB in our tree.
|
||||
///
|
||||
/// This works by cleaning up our references from the bottom of the tree to the top. The directed graph of components
|
||||
/// essentially forms a dependency tree that we can traverse from the bottom to the top. As we traverse, we remove
|
||||
/// any possible references to the data in the hook list.
|
||||
///
|
||||
/// References to hook data can only be stored in listeners and component props. During diffing, we make sure to log
|
||||
/// all listeners and borrowed props so we can clear them here.
|
||||
///
|
||||
/// This also makes sure that drop order is consistent and predictable. All resources that rely on being dropped will
|
||||
/// be dropped.
|
||||
pub(crate) fn ensure_drop_safety(&self, scope_id: ScopeId) {
|
||||
if let Some(scope) = self.get_scope(scope_id) {
|
||||
let mut items = scope.items.borrow_mut();
|
||||
|
||||
// make sure we drop all borrowed props manually to guarantee that their drop implementation is called before we
|
||||
// run the hooks (which hold an &mut Reference)
|
||||
// recursively call ensure_drop_safety on all children
|
||||
items.borrowed_props.drain(..).for_each(|comp| {
|
||||
let scope_id = comp
|
||||
.scope
|
||||
.get()
|
||||
.expect("VComponents should be associated with a valid Scope");
|
||||
|
||||
self.ensure_drop_safety(scope_id);
|
||||
|
||||
let g = comp.props.take();
|
||||
// comp.props.release();
|
||||
});
|
||||
|
||||
// Now that all the references are gone, we can safely drop our own references in our listeners.
|
||||
items
|
||||
.listeners
|
||||
.drain(..)
|
||||
.for_each(|listener| drop(listener.callback.callback.borrow_mut().take()));
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn run_scope(&self, id: ScopeId) {
|
||||
// Cycle to the next frame and then reset it
|
||||
// This breaks any latent references, invalidating every pointer referencing into it.
|
||||
// Remove all the outdated listeners
|
||||
self.ensure_drop_safety(id);
|
||||
|
||||
// todo: we *know* that this is aliased by the contents of the scope itself
|
||||
let scope = unsafe { &mut *self.get_scope_raw(id).expect("could not find scope") };
|
||||
|
||||
// Safety:
|
||||
// - We dropped the listeners, so no more &mut T can be used while these are held
|
||||
// - All children nodes that rely on &mut T are replaced with a new reference
|
||||
scope.hook_idx.set(0);
|
||||
|
||||
// book keeping to ensure safety around the borrowed data
|
||||
{
|
||||
// Safety:
|
||||
// - We've dropped all references to the wip bump frame with "ensure_drop_safety"
|
||||
unsafe { scope.reset_wip_frame() };
|
||||
|
||||
let mut items = scope.items.borrow_mut();
|
||||
|
||||
// just forget about our suspended nodes while we're at it
|
||||
items.tasks.clear();
|
||||
|
||||
// guarantee that we haven't screwed up - there should be no latent references anywhere
|
||||
debug_assert!(items.listeners.is_empty());
|
||||
debug_assert!(items.borrowed_props.is_empty());
|
||||
debug_assert!(items.tasks.is_empty());
|
||||
}
|
||||
|
||||
// safety: this is definitely not dropped
|
||||
|
||||
/*
|
||||
If the component returns None, then we fill in a placeholder node. This will wipe what was there.
|
||||
An alternate approach is to leave the Real Dom the same, but that can lead to safety issues and a lot more checks.
|
||||
|
||||
Instead, we just treat the `None` as a shortcut to placeholder.
|
||||
If the developer wants to prevent a scope from updating, they should control its memoization instead.
|
||||
|
||||
Also, the way we implement hooks allows us to cut rendering short before the next hook is recalled.
|
||||
I'm not sure if React lets you abort the component early, but we let you do that.
|
||||
*/
|
||||
if let Some(node) = scope.props.render(scope) {
|
||||
if !scope.items.borrow().tasks.is_empty() {
|
||||
self.pending_futures.borrow_mut().insert(id);
|
||||
}
|
||||
|
||||
let frame = scope.wip_frame();
|
||||
let node = frame.bump.alloc(node);
|
||||
frame.node.set(unsafe { extend_vnode(node) });
|
||||
} else {
|
||||
let frame = scope.wip_frame();
|
||||
let node = frame
|
||||
.bump
|
||||
.alloc(VNode::Placeholder(frame.bump.alloc(VPlaceholder {
|
||||
dom_id: Default::default(),
|
||||
})));
|
||||
frame.node.set(unsafe { extend_vnode(node) });
|
||||
}
|
||||
|
||||
// make the "wip frame" contents the "finished frame"
|
||||
// any future dipping into completed nodes after "render" will go through "fin head"
|
||||
scope.cycle_frame();
|
||||
}
|
||||
|
||||
pub fn call_listener_with_bubbling(&self, event: UserEvent, element: ElementId) {
|
||||
let nodes = self.nodes.borrow();
|
||||
let mut cur_el = Some(element);
|
||||
|
||||
while let Some(id) = cur_el.take() {
|
||||
if let Some(el) = nodes.get(id.0) {
|
||||
let real_el = unsafe { &**el };
|
||||
if let VNode::Element(real_el) = real_el {
|
||||
for listener in real_el.listeners.borrow().iter() {
|
||||
if listener.event == event.name {
|
||||
let mut cb = listener.callback.callback.borrow_mut();
|
||||
if let Some(cb) = cb.as_mut() {
|
||||
// todo: arcs are pretty heavy to clone
|
||||
// we really want to convert arc to rc
|
||||
// unfortunately, the SchedulerMsg must be send/sync to be sent across threads
|
||||
// we could convert arc to rc internally or something
|
||||
(cb)(event.data.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cur_el = real_el.parent_id.get();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The head of the bumpframe is the first linked NodeLink
|
||||
pub fn wip_head(&self, id: ScopeId) -> &VNode {
|
||||
let scope = self.get_scope(id).unwrap();
|
||||
let frame = scope.wip_frame();
|
||||
let node = unsafe { &*frame.node.get() };
|
||||
unsafe { extend_vnode(node) }
|
||||
}
|
||||
|
||||
// The head of the bumpframe is the first linked NodeLink
|
||||
pub fn fin_head(&self, id: ScopeId) -> &VNode {
|
||||
let scope = self.get_scope(id).unwrap();
|
||||
let frame = scope.fin_frame();
|
||||
let node = unsafe { &*frame.node.get() };
|
||||
unsafe { extend_vnode(node) }
|
||||
}
|
||||
|
||||
pub fn root_node(&self, id: ScopeId) -> &VNode {
|
||||
self.fin_head(id)
|
||||
}
|
||||
}
|
||||
|
||||
/// Components in Dioxus use the "Context" object to interact with their lifecycle.
|
||||
///
|
||||
/// This lets components access props, schedule updates, integrate hooks, and expose shared state.
|
||||
///
|
||||
/// For the most part, the only method you should be using regularly is `render`.
|
||||
///
|
||||
/// ## Example
|
||||
///
|
||||
/// ```ignore
|
||||
/// #[derive(Props)]
|
||||
/// struct ExampleProps {
|
||||
/// name: String
|
||||
/// }
|
||||
///
|
||||
/// fn Example(cx: Scope<ExampleProps>) -> Element {
|
||||
/// cx.render(rsx!{ div {"Hello, {cx.props.name}"} })
|
||||
/// }
|
||||
/// ```
|
||||
pub struct Scope<'a, P> {
|
||||
pub scope: &'a ScopeState,
|
||||
pub props: &'a P,
|
||||
}
|
||||
|
||||
impl<P> Copy for Scope<'_, P> {}
|
||||
impl<P> Clone for Scope<'_, P> {
|
||||
fn clone(&self) -> Self {
|
||||
Self {
|
||||
scope: self.scope,
|
||||
props: self.props,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, P> std::ops::Deref for Scope<'a, P> {
|
||||
// rust will auto deref again to the original 'a lifetime at the call site
|
||||
type Target = &'a ScopeState;
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.scope
|
||||
}
|
||||
}
|
||||
|
||||
/// A component's unique identifier.
|
||||
///
|
||||
/// `ScopeId` is a `usize` that is unique across the entire VirtualDOM and across time. ScopeIDs will never be reused
|
||||
/// once a component has been unmounted.
|
||||
#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
|
||||
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
||||
pub struct ScopeId(pub usize);
|
||||
|
||||
/// Every component in Dioxus is represented by a `ScopeState`.
|
||||
///
|
||||
/// Scopes contain the state for hooks, the component's props, and other lifecycle information.
|
||||
///
|
||||
/// Scopes are allocated in a generational arena. As components are mounted/unmounted, they will replace slots of dead components.
|
||||
/// The actual contents of the hooks, though, will be allocated with the standard allocator. These should not allocate as frequently.
|
||||
///
|
||||
/// We expose the `Scope` type so downstream users can traverse the Dioxus VirtualDOM for whatever
|
||||
/// use case they might have.
|
||||
pub struct ScopeState {
|
||||
pub(crate) parent_scope: Option<*mut ScopeState>,
|
||||
pub(crate) container: ElementId,
|
||||
pub(crate) our_arena_idx: ScopeId,
|
||||
pub(crate) height: u32,
|
||||
pub(crate) sender: UnboundedSender<SchedulerMsg>,
|
||||
|
||||
// todo: subtrees
|
||||
pub(crate) is_subtree_root: Cell<bool>,
|
||||
pub(crate) subtree: Cell<u32>,
|
||||
|
||||
pub(crate) props: Option<RefCell<Box<dyn AnyProps>>>,
|
||||
|
||||
// nodes, items
|
||||
pub(crate) frames: [BumpFrame; 2],
|
||||
pub(crate) generation: Cell<u32>,
|
||||
pub(crate) items: RefCell<SelfReferentialItems<'static>>,
|
||||
|
||||
// hooks
|
||||
pub(crate) hook_arena: Bump,
|
||||
pub(crate) hook_vals: RefCell<Vec<*mut dyn Any>>,
|
||||
pub(crate) hook_idx: Cell<usize>,
|
||||
|
||||
// shared state -> todo: move this out of scopestate
|
||||
pub(crate) shared_contexts: RefCell<HashMap<TypeId, Rc<dyn Any>>>,
|
||||
}
|
||||
|
||||
pub struct SelfReferentialItems<'a> {
|
||||
pub(crate) listeners: Vec<&'a Listener<'a>>,
|
||||
pub(crate) borrowed_props: Vec<&'a VComponent<'a>>,
|
||||
pub(crate) tasks: Vec<Pin<BumpBox<'a, dyn Future<Output = ()>>>>,
|
||||
}
|
||||
|
||||
// Public methods exposed to libraries and components
|
||||
impl ScopeState {
|
||||
/// Get the subtree ID that this scope belongs to.
|
||||
///
|
||||
/// Each component has its own subtree ID - the root subtree has an ID of 0. This ID is used by the renderer to route
|
||||
/// the mutations to the correct window/portal/subtree.
|
||||
///
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust, ignore
|
||||
/// let mut dom = VirtualDom::new(|cx, props|cx.render(rsx!{ div {} }));
|
||||
/// dom.rebuild();
|
||||
///
|
||||
/// let base = dom.base_scope();
|
||||
///
|
||||
/// assert_eq!(base.subtree(), 0);
|
||||
/// ```
|
||||
///
|
||||
/// todo: enable
|
||||
pub(crate) fn _subtree(&self) -> u32 {
|
||||
self.subtree.get()
|
||||
}
|
||||
|
||||
/// Create a new subtree with this scope as the root of the subtree.
|
||||
///
|
||||
/// Each component has its own subtree ID - the root subtree has an ID of 0. This ID is used by the renderer to route
|
||||
/// the mutations to the correct window/portal/subtree.
|
||||
///
|
||||
/// This method
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust, ignore
|
||||
/// fn App(cx: Scope<()>) -> Element {
|
||||
/// rsx!(cx, div { "Subtree {id}"})
|
||||
/// };
|
||||
/// ```
|
||||
///
|
||||
/// todo: enable subtree
|
||||
pub(crate) fn _create_subtree(&self) -> Option<u32> {
|
||||
if self.is_subtree_root.get() {
|
||||
None
|
||||
} else {
|
||||
todo!()
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the height of this Scope - IE the number of scopes above it.
|
||||
///
|
||||
/// A Scope with a height of `0` is the root scope - there are no other scopes above it.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust, ignore
|
||||
/// let mut dom = VirtualDom::new(|cx, props| cx.render(rsx!{ div {} }));
|
||||
/// dom.rebuild();
|
||||
///
|
||||
/// let base = dom.base_scope();
|
||||
///
|
||||
/// assert_eq!(base.height(), 0);
|
||||
/// ```
|
||||
pub fn height(&self) -> u32 {
|
||||
self.height
|
||||
}
|
||||
|
||||
/// Get the Parent of this Scope within this Dioxus VirtualDOM.
|
||||
///
|
||||
/// This ID is not unique across Dioxus VirtualDOMs or across time. IDs will be reused when components are unmounted.
|
||||
///
|
||||
/// The base component will not have a parent, and will return `None`.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust, ignore
|
||||
/// let mut dom = VirtualDom::new(|cx, props| cx.render(rsx!{ div {} }));
|
||||
/// dom.rebuild();
|
||||
///
|
||||
/// let base = dom.base_scope();
|
||||
///
|
||||
/// assert_eq!(base.parent(), None);
|
||||
/// ```
|
||||
pub fn parent(&self) -> Option<ScopeId> {
|
||||
// safety: the pointer to our parent is *always* valid thanks to the bump arena
|
||||
self.parent_scope.map(|p| unsafe { &*p }.our_arena_idx)
|
||||
}
|
||||
|
||||
/// Get the ID of this Scope within this Dioxus VirtualDOM.
|
||||
///
|
||||
/// This ID is not unique across Dioxus VirtualDOMs or across time. IDs will be reused when components are unmounted.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust, ignore
|
||||
/// let mut dom = VirtualDom::new(|cx, props| cx.render(rsx!{ div {} }));
|
||||
/// dom.rebuild();
|
||||
/// let base = dom.base_scope();
|
||||
///
|
||||
/// assert_eq!(base.scope_id(), 0);
|
||||
/// ```
|
||||
pub fn scope_id(&self) -> ScopeId {
|
||||
self.our_arena_idx
|
||||
}
|
||||
|
||||
/// Create a subscription that schedules a future render for the reference component
|
||||
///
|
||||
/// ## Notice: you should prefer using prepare_update and get_scope_id
|
||||
pub fn schedule_update(&self) -> Rc<dyn Fn() + 'static> {
|
||||
let (chan, id) = (self.sender.clone(), self.scope_id());
|
||||
Rc::new(move || {
|
||||
let _ = chan.unbounded_send(SchedulerMsg::Immediate(id));
|
||||
})
|
||||
}
|
||||
|
||||
/// Schedule an update for any component given its ScopeId.
|
||||
///
|
||||
/// A component's ScopeId can be obtained from `use_hook` or the [`Context::scope_id`] method.
|
||||
///
|
||||
/// This method should be used when you want to schedule an update for a component
|
||||
pub fn schedule_update_any(&self) -> Rc<dyn Fn(ScopeId)> {
|
||||
let chan = self.sender.clone();
|
||||
Rc::new(move |id| {
|
||||
let _ = chan.unbounded_send(SchedulerMsg::Immediate(id));
|
||||
})
|
||||
}
|
||||
|
||||
/// Get the [`ScopeId`] of a mounted component.
|
||||
///
|
||||
/// `ScopeId` is not unique for the lifetime of the VirtualDom - a ScopeId will be reused if a component is unmounted.
|
||||
pub fn needs_update(&self) {
|
||||
self.needs_update_any(self.scope_id())
|
||||
}
|
||||
|
||||
/// Get the [`ScopeId`] of a mounted component.
|
||||
///
|
||||
/// `ScopeId` is not unique for the lifetime of the VirtualDom - a ScopeId will be reused if a component is unmounted.
|
||||
pub fn needs_update_any(&self, id: ScopeId) {
|
||||
let _ = self.sender.unbounded_send(SchedulerMsg::Immediate(id));
|
||||
}
|
||||
|
||||
/// Get the Root Node of this scope
|
||||
pub fn root_node(&self) -> &VNode {
|
||||
let node = unsafe { &*self.fin_frame().node.get() };
|
||||
unsafe { std::mem::transmute(node) }
|
||||
}
|
||||
|
||||
/// This method enables the ability to expose state to children further down the VirtualDOM Tree.
|
||||
///
|
||||
/// This is a "fundamental" operation and should only be called during initialization of a hook.
|
||||
///
|
||||
/// For a hook that provides the same functionality, use `use_provide_state` and `use_consume_state` instead.
|
||||
///
|
||||
/// When the component is dropped, so is the context. Be aware of this behavior when consuming
|
||||
/// the context via Rc/Weak.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust, ignore
|
||||
/// struct SharedState(&'static str);
|
||||
///
|
||||
/// static App: Component<()> = |cx, props|{
|
||||
/// cx.use_hook(|_| cx.provide_state(SharedState("world")), |_| {}, |_| {});
|
||||
/// rsx!(cx, Child {})
|
||||
/// }
|
||||
///
|
||||
/// static Child: Component<()> = |cx| {
|
||||
/// let state = cx.consume_state::<SharedState>();
|
||||
/// rsx!(cx, div { "hello {state.0}" })
|
||||
/// }
|
||||
/// ```
|
||||
pub fn provide_state<T: 'static>(&self, value: T) {
|
||||
self.shared_contexts
|
||||
.borrow_mut()
|
||||
.insert(TypeId::of::<T>(), Rc::new(value))
|
||||
.map(|f| f.downcast::<T>().ok())
|
||||
.flatten();
|
||||
}
|
||||
|
||||
/// Try to retrieve a SharedState with type T from the any parent Scope.
|
||||
pub fn consume_state<T: 'static>(&self) -> Option<Rc<T>> {
|
||||
if let Some(shared) = self.shared_contexts.borrow().get(&TypeId::of::<T>()) {
|
||||
Some(shared.clone().downcast::<T>().unwrap())
|
||||
} else {
|
||||
let mut search_parent = self.parent_scope;
|
||||
|
||||
while let Some(parent_ptr) = search_parent {
|
||||
// safety: all parent pointers are valid thanks to the bump arena
|
||||
let parent = unsafe { &*parent_ptr };
|
||||
if let Some(shared) = parent.shared_contexts.borrow().get(&TypeId::of::<T>()) {
|
||||
return Some(shared.clone().downcast::<T>().unwrap());
|
||||
}
|
||||
search_parent = parent.parent_scope;
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Pushes the future onto the poll queue to be polled after the component renders.
|
||||
///
|
||||
/// The future is forcibly dropped if the component is not ready by the next render
|
||||
pub fn push_task<'src, F>(&'src self, fut: impl FnOnce() -> F + 'src) -> usize
|
||||
where
|
||||
F: Future<Output = ()>,
|
||||
F::Output: 'src,
|
||||
F: 'src,
|
||||
{
|
||||
self.sender
|
||||
.unbounded_send(SchedulerMsg::NewTask(self.our_arena_idx))
|
||||
.unwrap();
|
||||
|
||||
// wrap it in a type that will actually drop the contents
|
||||
//
|
||||
// Safety: we just made the pointer above and will promise not to alias it!
|
||||
// The main reason we do this through from_raw is because Bumpalo's box does
|
||||
// not support unsized coercion
|
||||
let fut: &mut dyn Future<Output = ()> = self.bump().alloc(fut());
|
||||
let boxed_fut: BumpBox<dyn Future<Output = ()>> = unsafe { BumpBox::from_raw(fut) };
|
||||
let pinned_fut: Pin<BumpBox<_>> = boxed_fut.into();
|
||||
|
||||
// erase the 'src lifetime for self-referential storage
|
||||
// todo: provide a miri test around this
|
||||
// concerned about segfaulting
|
||||
let self_ref_fut = unsafe { std::mem::transmute(pinned_fut) };
|
||||
|
||||
// Push the future into the tasks
|
||||
let mut items = self.items.borrow_mut();
|
||||
items.tasks.push(self_ref_fut);
|
||||
items.tasks.len() - 1
|
||||
}
|
||||
|
||||
/// Take a lazy VNode structure and actually build it with the context of the VDom's efficient VNode allocator.
|
||||
///
|
||||
/// This function consumes the context and absorb the lifetime, so these VNodes *must* be returned.
|
||||
///
|
||||
/// ## Example
|
||||
///
|
||||
/// ```ignore
|
||||
/// fn Component(cx: Scope<Props>) -> Element {
|
||||
/// // Lazy assemble the VNode tree
|
||||
/// let lazy_nodes = rsx!("hello world");
|
||||
///
|
||||
/// // Actually build the tree and allocate it
|
||||
/// cx.render(lazy_tree)
|
||||
/// }
|
||||
///```
|
||||
pub fn render<'src>(&'src self, rsx: Option<LazyNodes<'src, '_>>) -> Option<VNode<'src>> {
|
||||
let fac = NodeFactory {
|
||||
bump: &self.wip_frame().bump,
|
||||
};
|
||||
match rsx {
|
||||
Some(s) => Some(s.call(fac)),
|
||||
None => todo!("oh no no nodes"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Store a value between renders
|
||||
///
|
||||
/// This is *the* foundational hook for all other hooks.
|
||||
///
|
||||
/// - Initializer: closure used to create the initial hook state
|
||||
/// - Runner: closure used to output a value every time the hook is used
|
||||
///
|
||||
/// To "cleanup" the hook, implement `Drop` on the stored hook value. Whenever the component is dropped, the hook
|
||||
/// will be dropped as well.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```ignore
|
||||
/// // use_ref is the simplest way of storing a value between renders
|
||||
/// fn use_ref<T: 'static>(initial_value: impl FnOnce() -> T) -> &RefCell<T> {
|
||||
/// use_hook(
|
||||
/// || Rc::new(RefCell::new(initial_value())),
|
||||
/// |state| state,
|
||||
/// )
|
||||
/// }
|
||||
/// ```
|
||||
pub fn use_hook<'src, State: 'static, Output: 'src>(
|
||||
&'src self,
|
||||
initializer: impl FnOnce(usize) -> State,
|
||||
runner: impl FnOnce(&'src mut State) -> Output,
|
||||
) -> Output {
|
||||
let mut vals = self.hook_vals.borrow_mut();
|
||||
|
||||
let hook_len = vals.len();
|
||||
let cur_idx = self.hook_idx.get();
|
||||
|
||||
if cur_idx >= hook_len {
|
||||
vals.push(self.hook_arena.alloc(initializer(hook_len)));
|
||||
}
|
||||
|
||||
let state = vals
|
||||
.get(cur_idx)
|
||||
.and_then(|inn| {
|
||||
self.hook_idx.set(cur_idx + 1);
|
||||
let raw_box = unsafe { &mut **inn };
|
||||
raw_box.downcast_mut::<State>()
|
||||
})
|
||||
.expect(
|
||||
r###"
|
||||
Unable to retrieve the hook that was initialized at this index.
|
||||
Consult the `rules of hooks` to understand how to use hooks properly.
|
||||
|
||||
You likely used the hook in a conditional. Hooks rely on consistent ordering between renders.
|
||||
Functions prefixed with "use" should never be called conditionally.
|
||||
"###,
|
||||
);
|
||||
|
||||
runner(state)
|
||||
}
|
||||
|
||||
/// The "work in progress frame" represents the frame that is currently being worked on.
|
||||
pub(crate) fn wip_frame(&self) -> &BumpFrame {
|
||||
match self.generation.get() & 1 == 0 {
|
||||
true => &self.frames[0],
|
||||
false => &self.frames[1],
|
||||
}
|
||||
}
|
||||
|
||||
/// Mutable access to the "work in progress frame" - used to clear it
|
||||
pub(crate) fn wip_frame_mut(&mut self) -> &mut BumpFrame {
|
||||
match self.generation.get() & 1 == 0 {
|
||||
true => &mut self.frames[0],
|
||||
false => &mut self.frames[1],
|
||||
}
|
||||
}
|
||||
|
||||
/// Access to the frame where finalized nodes existed
|
||||
pub(crate) fn fin_frame(&self) -> &BumpFrame {
|
||||
match self.generation.get() & 1 == 1 {
|
||||
true => &self.frames[0],
|
||||
false => &self.frames[1],
|
||||
}
|
||||
}
|
||||
|
||||
/// Reset this component's frame
|
||||
///
|
||||
/// # Safety:
|
||||
///
|
||||
/// This method breaks every reference of VNodes in the current frame.
|
||||
///
|
||||
/// Calling reset itself is not usually a big deal, but we consider it important
|
||||
/// due to the complex safety guarantees we need to uphold.
|
||||
pub(crate) unsafe fn reset_wip_frame(&mut self) {
|
||||
self.wip_frame_mut().bump.reset();
|
||||
}
|
||||
|
||||
/// Cycle to the next generation
|
||||
pub(crate) fn cycle_frame(&self) {
|
||||
self.generation.set(self.generation.get() + 1);
|
||||
}
|
||||
|
||||
/// Get the [`Bump`] of the WIP frame.
|
||||
pub(crate) fn bump(&self) -> &Bump {
|
||||
&self.wip_frame().bump
|
||||
}
|
||||
|
||||
// todo: disable bookkeeping on drop (unncessary)
|
||||
pub(crate) fn reset(&mut self) {
|
||||
// first: book keaping
|
||||
self.hook_idx.set(0);
|
||||
self.parent_scope = None;
|
||||
self.generation.set(0);
|
||||
self.is_subtree_root.set(false);
|
||||
self.subtree.set(0);
|
||||
|
||||
// next: shared context data
|
||||
self.shared_contexts.get_mut().clear();
|
||||
|
||||
// next: reset the node data
|
||||
let SelfReferentialItems {
|
||||
borrowed_props,
|
||||
listeners,
|
||||
tasks,
|
||||
} = self.items.get_mut();
|
||||
borrowed_props.clear();
|
||||
listeners.clear();
|
||||
tasks.clear();
|
||||
self.frames[0].reset();
|
||||
self.frames[1].reset();
|
||||
|
||||
// Finally, free up the hook values
|
||||
self.hook_arena.reset();
|
||||
self.hook_vals.get_mut().drain(..).for_each(|state| {
|
||||
let as_mut = unsafe { &mut *state };
|
||||
let boxed = unsafe { bumpalo::boxed::Box::from_raw(as_mut) };
|
||||
drop(boxed);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) struct BumpFrame {
|
||||
pub bump: Bump,
|
||||
pub node: Cell<*const VNode<'static>>,
|
||||
}
|
||||
impl BumpFrame {
|
||||
pub(crate) fn new(capacity: usize) -> Self {
|
||||
let bump = Bump::with_capacity(capacity);
|
||||
|
||||
let node = &*bump.alloc(VText {
|
||||
text: "placeholdertext",
|
||||
dom_id: Default::default(),
|
||||
is_static: false,
|
||||
});
|
||||
let node = bump.alloc(VNode::Text(unsafe { std::mem::transmute(node) }));
|
||||
let nodes = Cell::new(node as *const _);
|
||||
Self { bump, node: nodes }
|
||||
}
|
||||
|
||||
pub(crate) fn reset(&mut self) {
|
||||
self.bump.reset();
|
||||
let node = self.bump.alloc(VText {
|
||||
text: "placeholdertext",
|
||||
dom_id: Default::default(),
|
||||
is_static: false,
|
||||
});
|
||||
let node = self
|
||||
.bump
|
||||
.alloc(VNode::Text(unsafe { std::mem::transmute(node) }));
|
||||
self.node.set(node as *const _);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sizeof() {
|
||||
dbg!(std::mem::size_of::<ScopeState>());
|
||||
}
|
||||
Reference in new issue
Block a user