[go: up one dir, main page]
sysinfo

Struct Networks

Source 
pub struct Networks { /* private fields */ }
Expand description

Interacting with network interfaces.

use sysinfo::Networks;

let networks = Networks::new_with_refreshed_list();
for (interface_name, network) in &networks {
    println!("[{interface_name}]: {network:?}");
}

Implementations§

Source§

impl Networks

Source

pub fn new() -> Self

Creates a new empty Networks type.

If you want it to be filled directly, take a look at Networks::new_with_refreshed_list.

use sysinfo::Networks;

let mut networks = Networks::new();
networks.refresh(true);
for (interface_name, network) in &networks {
    println!("[{interface_name}]: {network:?}");
}
Source

pub fn new_with_refreshed_list() -> Self

Creates a new Networks type with the network interfaces list loaded.

use sysinfo::Networks;

let networks = Networks::new_with_refreshed_list();
for network in &networks {
    println!("{network:?}");
}
Examples found in repository?
examples/simple.rs (line 476)
473fn main() {
474    println!("Getting system information...");
475    let mut system = System::new_all();
476    let mut networks = Networks::new_with_refreshed_list();
477    let mut disks = Disks::new_with_refreshed_list();
478    let mut components = Components::new_with_refreshed_list();
479    let mut users = Users::new_with_refreshed_list();
480
481    println!("Done.");
482    let t_stin = io::stdin();
483    let mut stin = t_stin.lock();
484    let mut done = false;
485
486    println!("To get the commands' list, enter 'help'.");
487    while !done {
488        let mut input = String::new();
489        write!(&mut io::stdout(), "> ");
490        io::stdout().flush();
491
492        stin.read_line(&mut input);
493        if input.is_empty() {
494            // The string is empty, meaning there is no '\n', meaning
495            // that the user used CTRL+D so we can just quit!
496            println!("\nLeaving, bye!");
497            break;
498        }
499        if (&input as &str).ends_with('\n') {
500            input.pop();
501        }
502        done = interpret_input(
503            input.as_ref(),
504            &mut system,
505            &mut networks,
506            &mut disks,
507            &mut components,
508            &mut users,
509        );
510    }
511}
Source

pub fn list(&self) -> &HashMap<String, NetworkData>

Returns the network interfaces map.

use sysinfo::Networks;

let networks = Networks::new_with_refreshed_list();
for network in networks.list() {
    println!("{network:?}");
}
Source

pub fn refresh(&mut self, remove_not_listed_interfaces: bool)

Refreshes the network interfaces.

use sysinfo::Networks;

let mut networks = Networks::new_with_refreshed_list();
// Wait some time...? Then refresh the data of each network.
networks.refresh(true);
Examples found in repository?
examples/simple.rs (line 172)
150fn interpret_input(
151    input: &str,
152    sys: &mut System,
153    networks: &mut Networks,
154    disks: &mut Disks,
155    components: &mut Components,
156    users: &mut Users,
157) -> bool {
158    match input.trim() {
159        "help" => print_help(),
160        "refresh_disks" => {
161            writeln!(&mut io::stdout(), "Refreshing disk list...");
162            disks.refresh(true);
163            writeln!(&mut io::stdout(), "Done.");
164        }
165        "refresh_users" => {
166            writeln!(&mut io::stdout(), "Refreshing user list...");
167            users.refresh();
168            writeln!(&mut io::stdout(), "Done.");
169        }
170        "refresh_networks" => {
171            writeln!(&mut io::stdout(), "Refreshing network list...");
172            networks.refresh(true);
173            writeln!(&mut io::stdout(), "Done.");
174        }
175        "refresh_components" => {
176            writeln!(&mut io::stdout(), "Refreshing component list...");
177            components.refresh(true);
178            writeln!(&mut io::stdout(), "Done.");
179        }
180        "refresh_cpu" => {
181            writeln!(&mut io::stdout(), "Refreshing CPUs...");
182            sys.refresh_cpu_all();
183            writeln!(&mut io::stdout(), "Done.");
184        }
185        "signals" => {
186            let mut nb = 1i32;
187
188            for sig in signals {
189                writeln!(&mut io::stdout(), "{nb:2}:{sig:?}");
190                nb += 1;
191            }
192        }
193        "cpus" => {
194            // Note: you should refresh a few times before using this, so that usage statistics
195            // can be ascertained
196            writeln!(
197                &mut io::stdout(),
198                "number of physical cores: {}",
199                System::physical_core_count()
200                    .map(|c| c.to_string())
201                    .unwrap_or_else(|| "Unknown".to_owned()),
202            );
203            writeln!(
204                &mut io::stdout(),
205                "total CPU usage: {}%",
206                sys.global_cpu_usage(),
207            );
208            for cpu in sys.cpus() {
209                writeln!(&mut io::stdout(), "{cpu:?}");
210            }
211        }
212        "memory" => {
213            writeln!(
214                &mut io::stdout(),
215                "total memory:     {: >10} KB",
216                sys.total_memory() / 1_000
217            );
218            writeln!(
219                &mut io::stdout(),
220                "available memory: {: >10} KB",
221                sys.available_memory() / 1_000
222            );
223            writeln!(
224                &mut io::stdout(),
225                "used memory:      {: >10} KB",
226                sys.used_memory() / 1_000
227            );
228            writeln!(
229                &mut io::stdout(),
230                "total swap:       {: >10} KB",
231                sys.total_swap() / 1_000
232            );
233            writeln!(
234                &mut io::stdout(),
235                "used swap:        {: >10} KB",
236                sys.used_swap() / 1_000
237            );
238        }
239        "quit" | "exit" => return true,
240        "all" => {
241            for (pid, proc_) in sys.processes() {
242                writeln!(
243                    &mut io::stdout(),
244                    "{}:{} status={:?}",
245                    pid,
246                    proc_.name().to_string_lossy(),
247                    proc_.status()
248                );
249            }
250        }
251        "frequency" => {
252            for cpu in sys.cpus() {
253                writeln!(
254                    &mut io::stdout(),
255                    "[{}] {} MHz",
256                    cpu.name(),
257                    cpu.frequency(),
258                );
259            }
260        }
261        "vendor_id" => {
262            writeln!(
263                &mut io::stdout(),
264                "vendor ID: {}",
265                sys.cpus()[0].vendor_id()
266            );
267        }
268        "brand" => {
269            writeln!(&mut io::stdout(), "brand: {}", sys.cpus()[0].brand());
270        }
271        "load_avg" => {
272            let load_avg = System::load_average();
273            writeln!(&mut io::stdout(), "one minute     : {}%", load_avg.one);
274            writeln!(&mut io::stdout(), "five minutes   : {}%", load_avg.five);
275            writeln!(&mut io::stdout(), "fifteen minutes: {}%", load_avg.fifteen);
276        }
277        e if e.starts_with("show ") => {
278            let tmp: Vec<&str> = e.split(' ').collect();
279
280            if tmp.len() != 2 {
281                writeln!(
282                    &mut io::stdout(),
283                    "show command takes a pid or a name in parameter!"
284                );
285                writeln!(&mut io::stdout(), "example: show 1254");
286            } else if let Ok(pid) = Pid::from_str(tmp[1]) {
287                match sys.process(pid) {
288                    Some(p) => {
289                        writeln!(&mut io::stdout(), "{:?}", *p);
290                        writeln!(
291                            &mut io::stdout(),
292                            "Files open/limit: {:?}/{:?}",
293                            p.open_files(),
294                            p.open_files_limit(),
295                        );
296                    }
297                    None => {
298                        writeln!(&mut io::stdout(), "pid \"{pid:?}\" not found");
299                    }
300                }
301            } else {
302                let proc_name = tmp[1];
303                for proc_ in sys.processes_by_name(proc_name.as_ref()) {
304                    writeln!(
305                        &mut io::stdout(),
306                        "==== {} ====",
307                        proc_.name().to_string_lossy()
308                    );
309                    writeln!(&mut io::stdout(), "{proc_:?}");
310                }
311            }
312        }
313        "temperature" => {
314            for component in components.iter() {
315                writeln!(&mut io::stdout(), "{component:?}");
316            }
317        }
318        "network" => {
319            for (interface_name, data) in networks.iter() {
320                writeln!(
321                    &mut io::stdout(),
322                    "{}:\n  ether {}\n  input data  (new / total): {} / {} B\n  output data (new / total): {} / {} B",
323                    interface_name,
324                    data.mac_address(),
325                    data.received(),
326                    data.total_received(),
327                    data.transmitted(),
328                    data.total_transmitted(),
329                );
330            }
331        }
332        "show" => {
333            writeln!(
334                &mut io::stdout(),
335                "'show' command expects a pid number or a process name"
336            );
337        }
338        e if e.starts_with("kill ") => {
339            let tmp: Vec<&str> = e.split(' ').collect();
340
341            if tmp.len() != 3 {
342                writeln!(
343                    &mut io::stdout(),
344                    "kill command takes the pid and a signal number in parameter!"
345                );
346                writeln!(&mut io::stdout(), "example: kill 1254 9");
347            } else {
348                let pid = Pid::from_str(tmp[1]).unwrap();
349                let signal = i32::from_str(tmp[2]).unwrap();
350
351                if signal < 1 || signal > 31 {
352                    writeln!(
353                        &mut io::stdout(),
354                        "Signal must be between 0 and 32 ! See the signals list with the \
355                         signals command"
356                    );
357                } else {
358                    match sys.process(pid) {
359                        Some(p) => {
360                            if let Some(res) =
361                                p.kill_with(*signals.get(signal as usize - 1).unwrap())
362                            {
363                                writeln!(&mut io::stdout(), "kill: {res}");
364                            } else {
365                                writeln!(
366                                    &mut io::stdout(),
367                                    "kill: signal not supported on this platform"
368                                );
369                            }
370                        }
371                        None => {
372                            writeln!(&mut io::stdout(), "pid not found");
373                        }
374                    };
375                }
376            }
377        }
378        "disks" => {
379            for disk in disks {
380                writeln!(&mut io::stdout(), "{disk:?}");
381            }
382        }
383        "users" => {
384            for user in users {
385                writeln!(
386                    &mut io::stdout(),
387                    "{:?} => {:?}",
388                    user.name(),
389                    user.groups()
390                );
391            }
392        }
393        "boot_time" => {
394            writeln!(&mut io::stdout(), "{} seconds", System::boot_time());
395        }
396        "uptime" => {
397            let up = System::uptime();
398            let mut uptime = up;
399            let days = uptime / 86400;
400            uptime -= days * 86400;
401            let hours = uptime / 3600;
402            uptime -= hours * 3600;
403            let minutes = uptime / 60;
404            writeln!(
405                &mut io::stdout(),
406                "{days} days {hours} hours {minutes} minutes ({up} seconds in total)",
407            );
408        }
409        x if x.starts_with("refresh") => {
410            if x == "refresh" {
411                writeln!(&mut io::stdout(), "Getting processes' information...");
412                sys.refresh_all();
413                writeln!(&mut io::stdout(), "Done.");
414            } else if x.starts_with("refresh ") {
415                writeln!(&mut io::stdout(), "Getting process' information...");
416                if let Some(pid) = x
417                    .split(' ')
418                    .filter_map(|pid| pid.parse().ok())
419                    .take(1)
420                    .next()
421                {
422                    if sys.refresh_processes(sysinfo::ProcessesToUpdate::Some(&[pid]), true) != 0 {
423                        writeln!(&mut io::stdout(), "Process `{pid}` updated successfully");
424                    } else {
425                        writeln!(&mut io::stdout(), "Process `{pid}` couldn't be updated...");
426                    }
427                } else {
428                    writeln!(&mut io::stdout(), "Invalid [pid] received...");
429                }
430            } else {
431                writeln!(
432                    &mut io::stdout(),
433                    "\"{x}\": Unknown command. Enter 'help' if you want to get the commands' \
434                     list.",
435                );
436            }
437        }
438        "pid" => {
439            writeln!(
440                &mut io::stdout(),
441                "PID: {}",
442                sysinfo::get_current_pid().expect("failed to get PID")
443            );
444        }
445        "system" => {
446            writeln!(
447                &mut io::stdout(),
448                "System name:              {}\n\
449                 System kernel version:    {}\n\
450                 System OS version:        {}\n\
451                 System OS (long) version: {}\n\
452                 System host name:         {}\n\
453		 System kernel:            {}",
454                System::name().unwrap_or_else(|| "<unknown>".to_owned()),
455                System::kernel_version().unwrap_or_else(|| "<unknown>".to_owned()),
456                System::os_version().unwrap_or_else(|| "<unknown>".to_owned()),
457                System::long_os_version().unwrap_or_else(|| "<unknown>".to_owned()),
458                System::host_name().unwrap_or_else(|| "<unknown>".to_owned()),
459                System::kernel_long_version(),
460            );
461        }
462        e => {
463            writeln!(
464                &mut io::stdout(),
465                "\"{e}\": Unknown command. Enter 'help' if you want to get the commands' \
466                 list.",
467            );
468        }
469    }
470    false
471}

Methods from Deref<Target = HashMap<String, NetworkData>>§

1.0.0

pub fn capacity(&self) -> usize

Returns the number of elements the map can hold without reallocating.

This number is a lower bound; the HashMap<K, V> might be able to hold more, but is guaranteed to be able to hold at least this many.

§Examples
use std::collections::HashMap;
let map: HashMap<i32, i32> = HashMap::with_capacity(100);
assert!(map.capacity() >= 100);
1.0.0

pub fn keys(&self) -> Keys<'_, K, V>

An iterator visiting all keys in arbitrary order. The iterator element type is &'a K.

§Examples
use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

for key in map.keys() {
    println!("{key}");
}
§Performance

In the current implementation, iterating over keys takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

1.0.0

pub fn values(&self) -> Values<'_, K, V>

An iterator visiting all values in arbitrary order. The iterator element type is &'a V.

§Examples
use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

for val in map.values() {
    println!("{val}");
}
§Performance

In the current implementation, iterating over values takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

1.0.0

pub fn iter(&self) -> Iter<'_, K, V>

An iterator visiting all key-value pairs in arbitrary order. The iterator element type is (&'a K, &'a V).

§Examples
use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

for (key, val) in map.iter() {
    println!("key: {key} val: {val}");
}
§Performance

In the current implementation, iterating over map takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

Examples found in repository?
examples/simple.rs (line 319)
150fn interpret_input(
151    input: &str,
152    sys: &mut System,
153    networks: &mut Networks,
154    disks: &mut Disks,
155    components: &mut Components,
156    users: &mut Users,
157) -> bool {
158    match input.trim() {
159        "help" => print_help(),
160        "refresh_disks" => {
161            writeln!(&mut io::stdout(), "Refreshing disk list...");
162            disks.refresh(true);
163            writeln!(&mut io::stdout(), "Done.");
164        }
165        "refresh_users" => {
166            writeln!(&mut io::stdout(), "Refreshing user list...");
167            users.refresh();
168            writeln!(&mut io::stdout(), "Done.");
169        }
170        "refresh_networks" => {
171            writeln!(&mut io::stdout(), "Refreshing network list...");
172            networks.refresh(true);
173            writeln!(&mut io::stdout(), "Done.");
174        }
175        "refresh_components" => {
176            writeln!(&mut io::stdout(), "Refreshing component list...");
177            components.refresh(true);
178            writeln!(&mut io::stdout(), "Done.");
179        }
180        "refresh_cpu" => {
181            writeln!(&mut io::stdout(), "Refreshing CPUs...");
182            sys.refresh_cpu_all();
183            writeln!(&mut io::stdout(), "Done.");
184        }
185        "signals" => {
186            let mut nb = 1i32;
187
188            for sig in signals {
189                writeln!(&mut io::stdout(), "{nb:2}:{sig:?}");
190                nb += 1;
191            }
192        }
193        "cpus" => {
194            // Note: you should refresh a few times before using this, so that usage statistics
195            // can be ascertained
196            writeln!(
197                &mut io::stdout(),
198                "number of physical cores: {}",
199                System::physical_core_count()
200                    .map(|c| c.to_string())
201                    .unwrap_or_else(|| "Unknown".to_owned()),
202            );
203            writeln!(
204                &mut io::stdout(),
205                "total CPU usage: {}%",
206                sys.global_cpu_usage(),
207            );
208            for cpu in sys.cpus() {
209                writeln!(&mut io::stdout(), "{cpu:?}");
210            }
211        }
212        "memory" => {
213            writeln!(
214                &mut io::stdout(),
215                "total memory:     {: >10} KB",
216                sys.total_memory() / 1_000
217            );
218            writeln!(
219                &mut io::stdout(),
220                "available memory: {: >10} KB",
221                sys.available_memory() / 1_000
222            );
223            writeln!(
224                &mut io::stdout(),
225                "used memory:      {: >10} KB",
226                sys.used_memory() / 1_000
227            );
228            writeln!(
229                &mut io::stdout(),
230                "total swap:       {: >10} KB",
231                sys.total_swap() / 1_000
232            );
233            writeln!(
234                &mut io::stdout(),
235                "used swap:        {: >10} KB",
236                sys.used_swap() / 1_000
237            );
238        }
239        "quit" | "exit" => return true,
240        "all" => {
241            for (pid, proc_) in sys.processes() {
242                writeln!(
243                    &mut io::stdout(),
244                    "{}:{} status={:?}",
245                    pid,
246                    proc_.name().to_string_lossy(),
247                    proc_.status()
248                );
249            }
250        }
251        "frequency" => {
252            for cpu in sys.cpus() {
253                writeln!(
254                    &mut io::stdout(),
255                    "[{}] {} MHz",
256                    cpu.name(),
257                    cpu.frequency(),
258                );
259            }
260        }
261        "vendor_id" => {
262            writeln!(
263                &mut io::stdout(),
264                "vendor ID: {}",
265                sys.cpus()[0].vendor_id()
266            );
267        }
268        "brand" => {
269            writeln!(&mut io::stdout(), "brand: {}", sys.cpus()[0].brand());
270        }
271        "load_avg" => {
272            let load_avg = System::load_average();
273            writeln!(&mut io::stdout(), "one minute     : {}%", load_avg.one);
274            writeln!(&mut io::stdout(), "five minutes   : {}%", load_avg.five);
275            writeln!(&mut io::stdout(), "fifteen minutes: {}%", load_avg.fifteen);
276        }
277        e if e.starts_with("show ") => {
278            let tmp: Vec<&str> = e.split(' ').collect();
279
280            if tmp.len() != 2 {
281                writeln!(
282                    &mut io::stdout(),
283                    "show command takes a pid or a name in parameter!"
284                );
285                writeln!(&mut io::stdout(), "example: show 1254");
286            } else if let Ok(pid) = Pid::from_str(tmp[1]) {
287                match sys.process(pid) {
288                    Some(p) => {
289                        writeln!(&mut io::stdout(), "{:?}", *p);
290                        writeln!(
291                            &mut io::stdout(),
292                            "Files open/limit: {:?}/{:?}",
293                            p.open_files(),
294                            p.open_files_limit(),
295                        );
296                    }
297                    None => {
298                        writeln!(&mut io::stdout(), "pid \"{pid:?}\" not found");
299                    }
300                }
301            } else {
302                let proc_name = tmp[1];
303                for proc_ in sys.processes_by_name(proc_name.as_ref()) {
304                    writeln!(
305                        &mut io::stdout(),
306                        "==== {} ====",
307                        proc_.name().to_string_lossy()
308                    );
309                    writeln!(&mut io::stdout(), "{proc_:?}");
310                }
311            }
312        }
313        "temperature" => {
314            for component in components.iter() {
315                writeln!(&mut io::stdout(), "{component:?}");
316            }
317        }
318        "network" => {
319            for (interface_name, data) in networks.iter() {
320                writeln!(
321                    &mut io::stdout(),
322                    "{}:\n  ether {}\n  input data  (new / total): {} / {} B\n  output data (new / total): {} / {} B",
323                    interface_name,
324                    data.mac_address(),
325                    data.received(),
326                    data.total_received(),
327                    data.transmitted(),
328                    data.total_transmitted(),
329                );
330            }
331        }
332        "show" => {
333            writeln!(
334                &mut io::stdout(),
335                "'show' command expects a pid number or a process name"
336            );
337        }
338        e if e.starts_with("kill ") => {
339            let tmp: Vec<&str> = e.split(' ').collect();
340
341            if tmp.len() != 3 {
342                writeln!(
343                    &mut io::stdout(),
344                    "kill command takes the pid and a signal number in parameter!"
345                );
346                writeln!(&mut io::stdout(), "example: kill 1254 9");
347            } else {
348                let pid = Pid::from_str(tmp[1]).unwrap();
349                let signal = i32::from_str(tmp[2]).unwrap();
350
351                if signal < 1 || signal > 31 {
352                    writeln!(
353                        &mut io::stdout(),
354                        "Signal must be between 0 and 32 ! See the signals list with the \
355                         signals command"
356                    );
357                } else {
358                    match sys.process(pid) {
359                        Some(p) => {
360                            if let Some(res) =
361                                p.kill_with(*signals.get(signal as usize - 1).unwrap())
362                            {
363                                writeln!(&mut io::stdout(), "kill: {res}");
364                            } else {
365                                writeln!(
366                                    &mut io::stdout(),
367                                    "kill: signal not supported on this platform"
368                                );
369                            }
370                        }
371                        None => {
372                            writeln!(&mut io::stdout(), "pid not found");
373                        }
374                    };
375                }
376            }
377        }
378        "disks" => {
379            for disk in disks {
380                writeln!(&mut io::stdout(), "{disk:?}");
381            }
382        }
383        "users" => {
384            for user in users {
385                writeln!(
386                    &mut io::stdout(),
387                    "{:?} => {:?}",
388                    user.name(),
389                    user.groups()
390                );
391            }
392        }
393        "boot_time" => {
394            writeln!(&mut io::stdout(), "{} seconds", System::boot_time());
395        }
396        "uptime" => {
397            let up = System::uptime();
398            let mut uptime = up;
399            let days = uptime / 86400;
400            uptime -= days * 86400;
401            let hours = uptime / 3600;
402            uptime -= hours * 3600;
403            let minutes = uptime / 60;
404            writeln!(
405                &mut io::stdout(),
406                "{days} days {hours} hours {minutes} minutes ({up} seconds in total)",
407            );
408        }
409        x if x.starts_with("refresh") => {
410            if x == "refresh" {
411                writeln!(&mut io::stdout(), "Getting processes' information...");
412                sys.refresh_all();
413                writeln!(&mut io::stdout(), "Done.");
414            } else if x.starts_with("refresh ") {
415                writeln!(&mut io::stdout(), "Getting process' information...");
416                if let Some(pid) = x
417                    .split(' ')
418                    .filter_map(|pid| pid.parse().ok())
419                    .take(1)
420                    .next()
421                {
422                    if sys.refresh_processes(sysinfo::ProcessesToUpdate::Some(&[pid]), true) != 0 {
423                        writeln!(&mut io::stdout(), "Process `{pid}` updated successfully");
424                    } else {
425                        writeln!(&mut io::stdout(), "Process `{pid}` couldn't be updated...");
426                    }
427                } else {
428                    writeln!(&mut io::stdout(), "Invalid [pid] received...");
429                }
430            } else {
431                writeln!(
432                    &mut io::stdout(),
433                    "\"{x}\": Unknown command. Enter 'help' if you want to get the commands' \
434                     list.",
435                );
436            }
437        }
438        "pid" => {
439            writeln!(
440                &mut io::stdout(),
441                "PID: {}",
442                sysinfo::get_current_pid().expect("failed to get PID")
443            );
444        }
445        "system" => {
446            writeln!(
447                &mut io::stdout(),
448                "System name:              {}\n\
449                 System kernel version:    {}\n\
450                 System OS version:        {}\n\
451                 System OS (long) version: {}\n\
452                 System host name:         {}\n\
453		 System kernel:            {}",
454                System::name().unwrap_or_else(|| "<unknown>".to_owned()),
455                System::kernel_version().unwrap_or_else(|| "<unknown>".to_owned()),
456                System::os_version().unwrap_or_else(|| "<unknown>".to_owned()),
457                System::long_os_version().unwrap_or_else(|| "<unknown>".to_owned()),
458                System::host_name().unwrap_or_else(|| "<unknown>".to_owned()),
459                System::kernel_long_version(),
460            );
461        }
462        e => {
463            writeln!(
464                &mut io::stdout(),
465                "\"{e}\": Unknown command. Enter 'help' if you want to get the commands' \
466                 list.",
467            );
468        }
469    }
470    false
471}
1.0.0

pub fn len(&self) -> usize

Returns the number of elements in the map.

§Examples
use std::collections::HashMap;

let mut a = HashMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);
1.0.0

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

§Examples
use std::collections::HashMap;

let mut a = HashMap::new();
assert!(a.is_empty());
a.insert(1, "a");
assert!(!a.is_empty());
1.9.0

pub fn hasher(&self) -> &S

Returns a reference to the map’s [BuildHasher].

§Examples
use std::collections::HashMap;
use std::hash::RandomState;

let hasher = RandomState::new();
let map: HashMap<i32, i32> = HashMap::with_hasher(hasher);
let hasher: &RandomState = map.hasher();
1.0.0

pub fn get<Q>(&self, k: &Q) -> Option<&V>
where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but [Hash] and [Eq] on the borrowed form must match those for the key type.

§Examples
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);
1.40.0

pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>
where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns the key-value pair corresponding to the supplied key. This is potentially useful:

  • for key types where non-identical keys can be considered equal;
  • for getting the &K stored key value from a borrowed &Q lookup key; or
  • for getting a reference to a key with the same lifetime as the collection.

The supplied key may be any borrowed form of the map’s key type, but [Hash] and [Eq] on the borrowed form must match those for the key type.

§Examples
use std::collections::HashMap;
use std::hash::{Hash, Hasher};

#[derive(Clone, Copy, Debug)]
struct S {
    id: u32,
    name: &'static str, // ignored by equality and hashing operations
}

impl PartialEq for S {
    fn eq(&self, other: &S) -> bool {
        self.id == other.id
    }
}

impl Eq for S {}

impl Hash for S {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.id.hash(state);
    }
}

let j_a = S { id: 1, name: "Jessica" };
let j_b = S { id: 1, name: "Jess" };
let p = S { id: 2, name: "Paul" };
assert_eq!(j_a, j_b);

let mut map = HashMap::new();
map.insert(j_a, "Paris");
assert_eq!(map.get_key_value(&j_a), Some((&j_a, &"Paris")));
assert_eq!(map.get_key_value(&j_b), Some((&j_a, &"Paris"))); // the notable case
assert_eq!(map.get_key_value(&p), None);
1.0.0

pub fn contains_key<Q>(&self, k: &Q) -> bool
where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns true if the map contains a value for the specified key.

The key may be any borrowed form of the map’s key type, but [Hash] and [Eq] on the borrowed form must match those for the key type.

§Examples
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);

Trait Implementations§

Source§

impl Debug for Networks

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl Default for Networks

Source§

fn default() -> Self

Returns the “default value” for a type. Read more
Source§

impl Deref for Networks

Source§

type Target = HashMap<String, NetworkData>

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

impl<'a> IntoIterator for &'a Networks

Source§

type Item = (&'a String, &'a NetworkData)

The type of the elements being iterated over.
Source§

type IntoIter = Iter<'a, String, NetworkData>

Which kind of iterator are we turning this into?
Source§

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more
Source§

impl Serialize for Networks

Source§

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

§

impl Freeze for Networks

§

impl RefUnwindSafe for Networks

§

impl Send for Networks

§

impl Sync for Networks

§

impl Unpin for Networks

§

impl UnwindSafe for Networks

Blanket Implementations§

§

impl<T> Any for T
where T: 'static + ?Sized,

§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T> Borrow<T> for T
where T: ?Sized,

§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
§

impl<T> BorrowMut<T> for T
where T: ?Sized,

§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> From<T> for T

§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T, U> Into<U> for T
where U: From<T>,

§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.