Struct NvList 

pub struct NvList { /* private fields */ }

An ordered list of name-value pairs, converted from an illumos nvlist.

Implementations

impl NvList

pub unsafe fn from_raw(nvl: *mut nvlist) -> Result<NvList, NvError>

Convert a raw nvlist_t * into an owned NvList.

Pair names and string values are converted from C strings using lossy UTF-8 conversion: any bytes that are not valid UTF-8 are replaced with U+FFFD (\u{FFFD}). This means a lookup() call will not match the original name if it contained non-UTF-8 bytes.

Safety

nvl must be a valid, non-null pointer to an nvlist. The nvlist is borrowed - the caller retains ownership and is responsible for freeing it.

pub fn lookup(&self, name: &str) -> Option<&NvValue>

Look up a value by name.

Examples found in repository

examples/list_modules.rs (line 38)

fn main() {
    let adm = FmdAdm::open().expect("failed to open fmd adm handle");

    println!("=== FMD Modules ===");
    let modules = adm.modules().expect("failed to list modules");
    for m in &modules {
        println!(
            "  {} v{} - {}{}",
            m.name,
            m.version,
            m.description,
            if m.failed { " [FAILED]" } else { "" },
        );
    }
    println!("({} modules total)", modules.len());

    println!("\n=== Faulty Resources ===");
    let resources = adm.resources(true).expect("failed to list resources");
    if resources.is_empty() {
        println!("  (none)");
    } else {
        for r in &resources {
            println!("  {} (case {})", r.fmri, r.uuid);
        }
    }

    println!("\n=== Cases ===");
    let cases = adm.cases(None).expect("failed to list cases");
    if cases.is_empty() {
        println!("  (none)");
    } else {
        for c in &cases {
            let severity = c
                .event
                .as_ref()
                .and_then(|e| e.lookup("severity"))
                .and_then(|v| match v {
                    NvValue::String(s) => Some(s.as_str()),
                    _ => None,
                })
                .unwrap_or("unknown");
            println!("  {} - {} (severity: {})", c.uuid, c.code, severity);
        }
    }
}

pub fn iter(&self) -> impl Iterator<Item = (&str, &NvValue)>

Returns an iterator over the name-value pairs.

pub fn len(&self) -> usize

Returns the number of pairs.

pub fn is_empty(&self) -> bool

Returns true if the list contains no pairs.

Trait Implementations

impl Clone for NvList

fn clone(&self) -> NvList

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NvList

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

Formats the value using the given formatter.

impl<'a> IntoIterator for &'a NvList

type Item = (&'a str, &'a NvValue)

The type of the elements being iterated over.

type IntoIter = Map<Iter<'a, (String, NvValue)>, fn(&'a (String, NvValue)) -> (&'a str, &'a NvValue)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a NvList as IntoIterator>::IntoIter

Creates an iterator from a value.

impl IntoIterator for NvList

type Item = (String, NvValue)

The type of the elements being iterated over.

type IntoIter = IntoIter<(String, NvValue)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <NvList as IntoIterator>::IntoIter

Creates an iterator from a value.

impl PartialEq for NvList

fn eq(&self, other: &NvList) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for NvList