swaits/dioxus
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use lockless in editqueue

Browse Source
This commit is contained in:
Jonathan Kelley committed 2024-01-18 04:19:17 -08:00
1 parent 94b17cc8ca
commit 2ed763e660
1 file changed
+8 -137
Download Patch File Download Diff File Expand all files Collapse all files
packages/desktop/src/edits.rs
+8 -137
View File
@@ -1,4 +1,4 @@
use std::{sync::Arc, sync::Mutex};
use std::{cell::RefCell, rc::Rc, sync::Arc, sync::Mutex};
use std::fmt::{Debug, Formatter};
@@ -6,8 +6,8 @@ use std::fmt::{Debug, Formatter};
/// It will hold onto the requests until the interpreter is ready to handle them and hold onto any pending edits until a new request is made.
#[derive(Default, Clone)]
pub(crate) struct EditQueue {
queue: Arc<Mutex<Vec<Vec<u8>>>>,
responder: Arc<Mutex<Option<wry::RequestAsyncResponder>>>,
queue: Rc<RefCell<Vec<Vec<u8>>>>,
responder: Rc<RefCell<Option<wry::RequestAsyncResponder>>>,
}
impl Debug for EditQueue {
@@ -15,7 +15,7 @@ impl Debug for EditQueue {
f.debug_struct("EditQueue")
.field("queue", &self.queue)
.field("responder", {
&self.responder.lock().unwrap().as_ref().map(|_| ())
&self.responder.borrow().as_ref().map(|_| ())
})
.finish()
}
@@ -23,149 +23,20 @@ impl Debug for EditQueue {
impl EditQueue {
pub fn handle_request(&self, responder: wry::RequestAsyncResponder) {
let mut queue = self.queue.lock().unwrap();
let mut queue = self.queue.borrow_mut();
if let Some(bytes) = queue.pop() {
responder.respond(wry::http::Response::new(bytes));
} else {
*self.responder.lock().unwrap() = Some(responder);
*self.responder.borrow_mut() = Some(responder);
}
}
pub fn add_edits(&self, edits: Vec<u8>) {
let mut responder = self.responder.lock().unwrap();
let mut responder = self.responder.borrow_mut();
if let Some(responder) = responder.take() {
responder.respond(wry::http::Response::new(edits));
} else {
self.queue.lock().unwrap().push(edits);
self.queue.borrow_mut().push(edits);
}
}
}
// pub(crate) fn apply_edits(
// mutations: Mutations,
// channel: &mut Channel,
// templates: &mut FxHashMap<String, u16>,
// max_template_count: &AtomicU16,
// ) -> Option<Vec<u8>> {
// if mutations.templates.is_empty() && mutations.edits.is_empty() {
// return None;
// }
// for template in mutations.templates {
// add_template(&template, channel, templates, max_template_count);
// }
// use dioxus_core::Mutation::*;
// for edit in mutations.edits {
// match edit {
// AppendChildren { id, m } => channel.append_children(id.0 as u32, m as u16),
// AssignId { path, id } => channel.assign_id(path, id.0 as u32),
// CreatePlaceholder { id } => channel.create_placeholder(id.0 as u32),
// CreateTextNode { value, id } => channel.create_text_node(value, id.0 as u32),
// HydrateText { path, value, id } => channel.hydrate_text(path, value, id.0 as u32),
// LoadTemplate { name, index, id } => {
// if let Some(tmpl_id) = templates.get(name) {
// channel.load_template(*tmpl_id, index as u16, id.0 as u32)
// }
// }
// ReplaceWith { id, m } => channel.replace_with(id.0 as u32, m as u16),
// ReplacePlaceholder { path, m } => channel.replace_placeholder(path, m as u16),
// InsertAfter { id, m } => channel.insert_after(id.0 as u32, m as u16),
// InsertBefore { id, m } => channel.insert_before(id.0 as u32, m as u16),
// SetAttribute {
// name,
// value,
// id,
// ns,
// } => match value {
// AttributeValue::Text(txt) => {
// channel.set_attribute(id.0 as u32, name, txt, ns.unwrap_or_default())
// }
// AttributeValue::Float(f) => {
// channel.set_attribute(id.0 as u32, name, &f.to_string(), ns.unwrap_or_default())
// }
// AttributeValue::Int(n) => {
// channel.set_attribute(id.0 as u32, name, &n.to_string(), ns.unwrap_or_default())
// }
// AttributeValue::Bool(b) => channel.set_attribute(
// id.0 as u32,
// name,
// if b { "true" } else { "false" },
// ns.unwrap_or_default(),
// ),
// AttributeValue::None => {
// channel.remove_attribute(id.0 as u32, name, ns.unwrap_or_default())
// }
// _ => unreachable!(),
// },
// SetText { value, id } => channel.set_text(id.0 as u32, value),
// NewEventListener { name, id, .. } => {
// channel.new_event_listener(name, id.0 as u32, event_bubbles(name) as u8)
// }
// RemoveEventListener { name, id } => {
// channel.remove_event_listener(name, id.0 as u32, event_bubbles(name) as u8)
// }
// Remove { id } => channel.remove(id.0 as u32),
// PushRoot { id } => channel.push_root(id.0 as u32),
// }
// }
// let bytes: Vec<_> = channel.export_memory().collect();
// channel.reset();
// Some(bytes)
// }
// pub fn add_template(
// template: &Template,
// channel: &mut Channel,
// templates: &mut FxHashMap<String, u16>,
// max_template_count: &AtomicU16,
// ) {
// let current_max_template_count = max_template_count.load(Ordering::Relaxed);
// for root in template.roots.iter() {
// create_template_node(channel, root);
// templates.insert(template.name.to_owned(), current_max_template_count);
// }
// channel.add_templates(current_max_template_count, template.roots.len() as u16);
// max_template_count.fetch_add(1, Ordering::Relaxed);
// }
// pub fn create_template_node(channel: &mut Channel, node: &'static TemplateNode) {
// use TemplateNode::*;
// match node {
// Element {
// tag,
// namespace,
// attrs,
// children,
// ..
// } => {
// // Push the current node onto the stack
// match namespace {
// Some(ns) => channel.create_element_ns(tag, ns),
// None => channel.create_element(tag),
// }
// // Set attributes on the current node
// for attr in *attrs {
// if let TemplateAttribute::Static {
// name,
// value,
// namespace,
// } = attr
// {
// channel.set_top_attribute(name, value, namespace.unwrap_or_default())
// }
// }
// // Add each child to the stack
// for child in *children {
// create_template_node(channel, child);
// }
// // Add all children to the parent
// channel.append_children_to_top(children.len() as u16);
// }
// Text { text } => channel.create_raw_text(text),
// DynamicText { .. } => channel.create_raw_text("p"),
// Dynamic { .. } => channel.add_placeholder(),
// }
// }