global_registry/

lib.rs

//! # Global Registry
//!
//! A thread-safe global type registration system for Rust that allows you to:
//! - Register types globally by their TypeId
//! - Associate metadata or factory functions with types
//! - Retrieve registered information at runtime
//!
//! ## Quick Start
//!
//! ```rust
//! use global_registry::{TypeRegistry, Registrable};
//! 
//! // Define a trait for your registered types
//! trait Handler: Send + Sync {
//!     fn handle(&self, data: &str) -> String;
//! }
//!
//! #[derive(Clone)]
//! struct EmailHandler;
//! impl Handler for EmailHandler {
//!     fn handle(&self, data: &str) -> String {
//!         format!("Email: {}", data)
//!     }
//! }
//!
//! // Register the type
//! global_registry::register!(EmailHandler, EmailHandler);
//!
//! // Use the registry
//! let result = TypeRegistry::global().get_cloned::<EmailHandler>().unwrap().handle("test");
//! assert_eq!(result, "Email: test");
//! ```

use once_cell::sync::Lazy;
use std::any::{Any, TypeId};
use std::collections::HashMap;
use std::sync::{Arc, RwLock};

/// Error types for the registry
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RegistryError {
    /// Type not found in registry
    TypeNotFound,
    /// Type already registered
    TypeAlreadyExists,
    /// Failed to acquire lock
    LockError,
    /// Invalid type cast
    InvalidCast,
}

impl std::fmt::Display for RegistryError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            RegistryError::TypeNotFound => write!(f, "Type not found in registry"),
            RegistryError::TypeAlreadyExists => write!(f, "Type already registered"),
            RegistryError::LockError => write!(f, "Failed to acquire lock on registry"),
            RegistryError::InvalidCast => write!(f, "Invalid type cast"),
        }
    }
}

impl std::error::Error for RegistryError {}

/// A trait for types that can be registered in the global registry
pub trait Registrable: Any + Send + Sync {
    /// Get the TypeId for this type
    fn type_id(&self) -> TypeId {
        TypeId::of::<Self>()
    }
}

impl<T: Any + Send + Sync> Registrable for T {}

/// The main type registry that stores registered types and their associated data
pub struct TypeRegistry {
    /// Internal storage mapping TypeId to boxed values
    registry: RwLock<HashMap<TypeId, Box<dyn Any + Send + Sync>>>,
}

impl TypeRegistry {
    /// Create a new empty type registry
    pub fn new() -> Self {
        Self {
            registry: RwLock::new(HashMap::new()),
        }
    }

    /// Get the global singleton instance of the type registry
    pub fn global() -> &'static TypeRegistry {
        static GLOBAL_REGISTRY: Lazy<TypeRegistry> = Lazy::new(TypeRegistry::new);
        &GLOBAL_REGISTRY
    }

    /// Register a value associated with type T
    pub fn register<T: Registrable>(&self, value: T) -> Result<(), RegistryError> {
        let type_id = TypeId::of::<T>();
        let mut registry = self.registry.write().map_err(|_| RegistryError::LockError)?;
        
        if registry.contains_key(&type_id) {
            return Err(RegistryError::TypeAlreadyExists);
        }
        
        registry.insert(type_id, Box::new(value));
        Ok(())
    }

    /// Register a value associated with type T, allowing overwrites
    pub fn register_or_replace<T: Registrable>(&self, value: T) -> Result<(), RegistryError> {
        let type_id = TypeId::of::<T>();
        let mut registry = self.registry.write().map_err(|_| RegistryError::LockError)?;
        registry.insert(type_id, Box::new(value));
        Ok(())
    }

    
    /// Get a cloned copy of the registered value for type T (only works for Clone types)
    pub fn get_cloned<T: Registrable + Clone>(&self) -> Result<T, RegistryError> {
        let type_id = TypeId::of::<T>();
        let registry = self.registry.read().map_err(|_| RegistryError::LockError)?;
        
        let value = registry
            .get(&type_id)
            .ok_or(RegistryError::TypeNotFound)?
            .downcast_ref::<T>()
            .ok_or(RegistryError::InvalidCast)?;
            
        Ok(value.clone())
    }

    /// Get an Arc reference to the registered value for type T
    pub fn get<T: Registrable + 'static>(&self) -> Result<Arc<T>, RegistryError> {
        let type_id = TypeId::of::<T>();
        let registry = self.registry.read().map_err(|_| RegistryError::LockError)?;
        
        let value = registry
            .get(&type_id)
            .ok_or(RegistryError::TypeNotFound)?;
            
        // Try to downcast to Arc<T> first (if it was stored as Arc<T>)
        if let Some(arc_value) = value.downcast_ref::<Arc<T>>() {
            return Ok(Arc::clone(arc_value));
        }
        
        // If not stored as Arc<T>, try to downcast to T and create a new Arc
        if let Some(_direct_value) = value.downcast_ref::<T>() {
            // For owned values, we need to clone to create Arc
            // This requires T: Clone, but we can't enforce it here without changing the signature
            // So we'll return an error for non-Arc stored values
            return Err(RegistryError::InvalidCast);
        }
        
        Err(RegistryError::InvalidCast)
    }

    /// Register an Arc<T> value in the registry
    pub fn register_arc<T: Registrable + 'static>(&self, value: Arc<T>) -> Result<(), RegistryError> {
        let type_id = TypeId::of::<T>();
        let mut registry = self.registry.write().map_err(|_| RegistryError::LockError)?;
        
        if registry.contains_key(&type_id) {
            return Err(RegistryError::TypeAlreadyExists);
        }
        
        registry.insert(type_id, Box::new(value));
        Ok(())
    }

    /// Register an Arc<T> value in the registry, allowing overwrites
    pub fn register_arc_or_replace<T: Registrable + 'static>(&self, value: Arc<T>) -> Result<(), RegistryError> {
        let type_id = TypeId::of::<T>();
        let mut registry = self.registry.write().map_err(|_| RegistryError::LockError)?;
        registry.insert(type_id, Box::new(value));
        Ok(())
    }

    /// Check if type T is registered
    pub fn is_registered<T: Registrable>(&self) -> bool {
        let type_id = TypeId::of::<T>();
        let registry = self.registry.read().unwrap_or_else(|_| panic!("Registry lock poisoned"));
        registry.contains_key(&type_id)
    }

    /// Unregister type T
    pub fn unregister<T: Registrable>(&self) -> Result<(), RegistryError> {
        let type_id = TypeId::of::<T>();
        let mut registry = self.registry.write().map_err(|_| RegistryError::LockError)?;
        
        if registry.remove(&type_id).is_some() {
            Ok(())
        } else {
            Err(RegistryError::TypeNotFound)
        }
    }

    /// Get the number of registered types
    pub fn len(&self) -> usize {
        let registry = self.registry.read().unwrap_or_else(|_| panic!("Registry lock poisoned"));
        registry.len()
    }

    /// Check if the registry is empty
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Clear all registered types
    pub fn clear(&self) -> Result<(), RegistryError> {
        let mut registry = self.registry.write().map_err(|_| RegistryError::LockError)?;
        registry.clear();
        Ok(())
    }

    /// Get all registered TypeIds
    pub fn registered_types(&self) -> Result<Vec<TypeId>, RegistryError> {
        let registry = self.registry.read().map_err(|_| RegistryError::LockError)?;
        Ok(registry.keys().copied().collect())
    }
}

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

/// Macro to register a type with a value in the global registry
#[macro_export]
macro_rules! register {
    ($type:ty, $value:expr) => {
        {
            let _result = $crate::TypeRegistry::global()
                .register::<$type>($value);
            _result
        }
    };
}

/// Macro to register a type with a factory function
#[macro_export]
macro_rules! register_factory {
    ($type:ty, $factory:expr) => {
        {
            let value = $factory();
            $crate::register!($type, value)
        }
    };
}


/// Macro to get a cloned copy of a registered type from the global registry
#[macro_export]
macro_rules! get_cloned {
    ($type:ty) => {
        $crate::TypeRegistry::global().get_cloned::<$type>()
    };
}

/// Macro to get an Arc reference to a registered type from the global registry
#[macro_export]
macro_rules! get {
    ($type:ty) => {
        $crate::TypeRegistry::global().get::<$type>()
    };
}

/// Macro to register an Arc<T> value in the global registry
/// Takes a raw value and wraps it in Arc::new() internally
#[macro_export]
macro_rules! register_arc {
    ($type:ty, $value:expr) => {
        {
            let _result = $crate::TypeRegistry::global()
                .register_arc::<$type>(std::sync::Arc::new($value));
            _result
        }
    };
}


/// Type alias for a factory function
pub type Factory<T> = Box<dyn Fn() -> T + Send + Sync>;

/// A registry specifically for factory functions
pub struct FactoryRegistry {
    registry: RwLock<HashMap<TypeId, Box<dyn Any + Send + Sync>>>,
}

impl FactoryRegistry {
    pub fn new() -> Self {
        Self {
            registry: RwLock::new(HashMap::new()),
        }
    }

    pub fn global() -> &'static FactoryRegistry {
        static GLOBAL_FACTORY_REGISTRY: Lazy<FactoryRegistry> = Lazy::new(FactoryRegistry::new);
        &GLOBAL_FACTORY_REGISTRY
    }

    pub fn register_factory<T: 'static>(&self, factory: Factory<T>) -> Result<(), RegistryError> {
        let type_id = TypeId::of::<T>();
        let mut registry = self.registry.write().map_err(|_| RegistryError::LockError)?;
        
        if registry.contains_key(&type_id) {
            return Err(RegistryError::TypeAlreadyExists);
        }
        
        registry.insert(type_id, Box::new(factory));
        Ok(())
    }

    pub fn create<T: 'static>(&self) -> Result<T, RegistryError> {
        let type_id = TypeId::of::<T>();
        let registry = self.registry.read().map_err(|_| RegistryError::LockError)?;
        
        let factory = registry
            .get(&type_id)
            .ok_or(RegistryError::TypeNotFound)?
            .downcast_ref::<Factory<T>>()
            .ok_or(RegistryError::InvalidCast)?;
            
        Ok(factory())
    }
}

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

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::Arc;
    use std::thread;

    #[derive(Debug, PartialEq, Clone)]
    struct TestStruct {
        value: i32,
    }

    trait TestTrait: Send + Sync {
        fn get_value(&self) -> i32;
    }

    impl TestTrait for TestStruct {
        fn get_value(&self) -> i32 {
            self.value
        }
    }

    #[test]
    fn test_basic_registration() {
        let registry = TypeRegistry::new();
        let test_struct = TestStruct { value: 42 };
        
        assert!(registry.register(test_struct).is_ok());
        
        let value = registry.get_cloned::<TestStruct>().unwrap().value;
        assert_eq!(value, 42);
    }

    #[test]
    fn test_duplicate_registration_fails() {
        let registry = TypeRegistry::new();
        let test_struct1 = TestStruct { value: 42 };
        let test_struct2 = TestStruct { value: 100 };
        
        assert!(registry.register(test_struct1).is_ok());
        assert_eq!(registry.register(test_struct2), Err(RegistryError::TypeAlreadyExists));
    }

    #[test]
    fn test_registration_replacement() {
        let registry = TypeRegistry::new();
        let test_struct1 = TestStruct { value: 42 };
        let test_struct2 = TestStruct { value: 100 };
        
        assert!(registry.register(test_struct1).is_ok());
        assert!(registry.register_or_replace(test_struct2).is_ok());
        
        let value = registry.get_cloned::<TestStruct>().unwrap().value;
        assert_eq!(value, 100);
    }

    #[test]
    fn test_unregister() {
        let registry = TypeRegistry::new();
        let test_struct = TestStruct { value: 42 };
        
        assert!(registry.register(test_struct).is_ok());
        assert!(registry.is_registered::<TestStruct>());
        assert!(registry.unregister::<TestStruct>().is_ok());
        assert!(!registry.is_registered::<TestStruct>());
    }

    #[test]
    fn test_global_registry() {
        let registry = TypeRegistry::global();
        let test_struct = TestStruct { value: 123 };
        
        assert!(registry.register(test_struct).is_ok());
        let value = registry.get_cloned::<TestStruct>().unwrap().value;
        assert_eq!(value, 123);
        
        assert!(registry.clear().is_ok());
    }

    #[test]
    fn test_macros() {
        #[derive(Clone)]
        struct MacroTestStruct { value: String }
        
        let result = register!(MacroTestStruct, MacroTestStruct { 
            value: "test".to_string() 
        });
        assert!(result.is_ok());
        
        let value = TypeRegistry::global().get_cloned::<MacroTestStruct>().unwrap();
        assert_eq!(value.value, "test");
        
        TypeRegistry::global().clear().unwrap();
    }

    #[test]
    fn test_factory_registry() {
        let factory_registry = FactoryRegistry::new();
        
        let factory: Factory<TestStruct> = Box::new(|| TestStruct { value: 999 });
        assert!(factory_registry.register_factory(factory).is_ok());
        
        let created = factory_registry.create::<TestStruct>().unwrap();
        assert_eq!(created.value, 999);
    }

    #[test]
    fn test_thread_safety() {
        let registry = Arc::new(TypeRegistry::new());
        let mut handles = vec![];

        for i in 0..10 {
            let registry_clone = Arc::clone(&registry);
            let handle = thread::spawn(move || {
                struct ThreadTestStruct(i32);
                let _ = registry_clone.register(ThreadTestStruct(i));
            });
            handles.push(handle);
        }

        for handle in handles {
            handle.join().unwrap();
        }

        assert_eq!(registry.len(), 1); // Only one type registered (different instances)
    }

    #[test]
    fn test_trait_objects() {
        let registry = TypeRegistry::new();
        let handler: Box<dyn TestTrait> = Box::new(TestStruct { value: 42 });
        
        assert!(registry.register(handler).is_ok());
        
        // Since Box<dyn TestTrait> doesn't implement Clone, we can't use get_cloned
        // For this test, we'll test that the registration succeeded
        assert!(registry.is_registered::<Box<dyn TestTrait>>());
    }


    #[test]
    fn test_arc_registration_and_get() {
        let registry = TypeRegistry::new();
        let test_struct = Arc::new(TestStruct { value: 123 });
        
        // Register Arc<TestStruct>
        assert!(registry.register_arc(test_struct.clone()).is_ok());
        
        // Get Arc<TestStruct> back
        let retrieved = registry.get::<TestStruct>().unwrap();
        assert_eq!(retrieved.value, 123);
        
        // Verify it's the same Arc (same address)
        assert!(Arc::ptr_eq(&test_struct, &retrieved));
    }

    #[test]
    fn test_arc_macros() {
        let test_struct = TestStruct { value: 456 };
        
        // Register using macro (now takes raw value)
        assert!(register_arc!(TestStruct, test_struct).is_ok());
        
        // Get using macro
        let retrieved = get!(TestStruct).unwrap();
        assert_eq!(retrieved.value, 456);
        
        // Clean up
        TypeRegistry::global().clear().unwrap();
    }



}