Implement serde traits for Variant types

Fix Variant serialization

Author: Waridley

gdnative-core/Cargo.toml

@@ -24,6 +24,7 @@ glam = "0.15.1"
 indexmap = "1.6.0"
 ahash = "0.7.0"
 once_cell = "1.7.2"
+serde = { version = "1", default_features = false, features = ["derive"], optional = true }
 
 gdnative-impl-proc-macros = { path = "../impl/proc_macros", version = "=0.9.3" }
 

gdnative-core/src/core_types/color.rs

@@ -6,6 +6,7 @@ use crate::core_types::GodotString;
 /// RGBA color with 32 bits floating point components.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Color {
     pub r: f32,
     pub g: f32,

gdnative-core/src/core_types/dictionary.rs

@@ -544,6 +544,82 @@ where
     }
 }
 
+#[cfg(feature = "serde")]
+pub(super) mod serde {
+    use super::*;
+    use ::serde::{
+        de::{MapAccess, Visitor},
+        ser::SerializeMap,
+        Deserialize, Deserializer, Serialize, Serializer,
+    };
+    use std::fmt::Formatter;
+
+    impl Serialize for Dictionary {
+        #[inline]
+        fn serialize<S>(&self, ser: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
+        where
+            S: Serializer,
+        {
+            let mut ser = ser.serialize_map(Some(self.len() as usize))?;
+            for (key, value) in self.iter() {
+                ser.serialize_entry(&key, &value)?
+            }
+            ser.end()
+        }
+    }
+
+    pub(in super::super) struct DictionaryVisitor;
+
+    impl<'de> Visitor<'de> for DictionaryVisitor {
+        type Value = Dictionary<Unique>;
+
+        fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+            formatter.write_str("a Dictionary")
+        }
+
+        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, <A as MapAccess<'de>>::Error>
+        where
+            A: MapAccess<'de>,
+        {
+            let dict = Dictionary::new();
+            while let Some((key, value)) = map.next_entry::<Variant, Variant>()? {
+                dict.insert(key, value)
+            }
+            Ok(dict)
+        }
+    }
+
+    impl<'de> Deserialize<'de> for Dictionary<Unique> {
+        #[inline]
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            deserializer.deserialize_map(DictionaryVisitor)
+        }
+    }
+
+    impl<'de> Deserialize<'de> for Dictionary<Shared> {
+        #[inline]
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            Dictionary::<Unique>::deserialize(deserializer).map(Dictionary::into_shared)
+        }
+    }
+
+    impl<'de> Deserialize<'de> for Dictionary<ThreadLocal> {
+        #[inline]
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            Dictionary::<Unique>::deserialize(deserializer).map(Dictionary::into_thread_local)
+        }
+    }
+}
+
 godot_test!(test_dictionary {
     use std::collections::HashSet;
 

gdnative-core/src/core_types/error.rs

@@ -2,6 +2,7 @@ use crate::sys;
 
 /// Error codes used in various Godot APIs.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[repr(u32)]
 pub enum GodotError {
     Failed = sys::godot_error_GODOT_FAILED as u32,

gdnative-core/src/core_types/geom/aabb.rs

@@ -3,6 +3,7 @@ use crate::core_types::Vector3;
 /// Axis-aligned bounding box.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Aabb {
     pub position: Vector3,
     pub size: Vector3,

gdnative-core/src/core_types/geom/basis.rs

@@ -4,6 +4,7 @@ use core::ops::Mul;
 /// A 3x3 matrix.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Basis {
     pub elements: [Vector3; 3],
 }

gdnative-core/src/core_types/geom/plane.rs

@@ -3,6 +3,7 @@ use crate::core_types::{IsEqualApprox, Vector3};
 /// Plane in hessian form.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Plane {
     pub normal: Vector3,
     pub d: f32,

gdnative-core/src/core_types/geom/transform.rs

@@ -3,6 +3,7 @@ use crate::core_types::{Basis, Vector3};
 /// 3D Transformation (3x4 matrix) Using basis + origin representation.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Transform {
     /// The basis is a matrix containing 3 Vector3 as its columns: X axis, Y axis, and Z axis.
     /// These vectors can be interpreted as the basis vectors of local coordinate system

gdnative-core/src/core_types/mod.rs

@@ -43,7 +43,7 @@ pub use rid::*;
 pub use string::*;
 pub use string_array::*;
 pub use transform2d::*;
-pub use typed_array::TypedArray;
+pub use typed_array::{Element, TypedArray};
 pub use variant::*;
 pub use variant_array::*;
 pub use vector2::*;

gdnative-core/src/core_types/node_path.rs

@@ -176,3 +176,67 @@ impl fmt::Debug for NodePath {
         write!(f, "NodePath({})", self.to_string())
     }
 }
+
+#[cfg(feature = "serde")]
+mod serde {
+    use super::*;
+    use ::serde::{
+        de::{Error, Visitor},
+        Deserialize, Deserializer, Serialize, Serializer,
+    };
+    use std::fmt::Formatter;
+
+    impl Serialize for NodePath {
+        #[inline]
+        fn serialize<S>(&self, ser: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
+        where
+            S: Serializer,
+        {
+            ser.serialize_newtype_struct("NodePath", &*self.to_string())
+        }
+    }
+
+    impl<'de> Deserialize<'de> for NodePath {
+        #[inline]
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            struct NodePathVisitor;
+
+            impl<'de> Visitor<'de> for NodePathVisitor {
+                type Value = NodePath;
+
+                fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+                    formatter.write_str("a NodePath")
+                }
+
+                fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+                where
+                    E: Error,
+                {
+                    Ok(NodePath::from_str(s))
+                }
+
+                fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
+                where
+                    E: Error,
+                {
+                    Ok(NodePath::from_str(&*s))
+                }
+
+                fn visit_newtype_struct<D>(
+                    self,
+                    deserializer: D,
+                ) -> Result<Self::Value, <D as Deserializer<'de>>::Error>
+                where
+                    D: Deserializer<'de>,
+                {
+                    deserializer.deserialize_str(self)
+                }
+            }
+
+            deserializer.deserialize_newtype_struct("NodePath", NodePathVisitor)
+        }
+    }
+}