Struct libnv::libnv::NvList

pub struct NvList { /* fields omitted */ }

A list of name/value pairs.

Implementations

impl NvList

pub fn as_ptr(&self) -> *mut nvlist

Make a copy of a pointer. Danger zone.

pub fn new(flags: NvFlag) -> NvResult<NvList>

Create a new name/value pair list (nvlist). Call this can only fail when system is out of memory.

use libnv::libnv::{NvList, NvFlag};

let nvlist = NvList::new(NvFlag::None).unwrap();

pub fn is_empty(&self) -> bool

Determines if the nvlist is empty.

use libnv::libnv::{NvList, NvFlag};
let nvlist = NvList::new(NvFlag::IgnoreCase).unwrap();
assert!(nvlist.is_empty());

pub fn flags(&self) -> NvFlag

The flags the nvlist was created with.

use libnv::libnv::{NvList, NvFlag};
let nvlist = NvList::new(NvFlag::NoUnique).unwrap();

assert_eq!(nvlist.flags(), NvFlag::NoUnique);

pub fn error(&self) -> i32

Gets error value that the list may have accumulated.

use libnv::libnv::{NvList, NvFlag};
let list = NvList::new(NvFlag::NoUnique).unwrap();

assert_eq!(0, list.error());

pub fn set_error(&mut self, error: i32) -> NvResult<()>

Sets the NvList to be in an error state.

use libnv::libnv::{NvList, NvFlag};

let mut list = NvList::new(NvFlag::Both).unwrap();

// EINVAL
list.set_error(0x16).unwrap();

assert_eq!(0x16, list.error());

pub fn insert<T: NvTypeOp>(&mut self, name: &str, value: T) -> NvResult<()>

Sugared way to add a single value to the NvList.

use libnv::libnv::{NvList, NvFlag, NvTypeOp};

let mut list = NvList::default();

let the_answer: u32 = 1776;
let not_the_answer: Option<u64> = None;

list.insert("Important year", the_answer);
list.insert("not important year", not_the_answer);
let copy = list.clone();
list.insert("foo", copy);

assert_eq!(list.get_number("Important year").unwrap().unwrap(), 1776);

pub fn insert_null(&mut self, name: &str) -> NvResult<()>

Add a null value to the NvList.

use libnv::libnv::{NvList, NvFlag, NvTypeOp};
let mut list = NvList::new(NvFlag::Both).unwrap();
list.insert_null("Hello, World!");

pub fn insert_number<I: Into<u64>>(
    &mut self,
    name: &str,
    value: I
) -> NvResult<()>

Add a number to the NvList. Number will be converted into u64.

use libnv::libnv::{NvList, NvFlag};

let mut list = NvList::new(NvFlag::Both).unwrap();

list.insert_number("Important year", 1776u64);

pub fn insert_bool(&mut self, name: &str, value: bool) -> NvResult<()>

Add a bool to the list.

pub fn insert_string(&mut self, name: &str, value: &str) -> NvResult<()>

Add string to the list.

pub fn insert_nvlist(&mut self, name: &str, value: &NvList) -> NvResult<()>

Add NvList to the list.

use libnv::libnv::{NvList, NvFlag};

let mut list = NvList::default();

let other_list = NvList::default();

list.insert_nvlist("other list", &other_list).unwrap();

pub unsafe fn add_binary(
    &mut self,
    name: &str,
    value: *mut i8,
    size: u32
) -> NvResult<()>

Add binary data to the list. TODO: make this safe.

pub fn insert_bools(&mut self, name: &str, value: &[bool]) -> NvResult<()>

Add an array of bool values.

use libnv::libnv::{NvList, NvFlag};

let mut list = NvList::new(NvFlag::Both).unwrap();

let slice = [true, false, true, false];

list.insert_bools("Important year", &slice);

pub fn insert_numbers(&mut self, name: &str, value: &[u64]) -> NvResult<()>

Add an array if u64. TODO: Make it work with any number…

use libnv::libnv::{NvList, NvFlag};

let mut list = NvList::new(NvFlag::None).unwrap();

let slice = [1776, 2017];

list.insert_numbers("Important year", &slice);

pub fn insert_strings(&mut self, name: &str, value: &[&str]) -> NvResult<()>

Add an array of strings

use libnv::libnv::{NvList, NvFlag};

let mut list = NvList::new(NvFlag::None).unwrap();

let orig = ["Hello", "World!"];

list.insert_strings("key", &orig).unwrap();

let vec = list.get_strings("key").unwrap().unwrap();

assert_eq!(*vec, ["Hello", "World!"]);

pub fn insert_nvlists(&mut self, name: &str, value: &[NvList]) -> NvResult<()>

Add an array of NvLists

use libnv::libnv::{NvList, NvFlag};

let mut list = NvList::new(NvFlag::Both).unwrap();

let slice = [NvList::new(NvFlag::Both).unwrap(),
NvList::new(NvFlag::Both).unwrap(),
             NvList::new(NvFlag::None).unwrap()];

list.insert_nvlists("nvlists", &slice);

let mut nvlists = list.get_nvlists("nvlists").unwrap().unwrap();

assert_eq!(NvFlag::None, nvlists.pop().unwrap().flags());

pub fn contains_key(&self, name: &str) -> NvResult<bool>

Returns true if a name/value pair exists in the NvList and false otherwise.

use libnv::libnv::{NvList, NvFlag};

let mut list = NvList::new(NvFlag::Both).unwrap();

let result = list.insert_number("Important year", 1776u64);
assert!(result.is_ok());

assert!(list.contains_key("Important year").unwrap());

pub fn contains_key_with_type(&self, name: &str, ty: NvType) -> NvResult<bool>

Returns true if a name/value pair of the specified type exists and false otherwise.

use libnv::libnv::{NvList, NvFlag, NvType};

let mut list = NvList::new(NvFlag::Both).unwrap();

let result = list.insert_number("Important year", 1776u64);
assert!(result.is_ok());

assert!(!list.contains_key_with_type("Important year", NvType::Bool).unwrap());

pub fn get_bool(&self, name: &str) -> NvResult<Option<bool>>

Get the first matching bool value paired with the given name.

use libnv::libnv::NvList;

let mut list = NvList::default();

list.insert_bool("Did history start on 1776?", true).unwrap();

assert!(list.get_bool("Did history start on 1776?").unwrap().unwrap(),
true);

pub fn get_number(&self, name: &str) -> NvResult<Option<u64>>

Get the first matching u64 value paired with the given name.

pub fn get_string(&self, name: &str) -> NvResult<Option<String>>

Get the first matching u64 value paired with the given name

use libnv::libnv::{NvList, NvFlag};

// Note: we're allowing duplicate values per name
let mut list = NvList::default();

list.insert_string("Hello", "World!").unwrap();

assert_eq!(list.get_string("Hello").unwrap().unwrap(), "World!");

pub fn get_nvlist(&self, name: &str) -> NvResult<Option<NvList>>

Get the first matching NvList value paired with the given name and clone it

use libnv::libnv::{NvList, NvFlag};

let mut list = NvList::new(NvFlag::Both).unwrap();

list.insert_bool("other list", true).unwrap();

let mut other_list = NvList::new(NvFlag::None).unwrap();
other_list.insert_number("Important year", 42u32).unwrap();

list.insert_nvlist("other list", &other_list).unwrap();

// Since we use `get_nvlist` we will get the
// NvList not the boolean value
let other_nvlist = list.get_nvlist("other list").unwrap().unwrap();

assert_eq!(other_nvlist.get_number("Important year").unwrap().unwrap(),
42);

pub fn get_bools<'a>(&'a self, name: &str) -> NvResult<Option<&'a [bool]>>

Get a &[bool] from the NvList

use libnv::libnv::{NvList, NvFlag};

// Note: we're allowing duplicate values per name
let mut list = NvList::new(NvFlag::None).unwrap();

list.insert_bools("true/false", &[true, false, true]).unwrap();

assert_eq!(list.get_bools("true/false").unwrap().unwrap(), &[true,
false, true]);

pub fn get_numbers(&self, name: &str) -> NvResult<Option<&[u64]>>

Get a &[u64] slice from the NvList

use libnv::libnv::{NvList, NvFlag};

// Note: we're allowing duplicate values per name
let mut list = NvList::default();

list.insert_numbers("The Year", &[1, 7, 7, 6]).unwrap();

assert_eq!(list.get_numbers("The Year").unwrap().unwrap(), &[1, 7, 7,
6]);

pub fn get_strings(&self, name: &str) -> NvResult<Option<Vec<String>>>

Get a Vec<String> of the first string slice added to the NvList for the given name

pub fn get_nvlists(&self, name: &str) -> NvResult<Option<Vec<NvList>>>

Get an array of NvList.

use libnv::libnv::{NvList, NvFlag};

let mut list = NvList::new(NvFlag::None).unwrap();

list.insert_nvlists("lists", &[NvList::default(),
                                      NvList::default()]).unwrap();

let vec = list.get_nvlists("lists").unwrap().unwrap();

assert_eq!(vec.len(), 2);
assert_eq!(vec[0].flags(), NvFlag::None);

pub fn dump<T: AsRawFd>(&self, out: T) -> NvResult<()>

Write NvList to a file descriptor.

use std::fs::File;
use libnv::libnv::NvList;

let mut list = NvList::default();

list.insert_number("Important year", 1776u64);

list.dump(File::create("/tmp/libnv_nv.dump").unwrap());

pub fn len(&self) -> i32

The size of the current list

pub fn remove(&mut self, name: &str) -> NvResult<()>

Removes a key from the NvList.

pub fn remove_with_type(&mut self, name: &str, ty: NvType) -> NvResult<()>

Remove the element of the given name and type from the NvList

Trait Implementations

impl Clone for NvList

fn clone(&self) -> NvList

Clone list using libnv method. This will perform deep copy.

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

Performs copy-assignment from source.

impl Debug for NvList

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

Formats the value using the given formatter.

impl Drop for NvList

fn drop(&mut self)

Using libnv method.

impl NvTypeOp for NvList

fn add_to_list(&self, list: &mut NvList, name: &str) -> NvResult<()>

Add a $type_ value to the NvList