77 lines
2.5 KiB
Rust
77 lines
2.5 KiB
Rust
use crate::nodes::RenderReturn;
|
|
use crate::{Attribute, AttributeValue, VComponent};
|
|
use bumpalo::Bump;
|
|
use std::cell::RefCell;
|
|
use std::cell::{Cell, UnsafeCell};
|
|
|
|
pub(crate) struct BumpFrame {
|
|
pub bump: UnsafeCell<Bump>,
|
|
pub node: Cell<*const RenderReturn<'static>>,
|
|
|
|
// The bump allocator will not call the destructor of the objects it allocated. Attributes and props need to have there destructor called, so we keep a list of them to drop before the bump allocator is reset.
|
|
pub(crate) attributes_to_drop_before_reset: RefCell<Vec<*const Attribute<'static>>>,
|
|
pub(crate) props_to_drop_before_reset: RefCell<Vec<*const VComponent<'static>>>,
|
|
}
|
|
|
|
impl BumpFrame {
|
|
pub(crate) fn new(capacity: usize) -> Self {
|
|
let bump = Bump::with_capacity(capacity);
|
|
Self {
|
|
bump: UnsafeCell::new(bump),
|
|
node: Cell::new(std::ptr::null()),
|
|
attributes_to_drop_before_reset: Default::default(),
|
|
props_to_drop_before_reset: Default::default(),
|
|
}
|
|
}
|
|
|
|
/// Creates a new lifetime out of thin air
|
|
pub(crate) unsafe fn try_load_node<'b>(&self) -> Option<&'b RenderReturn<'b>> {
|
|
let node = self.node.get();
|
|
|
|
if node.is_null() {
|
|
return None;
|
|
}
|
|
|
|
unsafe { std::mem::transmute(&*node) }
|
|
}
|
|
|
|
pub(crate) fn bump(&self) -> &Bump {
|
|
unsafe { &*self.bump.get() }
|
|
}
|
|
|
|
pub(crate) fn add_attribute_to_drop(&self, attribute: *const Attribute<'static>) {
|
|
self.attributes_to_drop_before_reset
|
|
.borrow_mut()
|
|
.push(attribute);
|
|
}
|
|
|
|
/// Reset the bump allocator and drop all the attributes and props that were allocated in it.
|
|
///
|
|
/// # Safety
|
|
/// The caller must insure that no reference to anything allocated in the bump allocator is available after this function is called.
|
|
pub(crate) unsafe fn reset(&self) {
|
|
let mut attributes = self.attributes_to_drop_before_reset.borrow_mut();
|
|
attributes.drain(..).for_each(|attribute| {
|
|
let attribute = unsafe { &*attribute };
|
|
if let AttributeValue::Any(l) = &attribute.value {
|
|
_ = l.take();
|
|
}
|
|
});
|
|
let mut props = self.props_to_drop_before_reset.borrow_mut();
|
|
props.drain(..).for_each(|prop| {
|
|
let prop = unsafe { &*prop };
|
|
_ = prop.props.borrow_mut().take();
|
|
});
|
|
unsafe {
|
|
let bump = &mut *self.bump.get();
|
|
bump.reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Drop for BumpFrame {
|
|
fn drop(&mut self) {
|
|
unsafe { self.reset() }
|
|
}
|
|
}
|