1 files changed, 122 insertions, 0 deletions
diff --git a/crates/rebel-resolve/src/args.rs b/crates/rebel-resolve/src/args.rs
new file mode 100644
index 0000000..805646a
--- /dev/null
+++ b/crates/rebel-resolve/src/args.rs
@@ -0,0 +1,122 @@
+use std::{
+	collections::{hash_map, HashMap},
+	hash,
+	rc::Rc,
+};
+
+use enum_kinds::EnumKind;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, PartialEq, Eq)]
+pub struct Platform {
+	#[serde(skip)]
+	pub short: String,
+	pub gnu_triplet: String,
+	pub karch: String,
+	pub prefix: String,
+}
+
+#[derive(Debug, Serialize, PartialEq, Eq)]
+pub struct PlatformRelation {
+	pub is_same: bool,
+	pub sysroot: String,
+	pub cross_compile: String,
+}
+
+#[derive(Clone, Debug, Serialize, PartialEq, Eq, EnumKind)]
+#[serde(untagged)]
+#[enum_kind(ArgType, derive(Deserialize), serde(rename_all = "snake_case"))]
+pub enum Arg {
+	String(Rc<String>),
+	Platform(Rc<Platform>),
+	PlatformRelation(Rc<PlatformRelation>),
+}
+
+impl From<&Arg> for Arg {
+	fn from(value: &Arg) -> Self {
+		value.clone()
+	}
+}
+
+impl From<String> for Arg {
+	fn from(value: String) -> Self {
+		Arg::String(Rc::new(value))
+	}
+}
+
+impl From<Platform> for Arg {
+	fn from(value: Platform) -> Self {
+		Arg::Platform(Rc::new(value))
+	}
+}
+
+impl From<PlatformRelation> for Arg {
+	fn from(value: PlatformRelation) -> Self {
+		Arg::PlatformRelation(Rc::new(value))
+	}
+}
+
+#[derive(Clone, Debug, Serialize, PartialEq, Eq, Default)]
+pub struct TaskArgs(HashMap<String, Arg>);
+
+impl TaskArgs {
+	pub fn contains_key(&self, key: &str) -> bool {
+		self.0.contains_key(key)
+	}
+
+	pub fn get(&self, key: &str) -> Option<&Arg> {
+		self.0.get(key)
+	}
+
+	pub fn set<T>(&mut self, key: &str, value: Option<T>)
+	where
+		T: Into<Arg>,
+	{
+		if let Some(v) = value {
+			self.0.insert(key.to_string(), v.into());
+		} else {
+			self.0.remove(key);
+		}
+	}
+
+	pub fn iter(&self) -> hash_map::Iter<String, Arg> {
+		self.into_iter()
+	}
+}
+
+impl FromIterator<(String, Arg)> for TaskArgs {
+	fn from_iter<T: IntoIterator<Item = (String, Arg)>>(iter: T) -> Self {
+		TaskArgs(HashMap::from_iter(iter))
+	}
+}
+
+impl<'a> IntoIterator for &'a TaskArgs {
+	type Item = (&'a String, &'a Arg);
+
+	type IntoIter = hash_map::Iter<'a, String, Arg>;
+
+	fn into_iter(self) -> Self::IntoIter {
+		self.0.iter()
+	}
+}
+
+#[allow(clippy::derived_hash_with_manual_eq)]
+impl hash::Hash for TaskArgs {
+	fn hash<H: hash::Hasher>(&self, _state: &mut H) {
+		// Don't do anything: Properly hashing the task args is likely to cost
+		// much more performance than the hash collisions caused by TaskRefs
+		// that only differ by the args
+	}
+}
+
+pub fn arg<A: Into<Arg>>(key: &str, value: A) -> (String, Arg) {
+	(key.to_string(), value.into())
+}
+
+#[derive(Clone, Debug, Deserialize, Default, PartialEq, Eq)]
+pub struct ArgMapping(pub HashMap<String, String>);
+
+#[allow(clippy::derived_hash_with_manual_eq)]
+impl hash::Hash for ArgMapping {
+	fn hash<H: hash::Hasher>(&self, _state: &mut H) {}
+}