bare-types 0.3.0

A zero-cost foundation for type-safe domain modeling in Rust. Implements the 'Parse, don't validate' philosophy to eliminate primitive obsession and ensure data integrity at the system boundary.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

//! Socket Address Demo
//!
//! This example demonstrates socket address operations in bare-types.

use bare_types::net::{Host, Port, SocketAddr};

fn main() {
    println!("=== Socket Address Operations ===\n");

    // Create from IP and port using Host::parse_str
    let host = Host::parse_str("192.168.1.1").unwrap();
    let port = Port::HTTP;
    let socket = SocketAddr::new(host, port);
    println!("Socket from IP: {}", socket);
    println!("  Is IP: {}", socket.is_ip());
    println!("  Is domain: {}", socket.is_domain_name());
    println!("  Port: {}\n", socket.as_port());

    // Create from domain and port
    let host = Host::parse_str("example.com").unwrap();
    let port = Port::HTTPS;
    let socket = SocketAddr::new(host, port);
    println!("Socket from domain: {}", socket);
    println!("  Is IP: {}", socket.is_ip());
    println!("  Is domain: {}", socket.is_domain_name());
    println!("  Port: {}\n", socket.as_port());

    // Parse from string
    let socket: SocketAddr = "192.168.1.1:8080".parse().unwrap();
    println!("Parsed socket: {}", socket);
    let (host, port) = socket.into_parts();
    println!("  Host: {}", host);
    println!("  Port: {}\n", port);

    // IPv6 socket
    let socket: SocketAddr = "[::1]:8080".parse().unwrap();
    println!("IPv6 socket: {}", socket);
    println!("  Is IPv6: {}\n", socket.is_ip());

    // Host type operations
    println!("=== Host Type Operations ===\n");

    let host_ip = Host::parse_str("192.168.1.1").unwrap();
    println!("Host from IP: {}", host_ip);
    println!("  Is IP: {}", host_ip.is_ipaddr());
    println!("  Is domain: {}", host_ip.is_domainname());
    println!("  Is hostname: {}", host_ip.is_hostname());

    let host_domain = Host::parse_str("example.com").unwrap();
    println!("\nHost from domain: {}", host_domain);
    println!("  Is IP: {}", host_domain.is_ipaddr());
    println!("  Is domain: {}", host_domain.is_domainname());

    let host_name = Host::parse_str("localhost").unwrap();
    println!("\nHost from hostname: {}", host_name);
    println!("  Is hostname: {}", host_name.is_hostname());
    println!("  Is localhost: {}", host_name.is_localhost());

    // Port operations
    println!("\n=== Port Operations ===\n");

    let port = Port::HTTP;
    println!("HTTP port: {}", port);
    println!("  Is system: {}", port.is_system_port());

    let port = Port::new(8080).unwrap();
    println!("\nCustom port: {}", port);
    println!("  Is system: {}", port.is_system_port());
    println!("  Is registered: {}", port.is_registered_port());
    println!("  Is dynamic: {}", port.is_dynamic_port());
}