Struct KV 

pub struct KV {
    pub kv: HashMap<String, KvValue>,
}

A simple key-value storage

Keeps pairs of (&'static str, KvValue) and is used to pass key-value pairs to Observers in each iteration of an optimization algorithm. Typically constructed using the kv! macro.

Example

use argmin::kv;

let kv = kv!(
    "key1" => "value1";
    "key2" => "value2";
    "key3" => 1234;
);

Fields

kv: HashMap<String, KvValue>

The actual key value storage

Implementations

impl KV

pub fn new() -> KV

Constructor a new empty KV

Example

let kv = KV::new();

pub fn insert<T>(&mut self, key: T, val: KvValue) -> &mut KV

where T: AsRef<str>,

Insert a key-value pair

Example

let mut kv = KV::new();
kv.insert("key1", KvValue::Str("value".to_string()));
kv.insert("key2", KvValue::Int(1234));

pub fn get<T>(&self, key: T) -> Option<&KvValue>

where T: AsRef<str>,

Retrieve an element from the KV by key

Returns Some(<reference to KvValue>) if key is present and None otherwise.

Example

let mut kv1 = KV::new();
kv1.insert("key1", KvValue::Float(12.0));

assert_eq!(kv1.get("key1"), Some(&KvValue::Float(12.0)));
assert_eq!(kv1.get("non_existing"), None);

pub fn keys(&self) -> Vec<(String, &'static str)>

Returns all available keys and their KvValue kind

Example

let mut kv1 = KV::new();
kv1.insert("key1", KvValue::Str("value1".to_string()));

assert_eq!(kv1.keys(), vec![("key1".to_string(), "Str")]);

pub fn merge(self, other: KV) -> KV

Merge with another KV

Example

let mut kv1 = KV::new();
kv1.insert("key1", KvValue::Str("value1".to_string()));

let mut kv2 = KV::new();
kv2.insert("key2", KvValue::Str("value2".to_string()));

let kv1 = kv1.merge(kv2);

Trait Implementations

impl Clone for KV

fn clone(&self) -> KV

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KV

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

Formats the value using the given formatter.

impl Default for KV

fn default() -> KV

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for KV

fn deserialize<__D>( __deserializer: __D, ) -> Result<KV, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for KV

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

Formats the value using the given formatter.

impl Extend<(&'static str, KvValue)> for KV

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = (&'static str, KvValue)>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<(&'static str, KvValue)> for KV

fn from_iter<I>(iter: I) -> KV

where I: IntoIterator<Item = (&'static str, KvValue)>,

Creates a value from an iterator.

impl PartialEq for KV

fn eq(&self, other: &KV) -> 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 Serialize for KV

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for KV