global-registry 0.1.0

//! Basic usage example demonstrating core functionality

use global_registry::{TypeRegistry, RegistryError};

// A simple struct to register
#[derive(Debug, Clone)]
struct DatabaseConfig {
    host: String,
    port: u16,
    database: String,
}

impl DatabaseConfig {
    fn new(host: &str, port: u16, database: &str) -> Self {
        Self {
            host: host.to_string(),
            port,
            database: database.to_string(),
        }
    }

    fn connection_string(&self) -> String {
        format!("{}:{}/{}", self.host, self.port, self.database)
    }
}

fn main() -> Result<(), RegistryError> {
    println!("=== Basic Type Registry Usage ===\n");

    // Create a new registry instance
    let registry = TypeRegistry::new();
    
    // Register a configuration
    let config = DatabaseConfig::new("localhost", 5432, "myapp");
    println!("Registering config: {:?}", config);
    registry.register(config)?;
    
    // Retrieve and use the configuration
    let config = registry.get_cloned::<DatabaseConfig>()?;
    println!("Retrieved config: {:?}", config);
    let connection_string = config.connection_string();
    println!("Connection string: {}", connection_string);
    
    // Check if type is registered
    println!("Is DatabaseConfig registered? {}", registry.is_registered::<DatabaseConfig>());
    
    // Show registry stats
    println!("Registry contains {} types", registry.len());
    
    // Try to register the same type again (will fail)
    let another_config = DatabaseConfig::new("remote", 3306, "prod");
    match registry.register(another_config) {
        Ok(()) => println!("Second registration succeeded"),
        Err(RegistryError::TypeAlreadyExists) => {
            println!("Second registration failed as expected: type already exists");
        }
        Err(e) => println!("Unexpected error: {}", e),
    }
    
    // Use register_or_replace to overwrite
    let replacement_config = DatabaseConfig::new("remote", 3306, "prod");
    println!("Replacing with new config: {:?}", replacement_config);
    registry.register_or_replace(replacement_config)?;
    
    let final_config = registry.get_cloned::<DatabaseConfig>()?;
    println!("Final config: {:?}", final_config);
    
    Ok(())
}