mirror of
https://github.com/DioxusLabs/dioxus
synced 2024-12-22 02:23:05 +00:00
110 lines
3.5 KiB
Rust
110 lines
3.5 KiB
Rust
use crate::inner::*;
|
|
use crate::nodes::VNode;
|
|
use crate::{context::hooks::Hook, diff::diff};
|
|
use bumpalo::Bump;
|
|
use generational_arena::Index;
|
|
use std::{
|
|
any::TypeId, borrow::Borrow, cell::RefCell, future::Future, marker::PhantomData,
|
|
sync::atomic::AtomicUsize,
|
|
};
|
|
|
|
/// Every component in Dioxus is represented by a `Scope`.
|
|
///
|
|
/// 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.
|
|
pub struct Scope {
|
|
// TODO @Jon
|
|
// These hooks are actually references into the hook arena
|
|
// These two could be combined with "OwningRef" to remove unsafe usage
|
|
// could also use ourborous
|
|
hooks: RefCell<Vec<*mut Hook>>,
|
|
hook_arena: typed_arena::Arena<Hook>,
|
|
|
|
// Map to the parent
|
|
parent: Option<Index>,
|
|
|
|
// todo, do better with the active frame stuff
|
|
frames: [Bump; 2],
|
|
|
|
// somehow build this vnode with a lifetime tied to self
|
|
cur_node: *mut VNode<'static>,
|
|
|
|
active_frame: u8,
|
|
|
|
// IE Which listeners need to be woken up?
|
|
listeners: Vec<Box<dyn Fn()>>,
|
|
|
|
//
|
|
props_type: TypeId,
|
|
caller: *const i32,
|
|
}
|
|
|
|
impl Scope {
|
|
// create a new scope from a function
|
|
pub(crate) fn new<T: 'static>(f: FC<T>, parent: Option<Index>) -> Self {
|
|
// Capture the props type
|
|
let props_type = TypeId::of::<T>();
|
|
let hook_arena = typed_arena::Arena::new();
|
|
let hooks = RefCell::new(Vec::new());
|
|
|
|
let caller = f as *const i32;
|
|
|
|
let frames = [Bump::new(), Bump::new()];
|
|
|
|
let listeners = Vec::new();
|
|
|
|
let active_frame = 1;
|
|
|
|
let new = frames[0].alloc(VNode::Text(VText::new("")));
|
|
let cur_node = new as *mut _;
|
|
|
|
Self {
|
|
hook_arena,
|
|
hooks,
|
|
props_type,
|
|
caller,
|
|
active_frame,
|
|
listeners,
|
|
parent,
|
|
frames,
|
|
cur_node,
|
|
}
|
|
}
|
|
|
|
/// Create a new context and run the component with references from the Virtual Dom
|
|
/// This function downcasts the function pointer based on the stored props_type
|
|
///
|
|
/// Props is ?Sized because we borrow the props
|
|
pub(crate) fn run<'a, P: Properties + ?Sized>(&self, props: &'a P) {
|
|
let bump = &self.frames[0];
|
|
|
|
let ctx = Context {
|
|
scope: &*self,
|
|
_p: PhantomData {},
|
|
arena: &self.hook_arena,
|
|
hooks: &self.hooks,
|
|
idx: 0.into(),
|
|
bump,
|
|
};
|
|
|
|
/*
|
|
SAFETY ALERT
|
|
|
|
This particular usage of transmute is outlined in its docs https://doc.rust-lang.org/std/mem/fn.transmute.html
|
|
We hide the generic bound on the function item by casting it to raw pointer. When the function is actually called,
|
|
we transmute the function back using the props as reference.
|
|
|
|
we could do a better check to make sure that the TypeID is correct
|
|
--
|
|
This is safe because we check that the generic type matches before casting.
|
|
*/
|
|
let caller = unsafe { std::mem::transmute::<*const i32, FC<P>>(self.caller) };
|
|
let new_nodes = caller(ctx, props);
|
|
let old_nodes: &mut VNode<'static> = unsafe { &mut *self.cur_node };
|
|
|
|
// perform the diff, dumping into the change list
|
|
crate::diff::diff(old_nodes, &new_nodes);
|
|
}
|
|
}
|