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

//! IP Range Operations Demo
//!
//! This example demonstrates the IP range operations available in bare-types.

use bare_types::net::{Ipv4Range, Ipv6Range};

fn main() {
    println!("=== IPv4 Range Operations ===\n");

    // Create an IPv4 range
    let range: Ipv4Range = "192.168.1.0-192.168.1.255".parse().unwrap();
    println!("Created range: {}", range);
    println!("Start: {}", range.start());
    println!("End: {}", range.end());
    println!("Number of addresses: {}\n", range.num_addresses());

    // Check if IP is in range
    let ip = core::net::Ipv4Addr::new(192, 168, 1, 100);
    println!("Contains {}: {}\n", ip, range.contains(&ip));

    // Check CIDR compatibility
    println!("Is CIDR compatible: {}", range.is_cidr_compatible());
    if range.is_cidr_compatible() {
        println!("CIDR prefix length: {:?}\n", range.cidr_prefix_len());
    }

    // Test contains_range
    let sub_range: Ipv4Range = "192.168.1.100-192.168.1.200".parse().unwrap();
    println!(" subrange: {}", sub_range);
    println!(
        "range contains subrange: {}",
        range.contains_range(&sub_range)
    );

    // Test overlaps
    let overlap_range: Ipv4Range = "192.168.1.200-192.168.2.50".parse().unwrap();
    println!("\nOverlap range: {}", overlap_range);
    println!("Ranges overlap: {}", range.overlaps(&overlap_range));

    // Test adjacent ranges
    let adjacent: Ipv4Range = "192.168.2.0-192.168.2.255".parse().unwrap();
    println!("\nAdjacent range: {}", adjacent);
    println!("Is adjacent: {}", range.is_adjacent_to(&adjacent));

    // Test merge
    if let Some(merged) = range.merge(&adjacent) {
        println!("\nMerged range: {}", merged);
    }

    println!("\n=== IPv6 Range Operations ===\n");

    // Create an IPv6 range
    let range6: Ipv6Range = "2001:db8::1-2001:db8::ffff".parse().unwrap();
    println!("Created range: {}", range6);
    println!("Number of addresses: {}\n", range6.num_addresses());

    // Check CIDR compatibility
    println!("Is CIDR compatible: {}", range6.is_cidr_compatible());
    if let Some(prefix) = range6.cidr_prefix_len() {
        println!("CIDR prefix length: {}", prefix);
    }
}