use serde::{ser::SerializeMap, Deserialize, Deserializer, Serialize}; use std::{ cmp::Ordering, collections::BTreeMap, fmt::{self, Display, Formatter}, sync::{Arc, RwLock, RwLockReadGuard}, }; use crate::{value::Value, Result, Type}; /// A collection dust variables comprised of key-value pairs. /// /// The inner value is a BTreeMap in order to allow VariableMap instances to be sorted and compared /// to one another. #[derive(Clone, Debug)] pub struct Map { variables: Arc>>, } impl Map { /// Creates a new instace. pub fn new() -> Self { Map { variables: Arc::new(RwLock::new(BTreeMap::new())), } } pub fn clone_from(other: &Self) -> Result { let mut new_map = BTreeMap::new(); for (key, (value, r#type)) in other.variables()?.iter() { new_map.insert(key.clone(), (value.clone(), r#type.clone())); } Ok(Map { variables: Arc::new(RwLock::new(new_map)), }) } pub fn variables(&self) -> Result>> { Ok(self.variables.read()?) } pub fn set( &self, key: String, value: Value, r#type: Option, ) -> Result> { let value_type = r#type.unwrap_or(value.r#type()); let previous = self .variables .write()? .insert(key, (value, value_type.clone())); Ok(previous) } pub fn unset_all(&self) -> Result<()> { for (_key, (value, r#_type)) in self.variables.write()?.iter_mut() { *value = Value::none(); } Ok(()) } pub fn clear(&self) -> Result<()> { self.variables.write()?.clear(); Ok(()) } } impl Default for Map { fn default() -> Self { Self::new() } } impl Eq for Map {} impl PartialEq for Map { fn eq(&self, other: &Self) -> bool { let left = self.variables.read().unwrap().clone().into_iter(); let right = other.variables.read().unwrap().clone().into_iter(); left.eq(right) } } impl Ord for Map { fn cmp(&self, other: &Self) -> Ordering { let left = self.variables.read().unwrap().clone().into_iter(); let right = other.variables.read().unwrap().clone().into_iter(); left.cmp(right) } } impl PartialOrd for Map { fn partial_cmp(&self, other: &Self) -> Option { Some(self.cmp(other)) } } impl Display for Map { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { writeln!(f, "{{")?; let variables = self.variables.read().unwrap().clone().into_iter(); for (key, (value, _)) in variables { writeln!(f, " {key} = {value}")?; } write!(f, "}}") } } impl Serialize for Map { fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { let variables = self.variables.read().unwrap(); let mut map = serializer.serialize_map(Some(variables.len()))?; for (key, (value, _type)) in variables.iter() { map.serialize_entry(key, value)?; } map.end() } } impl<'de> Deserialize<'de> for Map { fn deserialize(_deserializer: D) -> std::result::Result where D: Deserializer<'de>, { todo!() } }