bare-types 0.3.0

//! Example demonstrating integration between net and sys modules
//!
//! This example shows how to use bare-types in a real-world scenario
//! where you need to combine network and system information.
#![allow(unused_crate_dependencies)]

use bare_types::net::{DomainName, Host, Hostname, Port, SocketAddr};
use bare_types::sys::{Arch, KernelVersion, OsType, OsVersion, Username};

/// A simple server configuration that combines network and system types
struct ServerConfig {
    hostname: Hostname,
    domain: DomainName,
    listen_port: Port,
    admin_user: Username,
}

impl ServerConfig {
    fn new(
        hostname: Hostname,
        domain: DomainName,
        listen_port: Port,
        admin_user: Username,
    ) -> Self {
        Self {
            hostname,
            domain,
            listen_port,
            admin_user,
        }
    }

    fn display_info(&self) {
        println!("Server Configuration:");
        println!("  Hostname: {}", self.hostname);
        println!("  Domain: {}", self.domain);
        println!("  Listen Port: {}", self.listen_port);
        println!("  Admin User: {}", self.admin_user);
        println!("  Full FQDN: {}.{}", self.hostname, self.domain);
    }
}

/// Check if a system is compatible with a server configuration
fn check_compatibility(
    _config: &ServerConfig,
    os_type: OsType,
    kernel_version: KernelVersion,
    arch: Arch,
) -> bool {
    println!("\nSystem Compatibility Check:");
    println!("  OS: {}", os_type);
    println!("  Kernel: {}", kernel_version);
    println!("  Architecture: {}", arch);

    let compatible = os_type.is_unix() && arch.is_64_bit();
    println!("  Compatible: {}", compatible);
    compatible
}

fn main() {
    println!("=== bare-types Integration Demo ===\n");

    // Create server configuration using validated types
    let hostname: Hostname = "webserver".parse().expect("valid hostname");
    let domain: DomainName = "example.com".parse().expect("valid domain");
    let listen_port = Port::HTTPS;
    let admin_user: Username = "admin".parse().expect("valid username");

    let config = ServerConfig::new(hostname, domain, listen_port, admin_user);
    config.display_info();

    // Check system compatibility
    let os_type = OsType::current();
    let kernel_version: KernelVersion = "6.8.0-40-generic".parse().expect("valid kernel");
    let arch = Arch::current();

    let is_compatible = check_compatibility(&config, os_type, kernel_version, arch);

    if is_compatible {
        println!("\n✓ System is compatible with server configuration");
    } else {
        println!("\n✗ System is not compatible with server configuration");
    }

    // Demonstrate type-safe socket address handling
    println!("\n=== Socket Address Handling ===");
    let socket: SocketAddr = "example.com:443".parse().expect("valid socket");
    println!("Socket address: {}", socket);
    let (host, port) = socket.into_parts();
    println!("  Host: {}", host);
    println!("  Port: {}", port);

    // Validate that port is HTTPS
    if port == Port::HTTPS {
        println!("  ✓ Using HTTPS port");
    }

    // Demonstrate host type matching
    println!("\n=== Host Type Matching ===");
    let ip_host: Host = "192.168.1.1".parse().expect("valid host");
    let domain_host: Host = "example.com".parse().expect("valid host");
    let hostname_host: Host = "localhost".parse().expect("valid host");

    println!("IP host: {} (is IP: {})", ip_host, ip_host.is_ipaddr());
    println!(
        "Domain host: {} (is domain: {})",
        domain_host,
        domain_host.is_domainname()
    );
    println!(
        "Hostname host: {} (is hostname: {})",
        hostname_host,
        hostname_host.is_hostname()
    );

    // Demonstrate version comparison
    println!("\n=== Version Comparison ===");
    let current_ver: OsVersion = "22.04".parse().expect("valid version");
    let min_ver: OsVersion = "20.04".parse().expect("valid version");
    let max_ver: OsVersion = "24.04".parse().expect("valid version");

    println!("Current version: {}", current_ver);
    println!("Minimum required: {}", min_ver);
    println!("Maximum supported: {}", max_ver);
    println!("  Meets minimum: {}", current_ver >= min_ver);
    println!("  Exceeds maximum: {}", current_ver > max_ver);

    println!("\n=== Integration Benefits ===");
    println!("✓ Type safety prevents invalid states");
    println!("✓ Zero-cost abstractions - no runtime overhead");
    println!("✓ Compile-time validation where possible");
    println!("✓ Clear error messages for debugging");
    println!("✓ Self-documenting code through types");
    println!("✓ Full no_std compatibility for embedded systems");
}