120 lines
4.4 KiB
Rust
120 lines
4.4 KiB
Rust
// let scope = diff_machine.get_scope_mut(&trigger.originator).unwrap();
|
|
|
|
// let mut garbage_list = scope.consume_garbage();
|
|
|
|
// let mut scopes_to_kill = Vec::new();
|
|
// while let Some(node) = garbage_list.pop() {
|
|
// match &node.kind {
|
|
// VNodeKind::Text(_) => {
|
|
// self.shared.collect_garbage(node.direct_id());
|
|
// }
|
|
// VNodeKind::Anchor(_) => {
|
|
// self.shared.collect_garbage(node.direct_id());
|
|
// }
|
|
// VNodeKind::Suspended(_) => {
|
|
// self.shared.collect_garbage(node.direct_id());
|
|
// }
|
|
|
|
// VNodeKind::Element(el) => {
|
|
// self.shared.collect_garbage(node.direct_id());
|
|
// for child in el.children {
|
|
// garbage_list.push(child);
|
|
// }
|
|
// }
|
|
|
|
// VNodeKind::Fragment(frag) => {
|
|
// for child in frag.children {
|
|
// garbage_list.push(child);
|
|
// }
|
|
// }
|
|
|
|
// VNodeKind::Component(comp) => {
|
|
// // TODO: run the hook destructors and then even delete the scope
|
|
|
|
// let scope_id = comp.ass_scope.get().unwrap();
|
|
// let scope = self.get_scope(scope_id).unwrap();
|
|
// let root = scope.root();
|
|
// garbage_list.push(root);
|
|
// scopes_to_kill.push(scope_id);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// for scope in scopes_to_kill {
|
|
// // oy kill em
|
|
// log::debug!("should be removing scope {:#?}", scope);
|
|
// }
|
|
|
|
// // On the primary event queue, there is no batching, we take them off one-by-one
|
|
// let trigger = match receiver.try_next() {
|
|
// Ok(Some(trigger)) => trigger,
|
|
// _ => {
|
|
// // Continuously poll the future pool and the event receiver for work
|
|
// let mut tasks = self.shared.async_tasks.borrow_mut();
|
|
// let tasks_tasks = tasks.next();
|
|
|
|
// // if the new event generates work more important than our current fiber, we should consider switching
|
|
// // only switch if it impacts different scopes.
|
|
// let mut ui_receiver = self.shared.ui_event_receiver.borrow_mut();
|
|
// let ui_reciv_task = ui_receiver.next();
|
|
|
|
// // right now, this polling method will only catch batched set_states that don't get awaited.
|
|
// // However, in the future, we might be interested in batching set_states across await points
|
|
// let immediate_tasks = ();
|
|
|
|
// futures_util::pin_mut!(tasks_tasks);
|
|
// futures_util::pin_mut!(ui_reciv_task);
|
|
|
|
// // Poll the event receiver and the future pool for work
|
|
// // Abort early if our deadline has ran out
|
|
// let mut deadline = (&mut deadline_future).fuse();
|
|
|
|
// let trig = futures_util::select! {
|
|
// trigger = tasks_tasks => trigger,
|
|
// trigger = ui_reciv_task => trigger,
|
|
|
|
// // abort if we're out of time
|
|
// _ = deadline => { return Ok(diff_machine.mutations); }
|
|
// };
|
|
|
|
// trig.unwrap()
|
|
// }
|
|
// };
|
|
|
|
// async fn select_next_event(&mut self) -> Option<EventTrigger> {
|
|
// let mut receiver = self.shared.task_receiver.borrow_mut();
|
|
|
|
// // drain the in-flight events so that we can sort them out with the current events
|
|
// while let Ok(Some(trigger)) = receiver.try_next() {
|
|
// log::info!("retrieving event from receiver");
|
|
// let key = self.shared.make_trigger_key(&trigger);
|
|
// self.pending_events.insert(key, trigger);
|
|
// }
|
|
|
|
// if self.pending_events.is_empty() {
|
|
// // Continuously poll the future pool and the event receiver for work
|
|
// let mut tasks = self.shared.async_tasks.borrow_mut();
|
|
// let tasks_tasks = tasks.next();
|
|
|
|
// let mut receiver = self.shared.task_receiver.borrow_mut();
|
|
// let reciv_task = receiver.next();
|
|
|
|
// futures_util::pin_mut!(tasks_tasks);
|
|
// futures_util::pin_mut!(reciv_task);
|
|
|
|
// let trigger = match futures_util::future::select(tasks_tasks, reciv_task).await {
|
|
// futures_util::future::Either::Left((trigger, _)) => trigger,
|
|
// futures_util::future::Either::Right((trigger, _)) => trigger,
|
|
// }
|
|
// .unwrap();
|
|
// let key = self.shared.make_trigger_key(&trigger);
|
|
// self.pending_events.insert(key, trigger);
|
|
// }
|
|
|
|
// // pop the most important event off
|
|
// let key = self.pending_events.keys().next().unwrap().clone();
|
|
// let trigger = self.pending_events.remove(&key).unwrap();
|
|
|
|
// Some(trigger)
|
|
// }
|