Add is method to fundamental types

Fixes #860

Author: bilelmoussaoui

gdk4/src/event.rs

@@ -7,9 +7,13 @@ use std::fmt;
 use std::mem;
 
 impl Event {
+    pub fn is<T: EventKind>(&self) -> bool {
+        T::event_types().contains(&self.event_type())
+    }
+
     pub fn downcast<T: EventKind>(self) -> Result<T, Event> {
         unsafe {
-            if T::event_types().contains(&self.event_type()) {
+            if self.is::<T>() {
                 Ok(from_glib_full(self.to_glib_full()))
             } else {
                 Err(self)
@@ -19,7 +23,7 @@ impl Event {
 
     pub fn downcast_ref<T: EventKind>(&self) -> Option<&T> {
         unsafe {
-            if T::event_types().contains(&self.event_type()) {
+            if self.is::<T>() {
                 Some(&*(self as *const Event as *const T))
             } else {
                 None

gsk4/src/render_node.rs

@@ -5,6 +5,10 @@ use glib::translate::*;
 use glib::StaticType;
 
 impl RenderNode {
+    pub fn is<T: IsRenderNode>(&self) -> bool {
+        T::NODE_TYPE == self.node_type()
+    }
+
     #[doc(alias = "gsk_render_node_deserialize")]
     pub fn deserialize(bytes: &glib::Bytes) -> Option<Self> {
         assert_initialized_main_thread!();
@@ -51,7 +55,7 @@ impl RenderNode {
 
     pub fn downcast<T: IsRenderNode>(self) -> Result<T, Self> {
         unsafe {
-            if self.node_type() == T::NODE_TYPE {
+            if self.is::<T>() {
                 Ok(from_glib_full(self.to_glib_full()))
             } else {
                 Err(self)
@@ -61,7 +65,7 @@ impl RenderNode {
 
     pub fn downcast_ref<T: IsRenderNode>(&self) -> Option<&T> {
         unsafe {
-            if self.node_type() == T::NODE_TYPE {
+            if self.is::<T>() {
                 Some(&*(self as *const RenderNode as *const T))
             } else {
                 None

gtk4/src/constant_expression.rs

@@ -57,5 +57,7 @@ mod tests {
         let expr2 = ConstantExpression::for_value(&"hello".to_value());
         assert_eq!(expr2.value().get::<String>().unwrap(), "hello");
         assert_eq!(expr2.value_as::<String>(), "hello");
+
+        assert!(expr1.is::<ConstantExpression>());
     }
 }

gtk4/src/expression.rs

@@ -23,9 +23,13 @@ pub unsafe trait IsExpression:
 }
 
 impl Expression {
+    pub fn is<E: IsExpression>(&self) -> bool {
+        self.type_().is_a(E::static_type())
+    }
+
     pub fn downcast<E: IsExpression>(self) -> Result<E, Expression> {
         unsafe {
-            if self.type_() == E::static_type() {
+            if self.is::<E>() {
                 Ok(from_glib_full(self.to_glib_full()))
             } else {
                 Err(self)
@@ -35,7 +39,7 @@ impl Expression {
 
     pub fn downcast_ref<E: IsExpression>(&self) -> Option<&E> {
         unsafe {
-            if self.type_() == E::static_type() {
+            if self.is::<E>() {
                 Some(&*(self as *const Expression as *const E))
             } else {
                 None

gtk4/src/object_expression.rs

@@ -25,5 +25,6 @@ mod tests {
         let obj = crate::IconTheme::new();
         let expr = ObjectExpression::new(&obj);
         assert_eq!(expr.object().unwrap(), obj);
+        assert!(expr.is::<ObjectExpression>());
     }
 }

gtk4/src/property_expression.rs

@@ -24,10 +24,11 @@ mod tests {
 
     #[test]
     fn test_property_expression() {
-        let _prop_expr = PropertyExpression::new(
+        let prop_expr = PropertyExpression::new(
             crate::StringObject::static_type(),
             crate::Expression::NONE,
             "string",
         );
+        assert!(prop_expr.is::<PropertyExpression>());
     }
 }