Nonvolatile   ![Latest Version]

Nonvolatile is a library for storing persistent settings and configuration data out of the way.

Nonvolatile state is created by instantiating a State instance with a name, usually the name of the program creating it. Any set values are written to disk in some common directory depending on the platform being used. Values persist until they are overwritten, and can be accessed by any program that loads the state with that name. State instances are exclusive (i.e., two programs or two instances of the same program cannot have the same State open at the same time).

Most of the builtin types, and any type that implements serde::Serialize/Deserialize may be passed into and read from State::set and State::get.

Example

```rust use nonvolatile::State; use generic_error::*;

fn main() -> Result<()> {

//create a new state instance with the name "foo"
let mut state = State::load_else_create("foo")?;
//set a variable in foo
state.set("var", String::from("some value"))?;

//destroy the state variable
drop(state);

//create a new state instance
let state = State::load_else_create("foo")?;
//retrieve the previously set variable.
println!("foo: {}", state.get::<String>("var").unwrap());  //"some value"   
Ok(())

} ```

Notes

By default, state for a given name will be stored in $HOME/.local/rust_nonvolatile/<name> for Linux and MacOS systems, and %appdata%\rust_nonvolatile\<name> for Windows systems. If $HOME or %appdata% are not defined in the program environment, then nonvolatile will fall back to /etc and C:\ProgramData for Linux/MacOS and Windows respectively.

If your environment is unreliable, or you have a location where you'd rather keep settings and configuration, the default storage location can be overridden using the *_from functions (new_from instead of new, load_from instead of load, load_else_create_from instead of load_else_create).

Be careful to be consistent with the storage location! If you use a state from one location during one instance of your program, and then use a state from a different location during the next, you will be left with two non-matching states with the same name in different places.

Available State Functions

```rust pub fn set (&mut self, var: &str, value: T) -> Result<()> pub fn get<'de, T> (&self, var: &str) -> Option pub fn has (&self, item: &str) -> bool pub fn delete (&mut self, name: &str) -> Result<()>

pub fn loadelsecreate (name: &str) -> Result pub fn loadelsecreatefrom(name: &str, path: &str) -> Result pub fn new (name: &str) -> Result pub fn newfrom (name: &str, storagepath: &str) -> Result pub fn load (name: &str) -> Result pub fn loadfrom (name: &str, storagepath: &str) -> Result pub fn destroystate (name: &str) pub fn destroystatefrom (name: &str, storage_path: &str) ```