From c3a282d04f1fd5c7cc4cf5ebb478129c2b1c42fa Mon Sep 17 00:00:00 2001
From: troido <troido@protonmail.com>
Date: Sun, 27 Sep 2020 11:02:43 +0200
Subject: removed "args" from the code

---
 src/assemblage.rs          | 20 ++++++++------------
 src/parameterexpression.rs |  1 -
 src/template.rs            | 12 +++---------
 3 files changed, 11 insertions(+), 22 deletions(-)

diff --git a/src/assemblage.rs b/src/assemblage.rs
index 82b25da..e4554eb 100644
--- a/src/assemblage.rs
+++ b/src/assemblage.rs
@@ -33,25 +33,22 @@ impl Assemblage {
 		Ok(())
 	}
 	
-	fn prepare_arguments(&self, args: &[Parameter], kwargs: &HashMap<String, Parameter>) -> AnyResult<HashMap<&str, Parameter>> {
+	fn prepare_arguments(&self, kwargs: &HashMap<String, Parameter>) -> AnyResult<HashMap<&str, Parameter>> {
 		let mut arguments: HashMap<&str, Parameter> = HashMap::new();
-		for (idx, (name, typ, def)) in self.arguments.iter().enumerate() {
-			let value: Option<Parameter> = {
+		for (name, typ, def) in self.arguments.iter() {
+			let param: Parameter= {
 				if let Some(val) = kwargs.get(name) {
-					Some(val.clone())
-				} else if let Some(val) = args.get(idx) {
-					Some(val.clone())
+					val.clone()
 				} else if let Some(val) = def {
-					Some(val.clone())
+					val.clone()
 				} else {
-					None
+					return Err(aerr!("argument <{:?}> has no value", (name, typ, def)))
 				}
 			};
-			let param = value.ok_or(aerr!("argument <{:?}> has no value", (idx, (name, typ, def))))?;
 			if param.paramtype() != *typ {
 				return Err(aerr!(
 					"argument has incorrect type: {:?}, {:?}, {:?}",
-					(idx, (name, typ, def)),
+					(name, typ, def),
 					param.paramtype(),
 					param
 				));
@@ -62,10 +59,9 @@ impl Assemblage {
 	}
 
 	pub fn instantiate(&self, template: &Template) -> AnyResult<Vec<ComponentWrapper>>{
-		let args = &template.args;
 		let kwargs = &template.kwargs;
 		let mut components: Vec<ComponentWrapper> = Vec::new();
-		let arguments = self.prepare_arguments(args, kwargs)?;
+		let arguments = self.prepare_arguments(kwargs)?;
 		for (comptype, compparams) in &self.components {
 			let mut compargs: HashMap<&str, Parameter> = HashMap::new();
 			for (name, param) in compparams {
diff --git a/src/parameterexpression.rs b/src/parameterexpression.rs
index 0ff9f1c..b92613a 100644
--- a/src/parameterexpression.rs
+++ b/src/parameterexpression.rs
@@ -50,7 +50,6 @@ impl ParameterExpression {
 			Self::Template{name, kwargs, save} => {
 				Some(Parameter::Template(Template{
 					name: name.clone(),
-					args: Vec::new(),
 					save: *save,
 					kwargs: kwargs
 						.iter()
diff --git a/src/template.rs b/src/template.rs
index 1475d42..1ef6fc1 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -17,8 +17,6 @@ enum TemplateSave {
 	Full{
 		#[serde(rename = "type")]
 		name: EntityType,
-		#[serde(default, skip_serializing_if = "Vec::is_empty")]
-		args: Vec<Parameter>,
 		#[serde(default, skip_serializing_if = "HashMap::is_empty")]
 		kwargs: HashMap<String, Parameter>,
 		#[serde(default, skip_serializing_if = "Option::is_none")]
@@ -32,7 +30,6 @@ enum TemplateSave {
 #[serde(from="TemplateSave", into="TemplateSave")]
 pub struct Template {
 	pub name: EntityType,
-	pub args: Vec<Parameter>,
 	pub kwargs: HashMap<String, Parameter>,
 	pub save: Option<bool>,
 	pub clan: Option<String>
@@ -42,19 +39,18 @@ pub struct Template {
 impl From<TemplateSave> for Template {
 	fn from(ts: TemplateSave) -> Self {
 		match ts {
-			TemplateSave::Name(name) => Self{name, args: Vec::new(), kwargs: HashMap::new(), save: None, clan: None},
-			TemplateSave::Full{name, args, kwargs, save, clan} => Self{name, args, kwargs, save, clan}
+			TemplateSave::Name(name) => Self{name, kwargs: HashMap::new(), save: None, clan: None},
+			TemplateSave::Full{name, kwargs, save, clan} => Self{name, kwargs, save, clan}
 		}
 	}
 }
 impl Into<TemplateSave> for Template {
 	fn into(self) -> TemplateSave {
-		if self.args.is_empty() && self.kwargs.is_empty() && self.save == None && self.clan == None {
+		if self.kwargs.is_empty() && self.save == None && self.clan == None {
 			return TemplateSave::Name(self.name);
 		}
 		TemplateSave::Full {
 			name: self.name,
-			args: self.args,
 			kwargs: self.kwargs,
 			save: self.save,
 			clan: self.clan
@@ -67,7 +63,6 @@ impl Template {
 	pub fn new(name: &str, kwargs: HashMap<String, Parameter>) -> Self {
 		Self {
 			name: EntityType(name.to_string()),
-			args: Vec::new(),
 			kwargs,
 			save: None,
 			clan: None
@@ -88,7 +83,6 @@ impl Template {
 	pub fn from_entity_type(typ: EntityType) -> Self {
 		Self {
 			name: typ,
-			args: Vec::new(),
 			kwargs: HashMap::new(),
 			save: None,
 			clan: None
-- 
cgit