use std::collections::HashMap;
use crate::component::ComponentId;
use crate::ui::Ui;
#[derive(Default)]
pub(crate) struct NameIndex {
scoped: HashMap<ComponentId, HashMap<String, ComponentId>>,
global: Option<HashMap<String, ComponentId>>,
next_suffix: HashMap<(ComponentId, String), u32>,
}
impl Ui {
pub(crate) fn forget_names(&self) {
*self.names.borrow_mut() = NameIndex::default();
}
pub(crate) fn forget_scope(&self, scope: Option<ComponentId>) {
let mut names = self.names.borrow_mut();
names.global = None;
if let Some(scope) = scope {
names.scoped.remove(&scope);
}
}
pub(crate) fn forget_scopes(&self, gone: &[ComponentId]) {
let mut names = self.names.borrow_mut();
if !names.scoped.is_empty() {
for id in gone {
names.scoped.remove(id);
}
}
if !names.next_suffix.is_empty() {
let gone: std::collections::HashSet<&ComponentId> = gone.iter().collect();
names.next_suffix.retain(|(scope, _), _| !gone.contains(scope));
}
}
pub(crate) fn names_removed(&self, scope: Option<ComponentId>, items: &[(ComponentId, String)]) {
let mut names = self.names.borrow_mut();
names.global = None;
let Some(map) = scope.and_then(|s| names.scoped.get_mut(&s)) else { return };
for (id, name) in items {
let key = name.to_ascii_lowercase();
if map.get(&key) == Some(id) {
map.remove(&key);
}
}
}
pub(crate) fn names_added(&self, scope: Option<ComponentId>, items: &[(ComponentId, String)]) {
let mut names = self.names.borrow_mut();
names.global = None;
let Some(scope) = scope else { return };
let Some(map) = names.scoped.get_mut(&scope) else { return };
let mut clash = false;
for (id, name) in items.iter().filter(|(_, n)| !n.is_empty()) {
let key = name.to_ascii_lowercase();
match map.get(&key) {
Some(other) if other != id => clash = true,
Some(_) => {}
None => {
map.insert(key, *id);
}
}
}
if clash {
names.scoped.remove(&scope);
}
}
pub(crate) fn next_suffix(&self, scope: ComponentId, base: &str) -> u32 {
self.names.borrow().next_suffix.get(&(scope, base.to_ascii_lowercase())).copied().unwrap_or(2)
}
pub(crate) fn set_next_suffix(&self, scope: ComponentId, base: &str, next: u32) {
self.names.borrow_mut().next_suffix.insert((scope, base.to_ascii_lowercase()), next);
}
pub(crate) fn names_with(&self, id: ComponentId) -> Vec<(ComponentId, String)> {
let mut ids = Vec::new();
self.collect_scope(id, &mut ids);
ids.into_iter().filter_map(|c| self.name(c).filter(|n| !n.is_empty()).map(|n| (c, n.to_string()))).collect()
}
pub(crate) fn indexed_find(&self, name: &str) -> Option<ComponentId> {
let key = name.to_ascii_lowercase();
if self.names.borrow().global.is_none() {
let global = self.build_global();
self.names.borrow_mut().global = Some(global);
}
let found = self.names.borrow().global.as_ref().and_then(|g| g.get(&key).copied());
if cfg!(debug_assertions) {
let fresh = self.roots().iter().find_map(|&r| self.find_deep(r, name));
if fresh != found {
return self.stale_names(name, fresh);
}
}
found
}
pub(crate) fn indexed_find_in_scope(&self, scope: ComponentId, name: &str) -> Option<ComponentId> {
let key = name.to_ascii_lowercase();
if !self.names.borrow().scoped.contains_key(&scope) {
let index = self.build_scope(scope);
self.names.borrow_mut().scoped.insert(scope, index);
}
let found = self.names.borrow().scoped.get(&scope).and_then(|s| s.get(&key).copied());
if cfg!(debug_assertions) {
let fresh = self.find_in_children(scope, name);
if fresh != found {
return self.stale_names(name, fresh);
}
}
found
}
fn stale_names(&self, name: &str, fresh: Option<ComponentId>) -> Option<ComponentId> {
crate::stderr_line!("aylis: índice de nomes desatualizado para '{name}'");
self.forget_names();
fresh
}
fn build_scope(&self, scope: ComponentId) -> HashMap<String, ComponentId> {
let mut index = HashMap::new();
let mut stack: Vec<ComponentId> = self.children(scope).iter().rev().copied().collect();
while let Some(id) = stack.pop() {
if let Some(name) = self.name(id).filter(|n| !n.is_empty()) {
index.entry(name.to_ascii_lowercase()).or_insert(id);
}
if !self.is_name_scope(id) {
stack.extend(self.children(id).iter().rev());
}
}
index
}
fn build_global(&self) -> HashMap<String, ComponentId> {
let mut index = HashMap::new();
let mut stack: Vec<ComponentId> = self.roots().iter().rev().copied().collect();
while let Some(id) = stack.pop() {
if let Some(name) = self.name(id).filter(|n| !n.is_empty()) {
index.entry(name.to_ascii_lowercase()).or_insert(id);
}
stack.extend(self.children(id).iter().rev());
}
index
}
}