//! Object-to-visual dependencies. Cached results never own VM references. use crate::{ block::{self, Kind}, ui_bridge::{UiKind, UiNode}, }; use endor_core::{ChangeBatch, ChangeKey, ObjectRef, ObjectStore, Value, VmError}; use std::{ collections::{HashMap, HashSet, VecDeque}, sync::Arc, }; #[derive(Debug)] struct Cached { node: Arc, dependencies: Vec, children: Vec, } #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] struct Dependency { object: ObjectRef, property: Option, } #[derive(Debug, Default)] pub struct RenderCache { entries: HashMap, dependents: HashMap>, parents: HashMap>, dirty: HashSet, pub last_invalidation: String, pub visited: usize, pub reused: usize, } impl RenderCache { pub fn invalidate(&mut self, batch: ChangeBatch) { let mut queue = VecDeque::new(); if batch.rescan_required { self.last_invalidation = "change journal overflow".into(); queue.extend(self.entries.keys().copied()); } else { for change in batch.changes { let key = Dependency { object: change.object, property: match change.key { ChangeKey::Attribute(name) => Some(name), ChangeKey::Contents => None, }, }; if let Some(owners) = self.dependents.get(&key) { self.last_invalidation = format!("{} {:?}", key.object, key.property); queue.extend(owners); } } } self.invalidate_objects(queue); } pub fn invalidate_objects(&mut self, objects: impl IntoIterator) { let mut queue: VecDeque<_> = objects.into_iter().collect(); while let Some(block) = queue.pop_front() { if self.dirty.insert(block) && let Some(parents) = self.parents.get(&block) { queue.extend(parents); } } } fn remove(&mut self, block: ObjectRef) -> Option { let old = self.entries.remove(&block)?; for source in &old.dependencies { if let Some(owners) = self.dependents.get_mut(source) { owners.remove(&block); if owners.is_empty() { self.dependents.remove(source); } } } for child in &old.children { if let Some(parents) = self.parents.get_mut(child) { parents.remove(&block); if parents.is_empty() { self.parents.remove(child); } } } Some(old) } pub fn prune(&mut self, store: &ObjectStore) { let dead: Vec<_> = self .entries .keys() .filter(|v| store.object(**v).is_err()) .copied() .collect(); for block in dead { self.remove(block); self.dirty.remove(&block); } } pub fn snapshot( &mut self, store: &ObjectStore, root: ObjectRef, ) -> Result, VmError> { self.visited = 0; self.reused = 0; let mut work = vec![(root, false)]; let mut path = HashSet::new(); let mut values = Vec::>::new(); while let Some((block, finish)) = work.pop() { if !finish { if !self.dirty.contains(&block) && let Some(cached) = self.entries.get(&block) { self.reused += 1; values.push(cached.node.clone()); continue; } self.visited += 1; if self.visited > 10_000 { return Err(VmError::ExecutionLimit("expanded Block graph")); } } store.check_typed_instance_storage(block)?; let (data_ref, raw_data, raw_dependencies) = block::resolve_tracked(store, block)?; let data = block::visual_data(store, raw_data)?; let mut dependencies: Vec<_> = raw_dependencies .into_iter() .map(|object| Dependency { object, property: None, }) .collect(); let storage = *store .attribute_path(block)? .last() .expect("nonempty attribute path"); for name in store.typed_method_names(block)? { dependencies.push(Dependency { object: storage, property: Some(name), }); } if let Some(properties) = data.properties { for (name, _) in block::native_properties(&data) { dependencies.push(Dependency { object: properties, property: Some(name.into()), }); } } if !finish { if !path.insert(data_ref) { return Err(VmError::InvalidArgument("cyclic Block composition")); } work.push((block, true)); for child in data.children.iter().rev() { work.push((child.block, false)); } continue; } path.remove(&data_ref); let mut protocol_key = String::new(); let mut custom_event = false; if let Some(definition) = store.type_of(block)? { protocol_key.push_str(&definition.to_string()); for name in ["measure", "arrange", "paint", "hitTest", "onEvent"] { if let Some(method) = store.lookup_method(definition, name)? { let version = store.change_version(method)?; protocol_key.push_str(&format!("/{method}:{version}")); dependencies.push(Dependency { object: method, property: None, }); } } let event = store.lookup_method(definition, "onEvent")?; let mut current = Some(definition); while let Some(definition) = current { dependencies.push(Dependency { object: definition, property: None, }); let item = store.payload::(definition, "Type")?; current = item.base(); } custom_event = event .map(|function| { crate::ui_bridge::is_intrinsic_event(store, function).map(|native| !native) }) .transpose()? .unwrap_or(false); } let mut click_connection = false; for connection in &data.subscriptions { dependencies.push(Dependency { object: *connection, property: None, }); let item = store .payload::(*connection, "Connection")?; click_connection |= item.kind == "click" && item.handler.is_some(); } let children = values.split_off(values.len() - data.children.len()); let kind = match &data.kind { Kind::Text { value, size, color } => { let value = if let Some((source, field)) = &data.text_binding { let storage = store.attribute_path(*source)?; for (index, object) in storage.iter().enumerate() { dependencies.push(Dependency { object: *object, property: (index + 1 == storage.len()).then(|| field.clone()), }); } match store.get_attr(*source, field)? { Value::Nil => "nil".into(), Value::Bool(v) => v.to_string(), Value::Number(v) => v.to_string(), Value::Text(v) => v, Value::Object(v) => { dependencies.push(Dependency { object: v, property: None, }); store.str(v)? } } } else { value.clone() }; UiKind::Text { value, size: *size, color: color.clone(), } } Kind::Rect { width, height, radius, color, } => UiKind::Rect { width: *width, height: *height, radius: *radius, color: color.clone(), }, Kind::Scroll { width, height } => UiKind::Scroll { axis: data.scroll_axis, width: *width, height: *height, padding: data.padding, gap: data.gap, children, }, Kind::Spacer(size) => UiKind::Spacer(*size), Kind::Row => UiKind::Row { padding: data.padding, gap: data.gap, children, }, Kind::Column | Kind::Page => UiKind::Column { padding: data.padding, gap: data.gap, children, }, Kind::Button => UiKind::Button { padding: data.padding, gap: data.gap, children, }, }; let next = UiNode { flex: data.flex, flex_policy: data.flex_policy, main_align: data.main_align, block_id: block.to_string(), protocol_key, slots: data.children.iter().map(|c| c.slot).collect(), interactive: matches!(&data.kind, Kind::Button) || data.click.is_some() || click_connection || custom_event, kind, }; let old = self.remove(block); let node = if let Some(old) = old.as_ref().filter(|old| old.node.shallow_eq(&next)) { old.node.clone() } else { Arc::new(next) }; dependencies.sort_unstable(); dependencies.dedup(); let child_refs: Vec<_> = data.children.iter().map(|child| child.block).collect(); for source in &dependencies { self.dependents .entry(source.clone()) .or_default() .insert(block); } for child in &child_refs { self.parents.entry(*child).or_default().insert(block); } self.entries.insert( block, Cached { node: node.clone(), dependencies, children: child_refs, }, ); self.dirty.remove(&block); values.push(node); } values .pop() .ok_or(VmError::InvalidArgument("empty Block snapshot")) } }