use super::Value;
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Dict {
entries: Vec<(Value, Value)>,
}
impl Dict {
pub fn new() -> Self {
Dict { entries: Vec::new() }
}
pub fn with_capacity(n: usize) -> Self {
Dict { entries: Vec::with_capacity(n) }
}
pub fn len(&self) -> usize {
self.entries.len()
}
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
pub fn insert(&mut self, k: Value, v: Value) {
if let Some(slot) = self.entries.iter_mut().find(|(key, _)| key == &k) {
slot.1 = v;
} else {
self.entries.push((k, v));
}
}
pub fn get(&self, key: &str) -> Option<&Value> {
self.entries.iter().find(|(k, _)| k.as_str() == Some(key)).map(|(_, v)| v)
}
pub fn get_mut(&mut self, key: &str) -> Option<&mut Value> {
self.entries.iter_mut().find(|(k, _)| k.as_str() == Some(key)).map(|(_, v)| v)
}
pub fn get_by(&self, key: &Value) -> Option<&Value> {
self.entries.iter().find(|(k, _)| k == key).map(|(_, v)| v)
}
pub fn remove(&mut self, key: &str) -> Option<Value> {
let idx = self.entries.iter().position(|(k, _)| k.as_str() == Some(key))?;
Some(self.entries.remove(idx).1)
}
pub fn contains_key(&self, key: &str) -> bool {
self.get(key).is_some()
}
pub fn iter(&self) -> std::slice::Iter<'_, (Value, Value)> {
self.entries.iter()
}
pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, (Value, Value)> {
self.entries.iter_mut()
}
pub fn keys(&self) -> Vec<String> {
self.entries.iter().filter_map(|(k, _)| k.as_str().map(|s| s.to_string())).collect()
}
pub fn values_mut(&mut self) -> impl Iterator<Item = &mut Value> {
self.entries.iter_mut().map(|(_, v)| v)
}
pub fn into_entries(self) -> Vec<(Value, Value)> {
self.entries
}
}
impl FromIterator<(Value, Value)> for Dict {
fn from_iter<T: IntoIterator<Item = (Value, Value)>>(it: T) -> Self {
Dict { entries: it.into_iter().collect() }
}
}
impl<'a> IntoIterator for &'a Dict {
type Item = &'a (Value, Value);
type IntoIter = std::slice::Iter<'a, (Value, Value)>;
fn into_iter(self) -> Self::IntoIter {
self.entries.iter()
}
}