change Variant serde (de|)serialization

Author: zoedberg

rust/src/util.rs

@@ -23,6 +23,7 @@ use std::cmp::Ordering;
 use std::fmt::{self, Display, Formatter};
 use std::hash::{Hash, Hasher};
 use std::io;
+use std::str::FromStr;
 
 use crate::{ReadStruct, VariantName, WriteStruct, STRICT_TYPES_LIB};
 
@@ -84,13 +85,43 @@ impl Display for Sizing {
 }
 
 #[derive(Clone, Eq, Debug)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "serde_crate"))]
 pub struct Variant {
     pub name: VariantName,
     pub tag: u8,
 }
 impl_strict_struct!(Variant, STRICT_TYPES_LIB; name, tag);
 
+#[cfg(feature = "serde")]
+mod _serde {
+    use serde_crate::{Deserialize, Deserializer, Serialize, Serializer};
+
+    use super::*;
+
+    impl Serialize for Variant {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where S: Serializer {
+            if serializer.is_human_readable() {
+                serializer.serialize_str(&self.to_string())
+            } else {
+                (&self.name, self.tag).serialize(serializer)
+            }
+        }
+    }
+
+    impl<'de> Deserialize<'de> for Variant {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where D: Deserializer<'de> {
+            if deserializer.is_human_readable() {
+                let s = String::deserialize(deserializer)?;
+                Variant::from_str(&s).map_err(serde::de::Error::custom)
+            } else {
+                let (name, tag): (VariantName, u8) = Deserialize::deserialize(deserializer)?;
+                Ok(Variant { name, tag })
+            }
+        }
+    }
+}
+
 impl Variant {
     pub fn named(tag: u8, name: VariantName) -> Variant { Variant { name, tag } }
 
@@ -134,7 +165,22 @@ impl Ord for Variant {
 
 impl Display for Variant {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.name)?;
+        write!(f, "{}:{}", self.name, self.tag)?;
         Ok(())
     }
 }
+
+impl FromStr for Variant {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let parts: Vec<&str> = s.split(':').collect();
+        if parts.len() != 2 {
+            return Err(format!("Invalid variant format: '{}'. Expected 'name:tag'", s));
+        }
+        let name =
+            VariantName::from_str(parts[0]).map_err(|e| format!("Invalid variant name: {}", e))?;
+        let tag = parts[1].parse::<u8>().map_err(|e| format!("Invalid variant tag: {}", e))?;
+        Ok(Variant { name, tag })
+    }
+}