renamed ComponentParameter to ParemeterExpression; List and Template variant for ParameterExpression

1 files changed, 204 insertions, 0 deletions

diff --git a/src/parameterexpression.rs b/src/parameterexpression.rs
new file mode 100644
index 0000000..7e2236e
--- /dev/null
+++ b/src/parameterexpression.rs
@@ -0,0 +1,204 @@
+
+use std::collections::HashMap;
+use rand::Rng;
+use serde_json::{Value, json};
+use crate::{
+	parameter::{Parameter, ParameterType},
+	Template,
+	template::{SaveOption, EntityType},
+	Result,
+	aerr,
+	PResult,
+	perr
+};
+
+const MAX_NESTING: usize = 5;
+
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum ParameterExpression {
+	Constant(Parameter),
+	List(Vec<ParameterExpression>),
+	#[allow(dead_code)] // rustc bug does not know that this variant is used: https://github.com/rust-lang/rust/issues/68408
+	Template{name: EntityType, kwargs: HashMap<String, ParameterExpression>, save: SaveOption},
+	Argument(String),
+	Random(Vec<ParameterExpression>),
+	Concat(Vec<ParameterExpression>),
+	If(Box<ParameterExpression>, Box<ParameterExpression>, Box<ParameterExpression>),
+	TemplateSelf,
+	TemplateName
+}
+
+impl ParameterExpression {
+
+	pub fn evaluate(&self, arguments: &HashMap<&str, Parameter>, template: &Template) -> Option<Parameter> {
+		self.evaluate_(arguments, template, 0)
+	}
+	
+	fn evaluate_(&self, arguments: &HashMap<&str, Parameter>, template: &Template, nesting: usize) -> Option<Parameter> {
+		if nesting > MAX_NESTING {
+			return None;
+		}
+		match self {
+			Self::Constant(val) => {
+				Some(val.clone())
+			}
+			Self::List(values) => {
+				Some(Parameter::List(values.iter().map(|v| v.evaluate_(arguments, template, nesting+1)).collect::<Option<Vec<Parameter>>>()?))
+			}
+			Self::Template{name, kwargs, save} => {
+				Some(Parameter::Template(Template{
+					name: name.clone(),
+					args: Vec::new(),
+					save: *save,
+					kwargs: kwargs
+						.iter()
+						.map(
+							|(k, v)|
+							Some((k.clone(), v.evaluate_(arguments, template, nesting+1)?)))
+						.collect::<Option<HashMap<String, Parameter>>>()?
+				}))
+			}
+			Self::Argument(argname) => {
+				Some(arguments.get(argname.as_str())?.clone())
+			}
+			Self::Random(options) => {
+				let r = rand::thread_rng().gen_range(0, options.len());
+				options[r].evaluate_(arguments, template, nesting + 1)
+			}
+			Self::Concat(options) => {
+				let mut string = String::new();
+				for option in options {
+					if let Parameter::String(s) = option.evaluate_(arguments, template, nesting+1)? {
+						string.push_str(&s);
+					} else {
+						return None;
+					}
+				}
+				Some(Parameter::String(string))
+			}
+			Self::If(condition, thenval, elseval) => {
+				if let Parameter::Bool(b) = condition.evaluate_(arguments, template, nesting+1)? {
+					if b {
+						thenval.evaluate_(arguments, template, nesting+1)
+					} else {
+						elseval.evaluate_(arguments, template, nesting+1)
+					}
+				} else {
+					None
+				}
+			}
+			Self::TemplateSelf => Some(Parameter::Template(template.clone())),
+			Self::TemplateName => Some(Parameter::String(template.name.0.clone())),
+			
+		}
+	}
+	
+	pub fn from_json(value: &Value) -> PResult<Self> {
+		if !value.is_array() {
+			return Ok(Self::Constant(Parameter::guess_from_json(value)?));
+		}
+		let paramvalue = value.get(1).ok_or(perr!("index 1 not in component parameter"))?;
+		let typename = value.get(0).ok_or(perr!("index 0 not in component parameter"))?.as_str().ok_or(perr!("compparam type not a string"))?;
+		match typename {
+			"string" | "int" | "float" | "bool" | "pos" | "interaction" => {
+				let paramtype = ParameterType::from_str(typename).expect(&format!("unknown parameter type {:?}", typename));
+				Ok(Self::Constant(Parameter::from_typed_json(paramtype, paramvalue)?))
+			}
+			"list" => {
+				let values = paramvalue.as_array().ok_or(perr!("random argument not an array"))?;
+				let mut entries = Vec::new();
+				for entry in values {
+					entries.push(Self::from_json(entry)?)
+				}
+				Ok(Self::List(entries))
+			}
+			"template" => {
+				match paramvalue {
+					Value::String(s) => Ok(Self::Template{
+						name: EntityType(s.clone()),
+						kwargs: HashMap::new(),
+						save: SaveOption::Default
+					}),
+					Value::Object(o) => {
+						let name = EntityType(o.get("type").ok_or(perr!("template doesn't have 'type'"))?.as_str().ok_or(perr!("template type not a string"))?.to_string());
+						let mut kwargs = HashMap::new();
+						for (key, arg) in o.get("kwargs").unwrap_or(&json!({})).as_object().ok_or(perr!("template kwargs not a json object"))? {
+							kwargs.insert(key.to_string(), Self::from_json(arg)?);
+						}
+						let save = match o.get("save") {
+							Some(Value::Bool(b)) if *b => SaveOption::Always,
+							Some(Value::Bool(_b)) => SaveOption::False,
+							None => SaveOption::Default,
+							_ => {return Err(perr!("save not a bool"))}
+						};
+						Ok(Self::Template{name, kwargs, save})
+					}
+					_ => return Err(perr!("invalid template {:?}", paramvalue))
+				}
+			}
+			"A" | "arg" => {
+				let argname = paramvalue.as_str().ok_or(perr!("argument parameter not a string"))?.to_string();
+				Ok(Self::Argument(argname))
+			}
+			"random" => {
+				let optionvalues = paramvalue.as_array().ok_or(perr!("random argument not an array"))?;
+				let mut options = Vec::new();
+				for option in optionvalues {
+					options.push(Self::from_json(option)?)
+				}
+				Ok(Self::Random(options))
+			}
+			"concat" => {
+				let values = paramvalue.as_array().ok_or(perr!("concat argument not an array"))?;
+				let mut options = Vec::new();
+				for option in values {
+					options.push(Self::from_json(option)?)
+				}
+				Ok(Self::Concat(options))
+			}
+			"if" => {
+				Ok(Self::If(
+					Box::new(Self::from_json(paramvalue.get(0).ok_or(perr!("if does not have condition"))?)?),
+					Box::new(Self::from_json(paramvalue.get(1).ok_or(perr!("if does not have then value"))?)?),
+					Box::new(Self::from_json(paramvalue.get(2).ok_or(perr!("if does not have else value"))?)?)
+				))
+			}
+			"self" => Ok(Self::TemplateSelf),
+			"name" => Ok(Self::TemplateName),
+			_ => Err(perr!("unknown compparam type '{}'", typename))
+		}
+	}
+	
+	#[allow(dead_code)]
+	pub fn get_type(&self, arguments: &[(String, ParameterType, Option<Parameter>)]) -> Result<ParameterType>{
+		Ok(match self {
+			Self::Constant(param) => param.paramtype(),
+			Self::List(_) => ParameterType::List,
+			Self::Template{name: _, kwargs: _, save: _} => ParameterType::Template,
+			Self::Argument(argname) => arguments.iter().find(|(n, _t, _d)| n == argname).ok_or(aerr!("unknown argument name {} in {:?}", argname, arguments))?.1,
+			Self::Random(options) => {
+				let typ: ParameterType = options.get(0).ok_or(aerr!("random has no options"))?.get_type(arguments)?;
+				for param in options {
+					if param.get_type(arguments)? != typ {
+						return Err(aerr!("inconsistent parameter types in random"));
+					}
+				}
+				typ
+			},
+			Self::If(condition, thenval, elseval) => {
+				if condition.get_type(arguments)? != ParameterType::Bool {
+					return Err(aerr!("if condition is not a bool"));
+				}
+				let typ: ParameterType = thenval.get_type(arguments)?;
+				if elseval.get_type(arguments)? != typ {
+					return Err(aerr!("inconsistent parameter types in if"));
+				}
+				typ
+			},
+			Self::Concat(_s) => ParameterType::String,
+			Self::TemplateSelf => ParameterType::Template,
+			Self::TemplateName => ParameterType::String
+		})
+	}
+}