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
72
73
74
75
76

//! Example: System information types with bare-types
#![allow(unused_crate_dependencies)]

use bare_types::sys::{Arch, Distro, KernelVersion, OsType, OsVersion, Pid, Username};

fn main() {
    println!("=== bare-types System Info demo ===\n");

    println!("Architecture:");
    let arch = Arch::current();
    println!("  Current: {}", arch);
    println!("  Is 64-bit: {}", arch.is_64_bit());
    println!("  Is 32-bit: {}", arch.is_32_bit());
    println!("  Is x86: {}", arch.is_x86());
    println!("  Is ARM: {}", arch.is_arm());
    println!("  Is RISC-V: {}", arch.is_riscv());
    println!("  Is WASM: {}", arch.is_wasm());
    println!("  Pointer width: {} bits", arch.pointer_width());

    println!("\nOperating System:");
    let os = OsType::current();
    println!("  Current: {}", os);
    println!("  Is Unix: {}", os.is_unix());
    println!("  Is Windows: {}", os.is_windows());
    println!("  Is BSD: {}", os.is_bsd());
    println!("  Is mobile: {}", os.is_mobile());
    println!("  Is desktop: {}", os.is_desktop());
    println!("  Family: {}", os.family());

    println!("\nOS Version:");
    let os_ver: OsVersion = "22.04.3".parse().expect("Valid version");
    println!("  Version: {}", os_ver);
    println!("  Major: {}", os_ver.major());
    println!("  Minor: {}", os_ver.minor());
    println!("  Patch: {:?}", os_ver.patch());
    println!("  Is major release: {}", os_ver.is_major_release());

    println!("\nKernel Version:");
    let kernel: KernelVersion = "6.8.0-40-generic".parse().expect("Valid kernel");
    println!("  Version: {}", kernel);
    println!("  Major: {}", kernel.major());
    println!("  Minor: {}", kernel.minor());
    println!("  Patch: {}", kernel.patch());
    println!("  Release: {:?}", kernel.release());
    println!("  Is stable: {}", kernel.is_stable());
    println!("  Is development: {}", kernel.is_development());
    println!("  Is LTS: {}", kernel.is_lts());

    println!("\nDistribution:");
    let distro: Distro = "Ubuntu".parse().expect("Valid distro");
    println!("  Distro: {}", distro);
    println!("  Is Debian-based: {}", distro.is_debian_based());
    println!("  Is Red Hat-based: {}", distro.is_redhat_based());
    println!("  Is Arch-based: {}", distro.is_arch_based());
    println!("  Is rolling release: {}", distro.is_rolling_release());
    println!("  Is LTS: {}", distro.is_lts());

    println!("\nUser Management:");
    let username: Username = "www-data".parse().expect("Valid username");
    println!("  Username: {}", username);
    println!("  Is system user: {}", username.is_system_user());
    println!("  Is service account: {}", username.is_service_account());

    println!("\nProcess ID:");
    let pid: Pid = 1234.try_into().expect("Valid PID");
    println!("  PID: {}", pid);
    let init: Pid = 1.try_into().expect("Valid PID");
    println!("  PID 1 is init: {}", init.is_init());
    println!("  PID 1234 is system process: {}", pid.is_system_process());

    println!("\nAll types are:");
    println!("  - Compile-time constants for current() methods");
    println!("  - Zero-cost abstractions");
    println!("  - Fully no_std compatible");
    println!("  - Type-safe with validation at construction");
}