add Variant::{hash ; booleanize ; stringify}

+ test

Author: Astrale

godot-core/src/builtin/variant/mod.rs

@@ -156,15 +156,29 @@ impl Variant {
         }
     }
 
+    /// return a `GodotString` representing the variant
     #[allow(unused_mut)]
-    pub(crate) fn stringify(&self) -> GodotString {
+    pub fn stringify(&self) -> GodotString {
         let mut result = GodotString::new();
         unsafe {
             interface_fn!(variant_stringify)(self.var_sys(), result.string_sys());
         }
         result
     }
 
+    /// return the hash value of the variant.
+    ///
+    /// _Godot equivalent : `@GlobalScope.hash()`_
+    pub fn hash(&self) -> i64 {
+        unsafe { interface_fn!(variant_hash)(self.var_sys()) }
+    }
+
+    /// return a false only if the variant is `Variant::NIL`
+    /// or an empty `TypedArray` or `Dictionary`.
+    pub fn booleanize(&self) -> bool {
+        unsafe { interface_fn!(variant_booleanize)(self.var_sys()) != 0 }
+    }
+
     fn from_opaque(opaque: OpaqueVariant) -> Self {
         Self { opaque }
     }

itest/rust/src/variant_test.rs

@@ -6,7 +6,8 @@
 
 use crate::{expect_panic, itest};
 use godot::builtin::{
-    FromVariant, GodotString, NodePath, StringName, ToVariant, Variant, Vector2, Vector3,
+    dict, varray, FromVariant, GodotString, NodePath, StringName, ToVariant, Variant, Vector2,
+    Vector3,
 };
 use godot::engine::Node2D;
 use godot::obj::InstanceId;
@@ -334,6 +335,66 @@ fn variant_type_correct() {
     );
 }
 
+#[itest]
+fn variant_stringify_correct() {
+    assert_eq!("value".to_variant().stringify(), gstr("value"));
+    assert_eq!(Variant::nil().stringify(), gstr("<null>"));
+    assert_eq!(true.to_variant().stringify(), gstr("true"));
+    assert_eq!(30.to_variant().stringify(), gstr("30"));
+    assert_eq!(
+        godot::builtin::varray![1, "hello", false]
+            .to_variant()
+            .stringify(),
+        gstr("[1, \"hello\", false]")
+    );
+    assert_eq!(
+        dict! { "KEY": 50 }.to_variant().stringify(),
+        gstr("{ \"KEY\": 50 }")
+    );
+}
+
+#[itest]
+fn variant_booleanize_correct() {
+    assert!(gstr("string").to_variant().booleanize());
+    assert!(10.to_variant().booleanize());
+    assert!(varray![""].to_variant().booleanize());
+    assert!(dict! { "Key": 50 }.to_variant().booleanize());
+
+    assert!(!Dictionary::new().to_variant().booleanize());
+    assert!(!varray![].to_variant().booleanize());
+    assert!(!0.to_variant().booleanize());
+    assert!(!Variant::nil().booleanize());
+    assert!(!gstr("").to_variant().booleanize());
+}
+
+#[itest]
+fn variant_hash_correct() {
+    let hash_is_not_0 = [
+        dict! {}.to_variant(),
+        gstr("").to_variant(),
+        varray![].to_variant(),
+    ];
+    let self_equal = [
+        gstr("string").to_variant(),
+        varray![false, true, 4, "7"].to_variant(),
+        0.to_variant(),
+        dict! { 0 : dict!{ 0: 1 }}.to_variant(),
+    ];
+
+    for variant in hash_is_not_0 {
+        assert_ne!(variant.hash(), 0)
+    }
+    for variant in self_equal {
+        assert_eq!(variant.hash(), variant.hash())
+    }
+
+    assert_eq!(Variant::nil().hash(), 0);
+
+    // it's not guaranteed that different object will have different hash but it is
+    // extremely unlikely for a collision to happen.
+    assert_ne!(dict! { 0: dict!{ 0: 0 } }, dict! { 0: dict!{ 0: 1 } });
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
 fn roundtrip<T>(value: T)