cranpose_ui/modifier/
local.rs

1use std::{
2    any::{Any, TypeId},
3    collections::{HashMap, HashSet},
4    fmt,
5    hash::{Hash, Hasher},
6    rc::Rc,
7};
8
9use cranpose_foundation::{
10    DelegatableNode, InvalidationKind, ModifierInvalidation, ModifierNode, ModifierNodeChain,
11    ModifierNodeElement, NodeCapabilities, NodeState,
12};
13
14#[derive(Clone)]
15struct ModifierLocalId(Rc<()>);
16
17impl ModifierLocalId {
18    fn new() -> Self {
19        Self(Rc::new(()))
20    }
21}
22
23impl fmt::Debug for ModifierLocalId {
24    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
25        f.debug_tuple("ModifierLocalId")
26            .field(&(Rc::as_ptr(&self.0) as usize))
27            .finish()
28    }
29}
30
31impl PartialEq for ModifierLocalId {
32    fn eq(&self, other: &Self) -> bool {
33        Rc::ptr_eq(&self.0, &other.0)
34    }
35}
36
37impl Eq for ModifierLocalId {}
38
39impl Hash for ModifierLocalId {
40    fn hash<H: Hasher>(&self, state: &mut H) {
41        Rc::as_ptr(&self.0).hash(state);
42    }
43}
44
45#[derive(Clone, Debug, PartialEq, Eq, Hash)]
46pub(crate) struct ModifierLocalToken {
47    id: ModifierLocalId,
48    type_id: TypeId,
49}
50
51impl ModifierLocalToken {
52    fn new(type_id: TypeId) -> Self {
53        let id = ModifierLocalId::new();
54        Self { id, type_id }
55    }
56
57    fn id(&self) -> ModifierLocalId {
58        self.id.clone()
59    }
60}
61
62/// Type-safe key referencing a modifier local value.
63#[derive(Clone)]
64pub struct ModifierLocalKey<T: 'static> {
65    token: ModifierLocalToken,
66    default: Rc<dyn Fn() -> T>,
67}
68
69impl<T: 'static> ModifierLocalKey<T> {
70    pub fn new(factory: impl Fn() -> T + 'static) -> Self {
71        Self {
72            token: ModifierLocalToken::new(TypeId::of::<T>()),
73            default: Rc::new(factory),
74        }
75    }
76
77    pub(crate) fn token(&self) -> ModifierLocalToken {
78        self.token.clone()
79    }
80
81    pub(crate) fn default_value(&self) -> T {
82        (self.default)()
83    }
84}
85
86impl<T: 'static> PartialEq for ModifierLocalKey<T> {
87    fn eq(&self, other: &Self) -> bool {
88        self.token == other.token
89    }
90}
91
92impl<T: 'static> Eq for ModifierLocalKey<T> {}
93
94impl<T: 'static> Hash for ModifierLocalKey<T> {
95    fn hash<H: Hasher>(&self, state: &mut H) {
96        self.token.hash(state);
97    }
98}
99
100pub struct ModifierLocalProviderNode {
101    token: ModifierLocalToken,
102    value_factory: Rc<dyn Fn() -> Box<dyn Any>>,
103    value: Rc<dyn Any>,
104    version: u64,
105    state: NodeState,
106}
107
108impl ModifierLocalProviderNode {
109    fn new(token: ModifierLocalToken, factory: Rc<dyn Fn() -> Box<dyn Any>>) -> Self {
110        Self {
111            token,
112            value: Self::create_value(&factory),
113            value_factory: factory,
114            version: 0,
115            state: NodeState::new(),
116        }
117    }
118
119    fn update_value(&mut self) {
120        self.value = Self::create_value(&self.value_factory);
121        self.version = self.version.wrapping_add(1);
122    }
123
124    fn set_factory(&mut self, factory: Rc<dyn Fn() -> Box<dyn Any>>) {
125        self.value_factory = factory;
126        self.update_value();
127    }
128
129    fn token(&self) -> ModifierLocalToken {
130        self.token.clone()
131    }
132
133    fn value(&self) -> Rc<dyn Any> {
134        self.value.clone()
135    }
136
137    fn version(&self) -> u64 {
138        self.version
139    }
140
141    fn create_value(factory: &Rc<dyn Fn() -> Box<dyn Any>>) -> Rc<dyn Any> {
142        Rc::from(factory())
143    }
144}
145
146impl DelegatableNode for ModifierLocalProviderNode {
147    fn node_state(&self) -> &NodeState {
148        &self.state
149    }
150}
151
152impl ModifierNode for ModifierLocalProviderNode {}
153
154pub struct ModifierLocalConsumerNode {
155    callback: Rc<dyn for<'a> Fn(&mut ModifierLocalReadScope<'a>)>,
156    state: NodeState,
157}
158
159impl ModifierLocalConsumerNode {
160    fn new(callback: Rc<dyn for<'a> Fn(&mut ModifierLocalReadScope<'a>)>) -> Self {
161        Self {
162            callback,
163            state: NodeState::new(),
164        }
165    }
166
167    fn notify(&self, scope: &mut ModifierLocalReadScope<'_>) {
168        (self.callback)(scope);
169    }
170
171    fn id(&self) -> usize {
172        self as *const Self as usize
173    }
174}
175
176#[derive(Clone)]
177pub(crate) struct ResolvedModifierLocal {
178    value: Rc<dyn Any>,
179    version: u64,
180    source: ModifierLocalSource,
181}
182
183impl ResolvedModifierLocal {
184    fn new(value: Rc<dyn Any>, version: u64, source: ModifierLocalSource) -> Self {
185        Self {
186            value,
187            version,
188            source,
189        }
190    }
191
192    pub(crate) fn value(&self) -> Rc<dyn Any> {
193        self.value.clone()
194    }
195
196    pub(crate) fn version(&self) -> u64 {
197        self.version
198    }
199
200    pub(crate) fn with_source(mut self, source: ModifierLocalSource) -> Self {
201        self.source = source;
202        self
203    }
204}
205
206#[derive(Clone, Copy, Debug, PartialEq, Eq)]
207pub(crate) enum ModifierLocalSource {
208    Chain,
209    Ancestor,
210}
211
212pub(crate) type ModifierLocalAncestorResolver<'a> =
213    dyn FnMut(&ModifierLocalToken) -> Option<ResolvedModifierLocal> + 'a;
214
215#[derive(Clone)]
216struct ProviderRecord {
217    value: Rc<dyn Any>,
218    version: u64,
219}
220
221impl ProviderRecord {
222    fn new(value: Rc<dyn Any>, version: u64) -> Self {
223        Self { value, version }
224    }
225
226    fn version(&self) -> u64 {
227        self.version
228    }
229
230    fn value(&self) -> &Rc<dyn Any> {
231        &self.value
232    }
233}
234
235#[derive(Clone)]
236struct DependencyRecord {
237    token: ModifierLocalToken,
238    source: DependencySource,
239    version: u64,
240}
241
242impl DependencyRecord {
243    fn from_chain(token: ModifierLocalToken, version: u64) -> Self {
244        Self {
245            token,
246            source: DependencySource::Chain,
247            version,
248        }
249    }
250
251    fn from_ancestor(token: ModifierLocalToken, version: u64) -> Self {
252        Self {
253            token,
254            source: DependencySource::Ancestor,
255            version,
256        }
257    }
258
259    fn from_default(token: ModifierLocalToken) -> Self {
260        Self {
261            token,
262            source: DependencySource::Default,
263            version: 0,
264        }
265    }
266
267    fn is_dirty(
268        &self,
269        providers: &HashMap<ModifierLocalId, ProviderRecord>,
270        ancestor_lookup: &mut ModifierLocalAncestorResolver<'_>,
271    ) -> bool {
272        match self.source {
273            DependencySource::Chain => match providers.get(&self.token.id()) {
274                Some(record) => record.version() != self.version,
275                None => true,
276            },
277            DependencySource::Ancestor => {
278                if providers.contains_key(&self.token.id()) {
279                    return true;
280                }
281                ancestor_lookup(&self.token)
282                    .is_none_or(|resolved| resolved.version() != self.version)
283            }
284            DependencySource::Default => {
285                providers.contains_key(&self.token.id()) || ancestor_lookup(&self.token).is_some()
286            }
287        }
288    }
289}
290
291#[derive(Clone, Copy)]
292enum DependencySource {
293    Chain,
294    Ancestor,
295    Default,
296}
297
298struct ConsumerState {
299    dependencies: Vec<DependencyRecord>,
300}
301
302impl ConsumerState {
303    fn new(dependencies: Vec<DependencyRecord>) -> Self {
304        Self { dependencies }
305    }
306
307    fn needs_update(
308        &self,
309        providers: &HashMap<ModifierLocalId, ProviderRecord>,
310        ancestor_lookup: &mut ModifierLocalAncestorResolver<'_>,
311    ) -> bool {
312        if self.dependencies.is_empty() {
313            return true;
314        }
315        self.dependencies
316            .iter()
317            .any(|dependency| dependency.is_dirty(providers, ancestor_lookup))
318    }
319}
320
321impl DelegatableNode for ModifierLocalConsumerNode {
322    fn node_state(&self) -> &NodeState {
323        &self.state
324    }
325}
326
327impl ModifierNode for ModifierLocalConsumerNode {}
328
329#[derive(Clone)]
330pub struct ModifierLocalProviderElement {
331    token: ModifierLocalToken,
332    factory: Rc<dyn Fn() -> Box<dyn Any>>,
333}
334
335impl ModifierLocalProviderElement {
336    pub fn new<T, F>(key: ModifierLocalKey<T>, factory: F) -> Self
337    where
338        T: 'static,
339        F: Fn() -> T + 'static,
340    {
341        let erased = Rc::new(move || -> Box<dyn Any> { Box::new(factory()) });
342        Self {
343            token: key.token(),
344            factory: erased,
345        }
346    }
347}
348
349impl fmt::Debug for ModifierLocalProviderElement {
350    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
351        f.debug_struct("ModifierLocalProviderElement")
352            .field("id", &self.token.id())
353            .finish()
354    }
355}
356
357impl PartialEq for ModifierLocalProviderElement {
358    fn eq(&self, other: &Self) -> bool {
359        self.token == other.token
360    }
361}
362
363impl Eq for ModifierLocalProviderElement {}
364
365impl Hash for ModifierLocalProviderElement {
366    fn hash<H: Hasher>(&self, state: &mut H) {
367        "modifier_local_provider".hash(state);
368        self.token.hash(state);
369    }
370}
371
372impl ModifierNodeElement for ModifierLocalProviderElement {
373    type Node = ModifierLocalProviderNode;
374
375    fn create(&self) -> Self::Node {
376        ModifierLocalProviderNode::new(self.token.clone(), self.factory.clone())
377    }
378
379    fn update(&self, node: &mut Self::Node) {
380        node.set_factory(self.factory.clone());
381    }
382
383    fn capabilities(&self) -> NodeCapabilities {
384        NodeCapabilities::MODIFIER_LOCALS
385    }
386
387    fn always_update(&self) -> bool {
388        true
389    }
390}
391
392#[derive(Clone)]
393pub struct ModifierLocalConsumerElement {
394    callback: Rc<dyn for<'a> Fn(&mut ModifierLocalReadScope<'a>)>,
395}
396
397impl ModifierLocalConsumerElement {
398    pub fn new<F>(callback: F) -> Self
399    where
400        F: for<'a> Fn(&mut ModifierLocalReadScope<'a>) + 'static,
401    {
402        Self {
403            callback: Rc::new(callback),
404        }
405    }
406}
407
408impl fmt::Debug for ModifierLocalConsumerElement {
409    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
410        f.write_str("ModifierLocalConsumerElement")
411    }
412}
413
414impl PartialEq for ModifierLocalConsumerElement {
415    fn eq(&self, _other: &Self) -> bool {
416        true
417    }
418}
419
420impl Eq for ModifierLocalConsumerElement {}
421
422impl Hash for ModifierLocalConsumerElement {
423    fn hash<H: Hasher>(&self, state: &mut H) {
424        "modifier_local_consumer".hash(state);
425    }
426}
427
428impl ModifierNodeElement for ModifierLocalConsumerElement {
429    type Node = ModifierLocalConsumerNode;
430
431    fn create(&self) -> Self::Node {
432        ModifierLocalConsumerNode::new(self.callback.clone())
433    }
434
435    fn update(&self, node: &mut Self::Node) {
436        node.callback = self.callback.clone();
437    }
438
439    fn capabilities(&self) -> NodeCapabilities {
440        NodeCapabilities::MODIFIER_LOCALS
441    }
442
443    fn always_update(&self) -> bool {
444        true
445    }
446}
447
448/// Lightweight read scope surfaced to modifier local consumers.
449pub struct ModifierLocalReadScope<'a> {
450    providers: &'a HashMap<ModifierLocalId, ProviderRecord>,
451    ancestor_lookup: &'a mut ModifierLocalAncestorResolver<'a>,
452    dependencies: &'a mut Vec<DependencyRecord>,
453    fallbacks: HashMap<ModifierLocalId, Rc<dyn Any>>,
454}
455
456impl<'a> ModifierLocalReadScope<'a> {
457    fn new(
458        providers: &'a HashMap<ModifierLocalId, ProviderRecord>,
459        ancestor_lookup: &'a mut ModifierLocalAncestorResolver<'a>,
460        dependencies: &'a mut Vec<DependencyRecord>,
461    ) -> Self {
462        Self {
463            providers,
464            ancestor_lookup,
465            dependencies,
466            fallbacks: HashMap::new(),
467        }
468    }
469
470    pub fn get<T: 'static>(&mut self, key: &ModifierLocalKey<T>) -> &T {
471        let token = key.token();
472        if let Some(record) = self.providers.get(&token.id()) {
473            self.dependencies
474                .push(DependencyRecord::from_chain(token, record.version()));
475            if let Some(value) = record.value().downcast_ref::<T>() {
476                return value;
477            }
478            return self.default_value_for(key);
479        }
480
481        if let Some(resolved) = (self.ancestor_lookup)(&token) {
482            self.dependencies.push(DependencyRecord::from_ancestor(
483                token.clone(),
484                resolved.version(),
485            ));
486            let resolved_value = resolved.value();
487            if resolved_value.downcast_ref::<T>().is_some() {
488                self.fallbacks.insert(token.id(), resolved_value);
489                return self.fallback_value_for(key);
490            }
491            return self.default_value_for(key);
492        }
493
494        self.dependencies
495            .push(DependencyRecord::from_default(token));
496        self.default_value_for(key)
497    }
498
499    fn fallback_value_for<T: 'static>(&mut self, key: &ModifierLocalKey<T>) -> &T {
500        let id = key.token().id();
501        if self
502            .fallbacks
503            .get(&id)
504            .and_then(|value| value.downcast_ref::<T>())
505            .is_none()
506        {
507            self.fallbacks
508                .insert(id.clone(), Rc::new(key.default_value()) as Rc<dyn Any>);
509        }
510
511        match self
512            .fallbacks
513            .get(&id)
514            .and_then(|value| value.downcast_ref::<T>())
515        {
516            Some(value) => value,
517            None => Box::leak(Box::new(key.default_value())),
518        }
519    }
520
521    fn default_value_for<T: 'static>(&mut self, key: &ModifierLocalKey<T>) -> &T {
522        self.fallback_value_for(key)
523    }
524}
525
526#[cfg(test)]
527mod tests {
528    use super::*;
529
530    fn empty_ancestor_lookup(_: &ModifierLocalToken) -> Option<ResolvedModifierLocal> {
531        None
532    }
533
534    #[test]
535    fn modifier_local_keys_do_not_use_process_global_counter() {
536        let source = include_str!("local.rs");
537        assert!(!source.contains(concat!("NEXT_", "MODIFIER_LOCAL_ID")));
538        assert!(!source.contains(concat!("Atomic", "U64")));
539    }
540
541    #[test]
542    fn modifier_local_key_identity_is_retained_per_key() {
543        let first = ModifierLocalKey::new(|| 1_i32);
544        let first_clone = first.clone();
545        let second = ModifierLocalKey::new(|| 1_i32);
546
547        assert_eq!(first.token(), first_clone.token());
548        assert_ne!(first.token(), second.token());
549    }
550
551    #[test]
552    fn modifier_local_provider_type_mismatch_falls_back_to_default() {
553        let key = ModifierLocalKey::new(|| 7_i32);
554        let mut providers = HashMap::new();
555        providers.insert(
556            key.token().id(),
557            ProviderRecord::new(Rc::new(String::from("wrong")) as Rc<dyn Any>, 4),
558        );
559        let mut dependencies = Vec::new();
560        let mut ancestor_lookup = empty_ancestor_lookup;
561        let mut scope =
562            ModifierLocalReadScope::new(&providers, &mut ancestor_lookup, &mut dependencies);
563
564        assert_eq!(*scope.get(&key), 7);
565        assert!(matches!(dependencies[0].source, DependencySource::Chain));
566        assert_eq!(dependencies[0].version, 4);
567    }
568
569    #[test]
570    fn modifier_local_ancestor_type_mismatch_falls_back_to_default() {
571        let key = ModifierLocalKey::new(|| 11_i32);
572        let providers = HashMap::new();
573        let mut dependencies = Vec::new();
574        let mut ancestor_lookup = |token: &ModifierLocalToken| {
575            if *token == key.token() {
576                Some(ResolvedModifierLocal::new(
577                    Rc::new(String::from("wrong")) as Rc<dyn Any>,
578                    9,
579                    ModifierLocalSource::Ancestor,
580                ))
581            } else {
582                None
583            }
584        };
585        let mut scope =
586            ModifierLocalReadScope::new(&providers, &mut ancestor_lookup, &mut dependencies);
587
588        assert_eq!(*scope.get(&key), 11);
589        assert!(matches!(dependencies[0].source, DependencySource::Ancestor));
590        assert_eq!(dependencies[0].version, 9);
591    }
592
593    #[test]
594    fn modifier_local_fallback_cache_reconciles_mismatched_cached_value() {
595        let key = ModifierLocalKey::new(|| 23_i32);
596        let providers = HashMap::new();
597        let mut dependencies = Vec::new();
598        let mut ancestor_lookup = empty_ancestor_lookup;
599        let cache_is_typed = {
600            let mut scope =
601                ModifierLocalReadScope::new(&providers, &mut ancestor_lookup, &mut dependencies);
602            scope.fallbacks.insert(
603                key.token().id(),
604                Rc::new(String::from("wrong")) as Rc<dyn Any>,
605            );
606
607            assert_eq!(*scope.get(&key), 23);
608            assert_eq!(*scope.get(&key), 23);
609            scope
610                .fallbacks
611                .get(&key.token().id())
612                .and_then(|value| value.downcast_ref::<i32>())
613                .is_some()
614        };
615
616        assert_eq!(dependencies.len(), 2);
617        assert!(cache_is_typed);
618    }
619}
620
621#[derive(Default)]
622pub struct ModifierLocalManager {
623    providers: HashMap<ModifierLocalId, ProviderRecord>,
624    consumers: HashMap<usize, ConsumerState>,
625}
626
627impl ModifierLocalManager {
628    pub fn new() -> Self {
629        Self::default()
630    }
631
632    #[allow(private_interfaces)]
633    pub fn sync(
634        &mut self,
635        chain: &ModifierNodeChain,
636        ancestor_lookup: &mut ModifierLocalAncestorResolver<'_>,
637    ) -> Vec<ModifierInvalidation> {
638        if !chain.has_capability(NodeCapabilities::MODIFIER_LOCALS) {
639            self.providers.clear();
640            self.consumers.clear();
641            return Vec::new();
642        }
643
644        let mut providers: HashMap<ModifierLocalId, ProviderRecord> = HashMap::new();
645        let mut seen_consumers = HashSet::new();
646        let mut invalidations = Vec::new();
647
648        chain.for_each_node_with_capability(NodeCapabilities::MODIFIER_LOCALS, |_ref, node| {
649            if let Some(provider) = node.as_any().downcast_ref::<ModifierLocalProviderNode>() {
650                providers.insert(
651                    provider.token().id(),
652                    ProviderRecord::new(provider.value(), provider.version()),
653                );
654                return;
655            }
656
657            if let Some(consumer) = node.as_any().downcast_ref::<ModifierLocalConsumerNode>() {
658                let id = consumer.id();
659                seen_consumers.insert(id);
660                let needs_update = self
661                    .consumers
662                    .get(&id)
663                    .is_none_or(|state| state.needs_update(&providers, ancestor_lookup));
664                if !needs_update {
665                    return;
666                }
667
668                let mut dependencies = Vec::new();
669                {
670                    let mut scope =
671                        ModifierLocalReadScope::new(&providers, ancestor_lookup, &mut dependencies);
672                    consumer.notify(&mut scope);
673                }
674                self.consumers.insert(id, ConsumerState::new(dependencies));
675                if !invalidations
676                    .iter()
677                    .any(|entry: &ModifierInvalidation| entry.kind() == InvalidationKind::Layout)
678                {
679                    invalidations.push(ModifierInvalidation::new(
680                        InvalidationKind::Layout,
681                        NodeCapabilities::LAYOUT | NodeCapabilities::MODIFIER_LOCALS,
682                    ));
683                }
684            }
685        });
686
687        self.providers = providers;
688        self.consumers.retain(|id, _| seen_consumers.contains(id));
689
690        invalidations
691    }
692
693    pub(crate) fn resolve(&self, token: &ModifierLocalToken) -> Option<ResolvedModifierLocal> {
694        self.providers.get(&token.id()).map(|record| {
695            ResolvedModifierLocal::new(
696                record.value().clone(),
697                record.version(),
698                ModifierLocalSource::Chain,
699            )
700        })
701    }
702}
cranpose_ui/modifier/local.rs

cranpose_ui/modifier/
local.rs
