Struct blather::Params [−][src]
Key/value parameters storage with helper methods to make adding and getting
common value types slightly more ergonomic and using a plain HashMap
.
Uses String
s for both keys and values internally.
Implementations
impl Params
[src]
pub fn new() -> Self
[src]
Create a new empty parameters object.
pub fn clear(&mut self)
[src]
Reset all the key/values in Params
object.
pub fn len(&self) -> usize
[src]
Return the number of key/value pairs in the parameter buffer.
pub fn get_inner(&self) -> &HashMap<String, String>
[src]
Return reference to inner HashMap.
pub fn add_param<T: ToString, U: ToString>(
&mut self,
key: T,
value: U
) -> Result<(), Error>
[src]
&mut self,
key: T,
value: U
) -> Result<(), Error>
Add a parameter to the parameter.
The key
and value
parameters are generic over the trait ToString
,
allowing a polymorphic behavior.
Examples
use blather::Params; fn main() { let mut params = Params::new(); params.add_param("integer", 42).unwrap(); params.add_param("string", "hello").unwrap(); }
pub fn add_str(&mut self, key: &str, value: &str) -> Result<(), Error>
[src]
Add a string parameter to the parameter.
Notes
- This method exists for parity with a C++ interface and is a less
flexible version of
add_param()
, which application should use instead.
pub fn add_strit<I, S>(&mut self, key: &str, c: I) -> Result<(), Error> where
I: IntoIterator<Item = S>,
S: AsRef<str>,
[src]
I: IntoIterator<Item = S>,
S: AsRef<str>,
Add parameter where the value is generated from an iterator over strings, where entries are comma-separated.
Examples
use std::collections::HashSet; use blather::Params; fn main() { let mut params = Params::new(); params.add_strit("Cat", &["meow", "paws", "tail"]).unwrap(); assert_eq!(params.get_str("Cat"), Some("meow,paws,tail")); let v = vec!["meow", "paws", "tail"]; params.add_strit("CatToo", v.into_iter()).unwrap(); assert_eq!(params.get_str("CatToo"), Some("meow,paws,tail")); let mut hs = HashSet::new(); hs.insert("Elena"); hs.insert("Drake"); params.add_strit("Uncharted", hs.into_iter()).unwrap(); }
pub fn add_bool<K: ToString>(
&mut self,
key: K,
value: bool
) -> Result<(), Error>
[src]
&mut self,
key: K,
value: bool
) -> Result<(), Error>
Add a boolean parameter.
Examples
use blather::Params; fn main() { let mut params = Params::new(); params.add_bool("should_be_true", true).unwrap(); params.add_bool("should_be_false", false).unwrap(); assert_eq!(params.get_bool("should_be_true"), Ok(true)); assert_eq!(params.get_bool("should_be_false"), Ok(false)); }
Notes
- Applications should not make assumptions about the specific string
value added by this function. Do not treat boolean values as strings;
use the
get_bool()
method instead.
pub fn have(&self, key: &str) -> bool
[src]
Returns true
if the parameter with key
exists. Returns false
otherwise.
pub fn get_param<T: FromStr>(&self, key: &str) -> Result<T, Error>
[src]
Get a parameter and convert it to a requested type, fail if key isn’t found.
Examples
use blather::{Params, Error}; fn main() { let mut params = Params::new(); params.add_param("arthur", 42); let fourtytwo = params.get_param::<u32>("arthur").unwrap(); assert_eq!(fourtytwo, 42); let nonexist = params.get_param::<u32>("ford"); assert_eq!(nonexist, Err(Error::KeyNotFound("ford".to_string()))); }
pub fn get_param_def<T: FromStr>(&self, key: &str, def: T) -> Result<T, Error>
[src]
Get a parameter and convert it to a requested type, return a default value if key isn’t found.
Examples
use blather::Params; fn main() { let mut params = Params::new(); let val = params.get_param_def::<u32>("nonexist", 11); assert_eq!(val, Ok(11)); }
pub fn get_str(&self, key: &str) -> Option<&str>
[src]
Get string representation of a value for a requested key.
Returns None
if the key is not found in the inner storage. Returns
Some(&str)
if parameter exists.
pub fn get_str_def<'a>(&'a self, key: &str, def: &'a str) -> &'a str
[src]
Get string representation of a value for a requested key. Returns a default value if key does not exist in parameter buffer.
Examples
use blather::Params; fn main() { let params = Params::new(); let e = params.get_str_def("nonexist", "elena"); assert_eq!(e, "elena"); }
pub fn get_int<T: FromStr>(&self, key: &str) -> Result<T, Error>
[src]
Get a parameter and convert it to an integer type.
Examples
use blather::Params; fn main() { let mut params = Params::new(); params.add_param("Num", 7); assert_eq!(params.get_int::<usize>("Num").unwrap(), 7); }
Notes
- This method exists primarily to achive some sort of parity with a
corresponding C++ library. It is recommended that applications use
Params::get_param()
instead.
pub fn get_int_def<T: FromStr>(&self, key: &str, def: T) -> Result<T, Error>
[src]
Try to get the value of a key and interpret it as an integer. If the key does not exist then return a default value supplied by the caller.
Examples
use blather::Params; fn main() { let mut params = Params::new(); params.add_param("num", 11); assert_eq!(params.get_int_def::<u32>("num", 5).unwrap(), 11); assert_eq!(params.get_int_def::<u32>("nonexistent", 17).unwrap(), 17); }
Notes
- It is recommended that application use
Params::get_param_def()
instead.
pub fn get_bool(&self, key: &str) -> Result<bool, Error>
[src]
Get a boolean value; return error if key wasn’t found.
pub fn get_bool_def(&self, key: &str, def: bool) -> Result<bool, Error>
[src]
Get a boolean value; return a default value if key wasn’t found.
pub fn get_strvec(&self, key: &str) -> Result<Vec<String>, Error>
[src]
Parse the value of a key as a comma-separated list of strings and return it. Only non-empty entries are returned.
Examples
use blather::Params; fn main() { let mut params = Params::new(); params.add_param("csv", "elena,chloe,drake"); let sv = params.get_strvec("csv").unwrap(); assert_eq!(sv, vec!["elena", "chloe", "drake"]); }
pub fn get_hashset(&self, key: &str) -> Result<HashSet<String>, Error>
[src]
Parse the value of a key as a comma-separated list of uniqie strings and return them in a HashSet. Only non-empty entries are returned.
Examples
use blather::Params; fn main() { let mut params = Params::new(); params.add_param("set", "elena,chloe"); let set = params.get_hashset("set").unwrap(); assert_eq!(set.len(), 2); assert_eq!(set.contains("elena"), true); assert_eq!(set.contains("chloe"), true); assert_eq!(set.contains("drake"), false); }
pub fn calc_buf_size(&self) -> usize
[src]
Calculate the size of the buffer in serialized form. Each entry will be a newline terminated utf-8 line. Last line will be a single newline character.
pub fn serialize(&self) -> Result<Vec<u8>, Error>
[src]
pub fn encoder_write(&self, buf: &mut BytesMut) -> Result<(), Error>
[src]
Write the Params to a buffer.
pub fn into_inner(self) -> HashMap<String, String>
[src]
Consume the Params buffer and return its internal HashMap.
Trait Implementations
impl Clone for Params
[src]
impl Debug for Params
[src]
impl Default for Params
[src]
impl Display for Params
[src]
impl Encoder<&'_ Params> for Codec
[src]
type Error = Error
The type of encoding errors. Read more
fn encode(&mut self, params: &Params, buf: &mut BytesMut) -> Result<(), Error>
[src]
impl From<HashMap<String, String, RandomState>> for Params
[src]
impl From<Params> for Telegram
[src]
Auto Trait Implementations
impl RefUnwindSafe for Params
impl Send for Params
impl Sync for Params
impl Unpin for Params
impl UnwindSafe for Params
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,