use crate::component::Component;
use crate::prop::PropValue;
#[derive(Clone, Copy, Debug)]
pub struct ClassInfo {
pub name: &'static str,
pub category: &'static str,
pub create: fn() -> Box<dyn Component>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct VariantInfo {
pub class: String,
pub name: String,
pub caption: String,
pub props: Vec<(String, PropValue)>,
}
#[derive(Default)]
pub struct ClassRegistry {
classes: Vec<ClassInfo>,
variants: Vec<VariantInfo>,
}
impl ClassRegistry {
pub fn register(&mut self, info: ClassInfo) {
match self.classes.iter_mut().find(|c| c.name.eq_ignore_ascii_case(info.name)) {
Some(existing) => *existing = info,
None => self.classes.push(info),
}
}
pub fn get(&self, name: &str) -> Option<&ClassInfo> {
self.classes.iter().find(|c| c.name.eq_ignore_ascii_case(name))
}
pub fn iter(&self) -> impl Iterator<Item = &ClassInfo> {
self.classes.iter()
}
pub fn register_variant(&mut self, info: VariantInfo) {
let same = |v: &VariantInfo| v.class.eq_ignore_ascii_case(&info.class) && v.name.eq_ignore_ascii_case(&info.name);
match self.variants.iter_mut().find(|v| same(v)) {
Some(existing) => *existing = info,
None => self.variants.push(info),
}
}
pub fn variants_of(&self, class: &str) -> impl Iterator<Item = &VariantInfo> {
let class = class.to_string();
self.variants.iter().filter(move |v| v.class.eq_ignore_ascii_case(&class))
}
pub fn variant(&self, class: &str, name: &str) -> Option<&VariantInfo> {
self.variants.iter().find(|v| v.class.eq_ignore_ascii_case(class) && v.name.eq_ignore_ascii_case(name))
}
}
pub fn split_variant(name: &str) -> (&str, Option<&str>) {
match name.split_once('.') {
Some((class, variant)) if !variant.is_empty() => (class, Some(variant)),
_ => (name, None),
}
}
pub(crate) fn create_default<T: Component + Default>() -> Box<dyn Component> {
Box::new(T::default())
}