2024-02-25 18:49:26 +00:00
|
|
|
use std::{
|
2024-06-17 21:39:44 +00:00
|
|
|
collections::HashMap,
|
2024-06-22 10:36:59 +00:00
|
|
|
sync::{Arc, RwLock},
|
2024-02-25 18:49:26 +00:00
|
|
|
};
|
|
|
|
|
2024-03-06 23:15:25 +00:00
|
|
|
use crate::{
|
2024-03-25 04:16:55 +00:00
|
|
|
abstract_tree::Type,
|
2024-06-21 22:28:12 +00:00
|
|
|
error::{PoisonError, ValidationError},
|
2024-03-25 04:16:55 +00:00
|
|
|
identifier::Identifier,
|
2024-03-24 00:36:23 +00:00
|
|
|
Value,
|
2024-03-06 23:15:25 +00:00
|
|
|
};
|
2024-02-25 18:49:26 +00:00
|
|
|
|
2024-03-12 01:57:27 +00:00
|
|
|
#[derive(Clone, Debug)]
|
2024-06-22 10:36:59 +00:00
|
|
|
pub struct Context {
|
|
|
|
data: Arc<RwLock<ContextData>>,
|
2024-05-21 20:29:54 +00:00
|
|
|
is_clean: Arc<RwLock<bool>>,
|
2024-02-25 18:49:26 +00:00
|
|
|
}
|
|
|
|
|
2024-06-22 10:36:59 +00:00
|
|
|
#[derive(Clone, Debug)]
|
|
|
|
struct ContextData {
|
|
|
|
variables: HashMap<Identifier, (VariableData, UsageData)>,
|
|
|
|
parent: Option<Context>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Context {
|
|
|
|
pub fn new(parent: Option<Context>) -> Self {
|
|
|
|
Context {
|
|
|
|
data: Arc::new(RwLock::new(ContextData {
|
|
|
|
variables: HashMap::new(),
|
|
|
|
parent,
|
|
|
|
})),
|
2024-05-21 20:29:54 +00:00
|
|
|
is_clean: Arc::new(RwLock::new(true)),
|
2024-03-06 23:15:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-06-22 10:36:59 +00:00
|
|
|
pub fn create_child(&self) -> Context {
|
|
|
|
Context::new(Some(self.clone()))
|
2024-03-20 08:42:13 +00:00
|
|
|
}
|
|
|
|
|
2024-06-21 22:28:12 +00:00
|
|
|
pub fn contains(&self, identifier: &Identifier) -> Result<bool, PoisonError> {
|
2024-04-22 07:41:21 +00:00
|
|
|
log::trace!("Checking that {identifier} exists.");
|
|
|
|
|
2024-06-22 10:36:59 +00:00
|
|
|
let data = self.data.read()?;
|
|
|
|
|
|
|
|
if data.variables.contains_key(identifier) {
|
2024-05-21 20:29:54 +00:00
|
|
|
Ok(true)
|
2024-06-22 10:36:59 +00:00
|
|
|
} else if let Some(parent) = &data.parent {
|
2024-05-21 20:29:54 +00:00
|
|
|
parent.contains(identifier)
|
|
|
|
} else {
|
|
|
|
Ok(false)
|
|
|
|
}
|
2024-03-12 01:57:27 +00:00
|
|
|
}
|
|
|
|
|
2024-03-19 22:31:52 +00:00
|
|
|
pub fn get_type(&self, identifier: &Identifier) -> Result<Option<Type>, ValidationError> {
|
2024-06-22 10:36:59 +00:00
|
|
|
log::trace!("Getting {identifier}'s type.");
|
|
|
|
|
|
|
|
let data = self.data.read()?;
|
2024-04-22 05:51:34 +00:00
|
|
|
|
2024-06-22 10:36:59 +00:00
|
|
|
if let Some((data, _)) = data.variables.get(identifier) {
|
2024-06-18 22:54:17 +00:00
|
|
|
let r#type = match data {
|
2024-06-17 14:10:06 +00:00
|
|
|
VariableData::Type(r#type) => r#type.clone(),
|
|
|
|
VariableData::Value(value) => value.r#type(self)?,
|
2024-03-12 01:57:27 +00:00
|
|
|
};
|
|
|
|
|
2024-03-23 12:15:48 +00:00
|
|
|
Ok(Some(r#type.clone()))
|
2024-06-22 10:36:59 +00:00
|
|
|
} else if let Some(parent) = &data.parent {
|
2024-05-21 20:29:54 +00:00
|
|
|
parent.get_type(identifier)
|
2024-03-23 12:15:48 +00:00
|
|
|
} else {
|
|
|
|
Ok(None)
|
2024-03-18 12:15:30 +00:00
|
|
|
}
|
2024-03-06 23:15:25 +00:00
|
|
|
}
|
|
|
|
|
2024-06-21 22:28:12 +00:00
|
|
|
pub fn use_value(&self, identifier: &Identifier) -> Result<Option<Value>, PoisonError> {
|
2024-06-22 10:36:59 +00:00
|
|
|
log::trace!("Using {identifier}'s value.");
|
2024-04-22 05:51:34 +00:00
|
|
|
|
2024-06-22 10:36:59 +00:00
|
|
|
let data = self.data.read()?;
|
|
|
|
|
|
|
|
if let Some((VariableData::Value(value), usage_data)) = data.variables.get(identifier) {
|
2024-04-22 09:50:26 +00:00
|
|
|
usage_data.inner().write()?.actual += 1;
|
2024-05-21 20:29:54 +00:00
|
|
|
*self.is_clean.write()? = false;
|
2024-04-22 05:51:34 +00:00
|
|
|
|
2024-03-17 17:36:31 +00:00
|
|
|
Ok(Some(value.clone()))
|
2024-06-22 10:36:59 +00:00
|
|
|
} else if let Some(parent) = &data.parent {
|
2024-05-21 20:29:54 +00:00
|
|
|
parent.use_value(identifier)
|
2024-03-12 01:57:27 +00:00
|
|
|
} else {
|
2024-03-18 12:15:30 +00:00
|
|
|
Ok(None)
|
2024-02-25 18:49:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-06-21 22:28:12 +00:00
|
|
|
pub fn get_value(&self, identifier: &Identifier) -> Result<Option<Value>, PoisonError> {
|
2024-06-22 10:36:59 +00:00
|
|
|
log::trace!("Getting {identifier}'s value.");
|
2024-04-27 07:40:05 +00:00
|
|
|
|
2024-06-22 10:36:59 +00:00
|
|
|
let data = self.data.read()?;
|
2024-04-27 07:40:05 +00:00
|
|
|
|
2024-06-22 10:36:59 +00:00
|
|
|
if let Some((VariableData::Value(value), _)) = data.variables.get(identifier) {
|
|
|
|
Ok(Some(value.clone()))
|
|
|
|
} else if let Some(parent) = &data.parent {
|
|
|
|
parent.use_value(identifier)
|
2024-04-27 07:40:05 +00:00
|
|
|
} else {
|
|
|
|
Ok(None)
|
|
|
|
}
|
2024-04-22 11:56:03 +00:00
|
|
|
}
|
|
|
|
|
2024-06-21 22:28:12 +00:00
|
|
|
pub fn set_type(&self, identifier: Identifier, r#type: Type) -> Result<(), PoisonError> {
|
2024-04-22 07:41:21 +00:00
|
|
|
log::debug!("Setting {identifier} to type {}.", r#type);
|
2024-04-22 05:51:34 +00:00
|
|
|
|
2024-06-22 10:36:59 +00:00
|
|
|
self.data
|
2024-03-06 23:15:25 +00:00
|
|
|
.write()?
|
2024-06-22 10:36:59 +00:00
|
|
|
.variables
|
2024-06-17 14:10:06 +00:00
|
|
|
.insert(identifier, (VariableData::Type(r#type), UsageData::new()));
|
2024-02-25 18:49:26 +00:00
|
|
|
|
2024-03-06 23:15:25 +00:00
|
|
|
Ok(())
|
2024-02-25 18:49:26 +00:00
|
|
|
}
|
|
|
|
|
2024-06-22 03:37:25 +00:00
|
|
|
pub fn set_value(&self, identifier: Identifier, value: Value) -> Result<(), PoisonError> {
|
2024-04-22 07:41:21 +00:00
|
|
|
log::debug!("Setting {identifier} to value {value}.");
|
2024-04-22 05:51:34 +00:00
|
|
|
|
2024-06-22 10:36:59 +00:00
|
|
|
let mut data = self.data.write()?;
|
|
|
|
let usage_data = data
|
|
|
|
.variables
|
2024-04-22 07:41:21 +00:00
|
|
|
.remove(&identifier)
|
2024-06-22 10:36:59 +00:00
|
|
|
.map(|(_, usage_data)| usage_data)
|
|
|
|
.unwrap_or(UsageData::new());
|
2024-04-22 05:51:34 +00:00
|
|
|
|
2024-06-22 10:36:59 +00:00
|
|
|
data.variables
|
|
|
|
.insert(identifier, (VariableData::Value(value), usage_data));
|
2024-02-25 18:49:26 +00:00
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
2024-03-23 12:47:57 +00:00
|
|
|
|
2024-06-22 10:36:59 +00:00
|
|
|
pub fn add_expected_use(&self, identifier: &Identifier) -> Result<bool, PoisonError> {
|
|
|
|
let data = self.data.read()?;
|
|
|
|
|
|
|
|
if let Some((_, usage_data)) = data.variables.get(identifier) {
|
|
|
|
log::trace!("Adding expected use for variable {identifier}.");
|
|
|
|
|
|
|
|
usage_data.inner().write()?.expected += 1;
|
|
|
|
|
|
|
|
Ok(true)
|
|
|
|
} else if let Some(parent) = &data.parent {
|
|
|
|
parent.add_expected_use(identifier)
|
|
|
|
} else {
|
|
|
|
Ok(false)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-06-22 03:37:25 +00:00
|
|
|
pub fn clean(&self) -> Result<(), PoisonError> {
|
2024-05-21 20:29:54 +00:00
|
|
|
if *self.is_clean.read()? {
|
2024-04-22 11:56:03 +00:00
|
|
|
return Ok(());
|
|
|
|
}
|
|
|
|
|
2024-06-22 10:36:59 +00:00
|
|
|
self.data
|
2024-04-22 05:51:34 +00:00
|
|
|
.write()?
|
2024-06-22 10:36:59 +00:00
|
|
|
.variables
|
2024-06-22 17:55:43 +00:00
|
|
|
.retain(|_, (value_data, usage_data)| match value_data {
|
|
|
|
VariableData::Type(_) => true,
|
|
|
|
VariableData::Value(_) => {
|
2024-04-22 11:56:03 +00:00
|
|
|
let usage = usage_data.inner().read().unwrap();
|
2024-04-22 09:50:26 +00:00
|
|
|
|
2024-06-22 17:55:43 +00:00
|
|
|
usage.actual < usage.expected
|
2024-04-22 05:51:34 +00:00
|
|
|
}
|
2024-04-22 07:41:21 +00:00
|
|
|
});
|
2024-04-22 05:51:34 +00:00
|
|
|
|
2024-05-21 20:29:54 +00:00
|
|
|
*self.is_clean.write()? = true;
|
2024-04-22 11:56:03 +00:00
|
|
|
|
2024-04-22 05:51:34 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2024-06-21 22:28:12 +00:00
|
|
|
pub fn is_clean(&mut self) -> Result<bool, PoisonError> {
|
2024-06-22 10:36:59 +00:00
|
|
|
Ok(*self.is_clean.read()?)
|
2024-04-22 05:51:34 +00:00
|
|
|
}
|
2024-02-25 18:49:26 +00:00
|
|
|
}
|
2024-03-17 17:36:31 +00:00
|
|
|
|
2024-06-22 17:55:43 +00:00
|
|
|
impl Default for Context {
|
|
|
|
fn default() -> Self {
|
|
|
|
Context::new(None)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-17 17:36:31 +00:00
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
2024-06-17 14:10:06 +00:00
|
|
|
pub enum VariableData {
|
2024-03-17 17:36:31 +00:00
|
|
|
Type(Type),
|
|
|
|
Value(Value),
|
|
|
|
}
|
2024-04-22 05:51:34 +00:00
|
|
|
|
|
|
|
#[derive(Clone, Debug)]
|
2024-04-22 09:50:26 +00:00
|
|
|
pub struct UsageData(Arc<RwLock<UsageDataInner>>);
|
|
|
|
|
|
|
|
impl UsageData {
|
|
|
|
pub fn inner(&self) -> &Arc<RwLock<UsageDataInner>> {
|
|
|
|
&self.0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Clone, Debug)]
|
|
|
|
pub struct UsageDataInner {
|
2024-04-22 05:51:34 +00:00
|
|
|
pub actual: u32,
|
|
|
|
pub expected: u32,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl UsageData {
|
|
|
|
pub fn new() -> Self {
|
2024-04-22 09:50:26 +00:00
|
|
|
UsageData(Arc::new(RwLock::new(UsageDataInner {
|
2024-04-22 05:51:34 +00:00
|
|
|
actual: 0,
|
|
|
|
expected: 0,
|
2024-04-22 09:50:26 +00:00
|
|
|
})))
|
2024-04-22 05:51:34 +00:00
|
|
|
}
|
|
|
|
}
|