magi_codex/

set.rs

use dashmap::DashMap;
use std::any::{Any, TypeId};
use std::sync::Arc;

/// Type-indexed set storage - one value per type.
///
/// `CodexSet` stores exactly one value per type `T`, similar to how a `HashSet`
/// stores unique values, but indexed by `TypeId` instead of value.
///
/// Useful for global configuration, shared state, or singleton resources.
///
/// ## Cloning
///
/// `CodexSet` is cheaply cloneable via `Arc`. All clones share the same storage:
///
/// ```
/// use magi_codex::CodexSet;
///
/// let set = CodexSet::new();
/// set.insert(42u32);
///
/// let set2 = set.clone();
/// assert_eq!(set2.get_cloned::<u32>(), Some(42));
/// ```
#[derive(Clone)]
pub struct CodexSet {
    map: Arc<DashMap<TypeId, Box<dyn Any + Send + Sync>>>,
}

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

impl CodexSet {
    /// Create a new empty set.
    #[inline]
    pub fn new() -> Self {
        Self {
            map: Arc::new(DashMap::new()),
        }
    }

    /// Insert or replace a value.
    ///
    /// # Example
    /// ```
    /// use magi_codex::CodexSet;
    ///
    /// struct Config { debug: bool }
    ///
    /// let set = CodexSet::new();
    /// set.insert(Config { debug: true });
    /// ```
    #[inline]
    pub fn insert<T>(&self, value: T)
    where
        T: Send + Sync + 'static,
    {
        self.map.insert(TypeId::of::<T>(), Box::new(value));
    }

    /// Returns true if a value of type `T` exists.
    #[inline]
    pub fn contains<T>(&self) -> bool
    where
        T: Send + Sync + 'static,
    {
        self.map.contains_key(&TypeId::of::<T>())
    }

    /// Access a value immutably via a closure.
    ///
    /// The closure runs while holding the lock on the value.
    ///
    /// # Example
    /// ```
    /// use magi_codex::CodexSet;
    ///
    /// struct Config { debug: bool }
    ///
    /// let set = CodexSet::new();
    /// set.insert(Config { debug: true });
    ///
    /// let debug = set.with::<Config, _, _>(|config| config.debug).unwrap();
    /// assert_eq!(debug, true);
    /// ```
    pub fn with<T, F, R>(&self, f: F) -> Option<R>
    where
        T: Send + Sync + 'static,
        F: FnOnce(&T) -> R,
    {
        let entry = self.map.get(&TypeId::of::<T>())?;
        let value = entry.value().as_ref().downcast_ref::<T>()?;
        Some(f(value))
    }

    /// Access a value mutably via a closure.
    ///
    /// The closure runs while holding the lock on the value.
    ///
    /// # Example
    /// ```
    /// use magi_codex::CodexSet;
    ///
    /// struct Config { debug: bool }
    ///
    /// let set = CodexSet::new();
    /// set.insert(Config { debug: false });
    ///
    /// set.with_mut::<Config, _, _>(|config| {
    ///     config.debug = true;
    /// });
    ///
    /// let debug = set.with::<Config, _, _>(|config| config.debug).unwrap();
    /// assert_eq!(debug, true);
    /// ```
    pub fn with_mut<T, F, R>(&self, f: F) -> Option<R>
    where
        T: Send + Sync + 'static,
        F: FnOnce(&mut T) -> R,
    {
        let mut entry = self.map.get_mut(&TypeId::of::<T>())?;
        let value = entry.value_mut().as_mut().downcast_mut::<T>()?;
        Some(f(value))
    }

    /// Clone and return a value.
    ///
    /// # Example
    /// ```
    /// use magi_codex::CodexSet;
    ///
    /// let set = CodexSet::new();
    /// set.insert(42u32);
    ///
    /// assert_eq!(set.get_cloned::<u32>(), Some(42));
    /// ```
    pub fn get_cloned<T>(&self) -> Option<T>
    where
        T: Clone + Send + Sync + 'static,
    {
        self.with::<T, _, _>(|v| v.clone())
    }

    /// Remove and return a value.
    ///
    /// # Example
    /// ```
    /// use magi_codex::CodexSet;
    ///
    /// let set = CodexSet::new();
    /// set.insert(42u32);
    ///
    /// assert_eq!(set.take::<u32>(), Some(42));
    /// assert!(!set.contains::<u32>());
    /// ```
    pub fn take<T>(&self) -> Option<T>
    where
        T: Send + Sync + 'static,
    {
        self.map
            .remove(&TypeId::of::<T>())
            .and_then(|(_, boxed)| boxed.downcast::<T>().ok())
            .map(|boxed| *boxed)
    }
}

// ============================================================================
// Tests
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;

    #[derive(Clone, Debug, PartialEq)]
    struct Config {
        debug: bool,
    }

    #[test]
    fn basic_operations() {
        let set = CodexSet::new();

        set.insert(Config { debug: true });
        assert!(set.contains::<Config>());

        let debug = set.with::<Config, _, _>(|config| config.debug).unwrap();
        assert_eq!(debug, true);
    }

    #[test]
    fn with_mut() {
        let set = CodexSet::new();
        set.insert(Config { debug: false });

        set.with_mut::<Config, _, _>(|config| {
            config.debug = true;
        });

        let debug = set.with::<Config, _, _>(|config| config.debug).unwrap();
        assert_eq!(debug, true);
    }

    #[test]
    fn get_cloned() {
        let set = CodexSet::new();
        set.insert(Config { debug: true });

        let config = set.get_cloned::<Config>().unwrap();
        assert_eq!(config.debug, true);

        // Original still exists
        assert!(set.contains::<Config>());
    }

    #[test]
    fn take() {
        let set = CodexSet::new();
        set.insert(Config { debug: true });

        let config = set.take::<Config>().unwrap();
        assert_eq!(config.debug, true);
        assert!(!set.contains::<Config>());
    }

    #[test]
    fn clone_shares_storage() {
        let set = CodexSet::new();
        set.insert(Config { debug: true });

        let set2 = set.clone();

        // Both see the same value
        assert!(set2.contains::<Config>());
        let debug = set2.with::<Config, _, _>(|c| c.debug).unwrap();
        assert_eq!(debug, true);

        // Mutation via set2 is visible in set
        set2.with_mut::<Config, _, _>(|config| {
            config.debug = false;
        });

        let debug = set.with::<Config, _, _>(|c| c.debug).unwrap();
        assert_eq!(debug, false);
    }

    #[tokio::test]
    async fn clone_across_tasks() {
        let set = CodexSet::new();
        set.insert(Config { debug: true });

        let set_clone = set.clone();

        let handle = tokio::spawn(async move {
            set_clone.insert(42u32);
            set_clone.with::<Config, _, _>(|c| c.debug).unwrap()
        });

        let debug = handle.await.unwrap();
        assert_eq!(debug, true);

        // Original sees value inserted by task
        assert_eq!(set.get_cloned::<u32>(), Some(42));
    }

    #[test]
    fn missing_resource_returns_none() {
        let set = CodexSet::new();

        let result = set.with::<Config, _, _>(|c| c.debug);
        assert!(result.is_none());
    }

    #[test]
    fn multiple_types() {
        let set = CodexSet::new();

        set.insert(Config { debug: true });
        set.insert(42u32);
        set.insert("hello".to_string());

        assert!(set.contains::<Config>());
        assert!(set.contains::<u32>());
        assert!(set.contains::<String>());

        let debug = set.with::<Config, _, _>(|c| c.debug).unwrap();
        assert_eq!(debug, true);

        let num = set.get_cloned::<u32>().unwrap();
        assert_eq!(num, 42);

        let s = set.get_cloned::<String>().unwrap();
        assert_eq!(s, "hello");
    }
}