Struct ByteSize

Source

pub struct ByteSize(pub u64);

Expand description

Byte size representation

Tuple Fields§

§0: u64

Implementations§

Source §

pub const fn as_u64(&self) -> u64

Examples found in repository ?

examples/info.rs (line 74)

7fn main() {
8    let sys = System::new();
9
10    match sys.mounts() {
11        Ok(mounts) => {
12            println!("\nMounts:");
13            for mount in mounts.iter() {
14                println!("{} ---{}---> {} (available {} of {})",
15                         mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
16            }
17        }
18        Err(x) => println!("\nMounts: error: {}", x)
19    }
20
21    match sys.mount_at("/") {
22        Ok(mount) => {
23            println!("\nMount at /:");
24            println!("{} ---{}---> {} (available {} of {})",
25                     mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
26        }
27        Err(x) => println!("\nMount at /: error: {}", x)
28    }
29
30    match sys.block_device_statistics() {
31        Ok(stats) => {
32            for blkstats in stats.values() {
33                println!("{}: {:?}", blkstats.name, blkstats);
34            }
35        }
36        Err(x) => println!("\nBlock statistics error: {}", x)
37    }
38
39    match sys.networks() {
40        Ok(netifs) => {
41            println!("\nNetworks:");
42            for netif in netifs.values() {
43                println!("{} ({:?})", netif.name, netif.addrs);
44            }
45        }
46        Err(x) => println!("\nNetworks: error: {}", x)
47    }
48
49    match sys.networks() {
50        Ok(netifs) => {
51            println!("\nNetwork interface statistics:");
52            for netif in netifs.values() {
53                println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
54            }
55        }
56        Err(x) => println!("\nNetworks: error: {}", x)
57    }
58
59    match sys.battery_life() {
60        Ok(battery) =>
61            print!("\nBattery: {}%, {}h{}m remaining",
62                   battery.remaining_capacity*100.0,
63                   battery.remaining_time.as_secs() / 3600,
64                   battery.remaining_time.as_secs() % 60),
65        Err(x) => print!("\nBattery: error: {}", x)
66    }
67
68    match sys.on_ac_power() {
69        Ok(power) => println!(", AC power: {}", power),
70        Err(x) => println!(", AC power: error: {}", x)
71    }
72
73    match sys.memory() {
74        Ok(mem) => println!("\nMemory: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(mem.total, mem.free), mem.total, mem.total.as_u64(), mem.platform_memory),
75        Err(x) => println!("\nMemory: error: {}", x)
76    }
77
78    match sys.swap() {
79        Ok(swap) => println!("\nSwap: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(swap.total, swap.free), swap.total, swap.total.as_u64(), swap.platform_swap),
80        Err(x) => println!("\nSwap: error: {}", x)
81    }
82
83    match sys.load_average() {
84        Ok(loadavg) => println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen),
85        Err(x) => println!("\nLoad average: error: {}", x)
86    }
87
88    match sys.uptime() {
89        Ok(uptime) => println!("\nUptime: {:?}", uptime),
90        Err(x) => println!("\nUptime: error: {}", x)
91    }
92
93    match sys.boot_time() {
94        Ok(boot_time) => println!("\nBoot time: {}", boot_time),
95        Err(x) => println!("\nBoot time: error: {}", x)
96    }
97
98    match sys.cpu_load_aggregate() {
99        Ok(cpu)=> {
100            println!("\nMeasuring CPU load...");
101            thread::sleep(Duration::from_secs(1));
102            let cpu = cpu.done().unwrap();
103            println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
104                cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
105        },
106        Err(x) => println!("\nCPU load: error: {}", x)
107    }
108
109    match sys.cpu_temp() {
110        Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp),
111        Err(x) => println!("\nCPU temp: {}", x)
112    }
113
114    match sys.socket_stats() {
115        Ok(stats) => println!("\nSystem socket statistics: {:?}", stats),
116        Err(x) => println!("\nSystem socket statistics: error: {}", x)
117    }
118}