dioxus/packages/core/src/nodes.rs

218 lines
5.8 KiB
Rust
Raw Normal View History

2022-11-06 22:28:41 +00:00
use crate::{any_props::AnyProps, arena::ElementId, ScopeState};
2022-11-03 00:29:18 +00:00
use std::{
2022-11-04 00:34:42 +00:00
any::{Any, TypeId},
2022-11-03 00:29:18 +00:00
cell::{Cell, RefCell},
hash::Hasher,
};
pub type TemplateId = &'static str;
/// A reference to a template along with any context needed to hydrate it
2022-11-02 01:42:29 +00:00
pub struct VNode<'a> {
// The ID assigned for the root of this template
pub node_id: Cell<ElementId>,
2022-11-03 08:24:20 +00:00
pub key: Option<&'a str>,
2022-11-03 00:29:18 +00:00
// When rendered, this template will be linked to its parent manually
2022-11-02 01:42:29 +00:00
pub parent: Option<(*mut VNode<'static>, usize)>,
2022-11-02 08:00:37 +00:00
pub template: Template<'static>,
pub root_ids: &'a [Cell<ElementId>],
2022-11-03 00:29:18 +00:00
pub dynamic_nodes: &'a [DynamicNode<'a>],
2022-11-03 00:29:18 +00:00
pub dynamic_attrs: &'a [Attribute<'a>],
}
2022-11-06 22:28:41 +00:00
impl<'a> VNode<'a> {
pub fn single_component(
cx: &'a ScopeState,
node: DynamicNode<'a>,
id: &'static str,
) -> Option<Self> {
Some(VNode {
node_id: Cell::new(ElementId(0)),
key: None,
parent: None,
root_ids: &[],
dynamic_nodes: cx.bump().alloc([node]),
dynamic_attrs: &[],
template: Template {
id,
roots: &[TemplateNode::Dynamic(0)],
node_paths: &[&[0]],
attr_paths: &[],
},
})
}
2022-11-08 06:55:22 +00:00
pub fn single_text(
cx: &'a ScopeState,
text: &'static [TemplateNode<'static>],
id: &'static str,
) -> Option<Self> {
Some(VNode {
node_id: Cell::new(ElementId(0)),
key: None,
parent: None,
root_ids: &[],
dynamic_nodes: &[],
dynamic_attrs: &[],
template: Template {
id,
roots: text,
node_paths: &[&[0]],
attr_paths: &[],
},
})
}
2022-11-06 22:28:41 +00:00
}
#[derive(Debug, Clone, Copy)]
2022-11-02 08:00:37 +00:00
pub struct Template<'a> {
pub id: &'a str,
pub roots: &'a [TemplateNode<'a>],
2022-11-03 08:24:20 +00:00
pub node_paths: &'a [&'a [u8]],
pub attr_paths: &'a [&'a [u8]],
2022-11-02 08:00:37 +00:00
}
impl<'a> std::hash::Hash for Template<'a> {
fn hash<H: Hasher>(&self, state: &mut H) {
self.id.hash(state);
}
}
2022-11-08 06:55:22 +00:00
impl Eq for Template<'_> {}
2022-11-02 08:00:37 +00:00
impl PartialEq for Template<'_> {
fn eq(&self, other: &Self) -> bool {
self.id == other.id
}
}
/// A weird-ish variant of VNodes with way more limited types
#[derive(Debug, Clone, Copy)]
pub enum TemplateNode<'a> {
Element {
tag: &'a str,
namespace: Option<&'a str>,
attrs: &'a [TemplateAttribute<'a>],
children: &'a [TemplateNode<'a>],
},
Text(&'a str),
Dynamic(usize),
DynamicText(usize),
}
2022-11-03 08:24:20 +00:00
pub enum DynamicNode<'a> {
Component {
name: &'static str,
2022-11-06 22:28:41 +00:00
static_props: bool,
2022-11-04 00:34:42 +00:00
props: Cell<*mut dyn AnyProps<'a>>,
2022-11-04 05:30:26 +00:00
placeholder: Cell<Option<ElementId>>,
},
Text {
id: Cell<ElementId>,
2022-11-02 08:00:37 +00:00
value: &'a str,
},
2022-11-04 00:34:42 +00:00
Fragment(&'a [VNode<'a>]),
Placeholder(Cell<ElementId>),
}
#[derive(Debug)]
2022-11-02 08:00:37 +00:00
pub enum TemplateAttribute<'a> {
Static {
name: &'static str,
value: &'a str,
namespace: Option<&'static str>,
volatile: bool,
},
2022-11-03 08:24:20 +00:00
Dynamic(usize),
}
pub struct Attribute<'a> {
2022-11-03 00:29:18 +00:00
pub name: &'a str,
pub value: AttributeValue<'a>,
pub namespace: Option<&'static str>,
2022-11-03 00:29:18 +00:00
pub mounted_element: Cell<ElementId>,
2022-11-03 08:24:20 +00:00
pub volatile: bool,
}
pub enum AttributeValue<'a> {
Text(&'a str),
Float(f32),
Int(i32),
Bool(bool),
2022-11-03 00:29:18 +00:00
Listener(RefCell<&'a mut dyn FnMut(&dyn Any)>),
Any(&'a dyn AnyValue),
2022-11-03 00:29:18 +00:00
None,
}
2022-11-04 00:34:42 +00:00
impl<'a> std::fmt::Debug for AttributeValue<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Text(arg0) => f.debug_tuple("Text").field(arg0).finish(),
Self::Float(arg0) => f.debug_tuple("Float").field(arg0).finish(),
Self::Int(arg0) => f.debug_tuple("Int").field(arg0).finish(),
Self::Bool(arg0) => f.debug_tuple("Bool").field(arg0).finish(),
2022-11-08 06:55:22 +00:00
Self::Listener(_) => f.debug_tuple("Listener").finish(),
Self::Any(_) => f.debug_tuple("Any").finish(),
2022-11-04 00:34:42 +00:00
Self::None => write!(f, "None"),
}
}
}
impl<'a> PartialEq for AttributeValue<'a> {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(Self::Text(l0), Self::Text(r0)) => l0 == r0,
(Self::Float(l0), Self::Float(r0)) => l0 == r0,
(Self::Int(l0), Self::Int(r0)) => l0 == r0,
(Self::Bool(l0), Self::Bool(r0)) => l0 == r0,
2022-11-08 06:55:22 +00:00
(Self::Listener(_), Self::Listener(_)) => true,
2022-11-04 00:34:42 +00:00
(Self::Any(l0), Self::Any(r0)) => l0.any_cmp(*r0),
_ => core::mem::discriminant(self) == core::mem::discriminant(other),
}
}
}
2022-11-03 00:29:18 +00:00
impl<'a> AttributeValue<'a> {
2022-11-04 00:34:42 +00:00
pub fn matches_type(&self, other: &'a AttributeValue<'a>) -> bool {
match (self, other) {
(Self::Text(_), Self::Text(_)) => true,
(Self::Float(_), Self::Float(_)) => true,
(Self::Int(_), Self::Int(_)) => true,
(Self::Bool(_), Self::Bool(_)) => true,
(Self::Listener(_), Self::Listener(_)) => true,
(Self::Any(_), Self::Any(_)) => true,
_ => return false,
}
}
}
pub trait AnyValue {
2022-11-04 00:34:42 +00:00
fn any_cmp(&self, other: &dyn AnyValue) -> bool;
fn our_typeid(&self) -> TypeId;
}
2022-11-08 06:55:22 +00:00
impl<T: PartialEq + Any> AnyValue for T {
2022-11-04 00:34:42 +00:00
fn any_cmp(&self, other: &dyn AnyValue) -> bool {
if self.type_id() != other.our_typeid() {
return false;
}
self == unsafe { &*(other as *const _ as *const T) }
}
2022-11-04 00:34:42 +00:00
fn our_typeid(&self) -> TypeId {
self.type_id()
}
}
#[test]
fn what_are_the_sizes() {
2022-11-02 01:42:29 +00:00
dbg!(std::mem::size_of::<VNode>());
dbg!(std::mem::size_of::<Template>());
dbg!(std::mem::size_of::<TemplateNode>());
}