lgui-store 0.2.1

Application-scoped reactive state stores for LGUI
Documentation
use std::{
    any::{Any, TypeId},
    collections::HashMap,
};

use crate::resources::Resources;

use super::super::{
    definition::StoreDefinition,
    subscription::{StoreNotification, StoreObserverRef, Subscription, SubscriptionToken},
    StoreUnit,
};

trait AnyStoreUnit: Send + Sync {
    fn as_any(&self) -> &dyn Any;
    fn as_any_mut(&mut self) -> &mut dyn Any;
}

struct StoreEntry<T> {
    unit: T,
}

impl<T> AnyStoreUnit for StoreEntry<T>
where
    T: Send + Sync + 'static,
{
    fn as_any(&self) -> &dyn Any {
        &self.unit
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        &mut self.unit
    }
}

struct SubscriptionEntry {
    token: SubscriptionToken,
    subscription: Subscription,
    observer: StoreObserverRef,
}

pub struct StoreRegistry {
    stores: HashMap<TypeId, Box<dyn AnyStoreUnit>>,
    keys: HashMap<&'static str, TypeId>,
    subscriptions: Vec<SubscriptionEntry>,
    next_token: u64,
}

impl StoreRegistry {
    pub fn new() -> Self {
        Self {
            stores: HashMap::new(),
            keys: HashMap::new(),
            subscriptions: Vec::new(),
            next_token: 1,
        }
    }

    pub fn ensure<T>(&mut self, resources: &Resources)
    where
        T: StoreUnit,
    {
        if self.stores.contains_key(&TypeId::of::<T>()) {
            return;
        }
        self.insert::<T>(T::KEY, T::create(resources));
    }

    pub fn ensure_defined<T>(&mut self, definition: StoreDefinition<T>)
    where
        T: Send + Sync + 'static,
    {
        if self.stores.contains_key(&TypeId::of::<T>()) {
            return;
        }
        self.insert::<T>(definition.key(), definition.initialize());
    }

    fn insert<T>(&mut self, key: &'static str, unit: T)
    where
        T: Send + Sync + 'static,
    {
        assert!(!key.is_empty(), "store key must not be empty");
        let type_id = TypeId::of::<T>();
        assert!(!self.keys.contains_key(key), "duplicate store key `{key}`");
        self.keys.insert(key, type_id);
        self.stores.insert(type_id, Box::new(StoreEntry { unit }));
    }

    pub fn get<T>(&self) -> Option<&T>
    where
        T: Send + Sync + 'static,
    {
        self.stores
            .get(&TypeId::of::<T>())
            .and_then(|store| store.as_any().downcast_ref::<T>())
    }

    pub fn get_mut<T>(&mut self) -> Option<&mut T>
    where
        T: Send + Sync + 'static,
    {
        self.stores
            .get_mut(&TypeId::of::<T>())
            .and_then(|store| store.as_any_mut().downcast_mut::<T>())
    }

    pub fn subscribe(
        &mut self,
        subscription: Subscription,
        observer: StoreObserverRef,
    ) -> SubscriptionToken {
        let token = SubscriptionToken(self.next_token);
        self.next_token += 1;
        self.subscriptions.push(SubscriptionEntry {
            token: token.clone(),
            subscription,
            observer,
        });
        token
    }

    pub fn unsubscribe(&mut self, token: SubscriptionToken) -> bool {
        let len_before = self.subscriptions.len();
        self.subscriptions.retain(|entry| entry.token != token);
        self.subscriptions.len() != len_before
    }

    pub fn observers_for(&self, notification: &StoreNotification) -> Vec<StoreObserverRef> {
        self.subscriptions
            .iter()
            .filter(|entry| entry.subscription.store_key == notification.store_key)
            .map(|entry| entry.observer.clone())
            .collect()
    }
}

impl Default for StoreRegistry {
    fn default() -> Self {
        Self::new()
    }
}