the start of Greatness.

ipjs/src/utils/mod.rs

@@ -0,0 +1 @@
+pub mod serialize;

ipjs/src/utils/serialize/mac.rs

@@ -0,0 +1,44 @@
+    use macaddr::MacAddr;
+    use serde::{self, Deserialize, Deserializer, de::Error as DeError};
+    use serde::{Serialize, Serializer, de};
+
+    pub fn serialize_macs<S>(macs: &[MacAddr], serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let strings: Vec<String> = macs.iter().map(|m| m.to_string()).collect();
+        serde::Serialize::serialize(&strings, serializer)
+    }
+
+    /// Serialize a MacAddr as a string
+    pub fn serialize_mac<S>(mac: &MacAddr, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&mac.to_string())
+    }
+
+    /// Deserialize a MacAddr from a string
+    pub fn deserialize_mac<'de, D>(deserializer: D) -> Result<MacAddr, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = <String as serde::Deserialize>::deserialize(deserializer)?;
+        s.parse::<MacAddr>().map_err(DeError::custom)
+    }
+
+    /// serialize an [`Option<MacAddr>`]
+    pub fn ser_opm<S: Serializer>(bro: &Option<MacAddr>, ser: S) -> Result<S::Ok, S::Error> {
+        Option::<String>::serialize(&bro.as_ref().map(ToString::to_string), ser)
+    }
+
+    /// deserialize an [`Option<MacAddr>`]
+    pub fn des_opm<'de, D>(des: D) -> Result<Option<MacAddr>, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        Option::<&str>::deserialize(des)?
+            .map(str::parse)
+            .transpose()
+            .map_err(de::Error::custom)
+    }

ipjs/src/utils/serialize/mod.rs

@@ -0,0 +1,2 @@
+pub mod mac;
+pub mod vec;

ipjs/src/utils/serialize/vec.rs

@@ -0,0 +1,37 @@
+use serde::Deserialize;
+use serde::de;
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum OneOrMany<T> {
+    One(T),
+    Many(Vec<T>),
+}
+
+pub fn vec_from_strs<'de, D, T>(des: D) -> Result<Vec<T>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+    T: std::str::FromStr,
+    T::Err: std::fmt::Display,
+{
+    let raw: OneOrMany<String> = OneOrMany::<String>::deserialize(des)?;
+    let mut out = Vec::new();
+    match raw {
+        OneOrMany::One(s) => {
+            let t = s.trim();
+            if !t.is_empty() {
+                out.push(t.parse().map_err(de::Error::custom)?);
+            }
+        }
+        OneOrMany::Many(vs) => {
+            for s in vs {
+                let t = s.trim();
+                if t.is_empty() {
+                    continue;
+                }
+                out.push(t.parse().map_err(de::Error::custom)?);
+            }
+        }
+    }
+    Ok(out)
+}