glib: split new/with_type for EnumClass/FlagsClass

Author: jf2048

glib-macros/src/variant_derive.rs

@@ -552,18 +552,15 @@ fn derive_variant_for_c_enum(
         ),
         EnumMode::Enum { repr: false } => (
             quote! {
-                let ty = <Self as #glib::StaticType>::static_type();
-                let enum_class = #glib::EnumClass::new(ty);
-                let enum_class = ::core::option::Option::unwrap(enum_class);
+                let enum_class = #glib::EnumClass::new::<Self>();
                 let value = <Self as #glib::translate::IntoGlib>::into_glib(*self);
                 let value = #glib::EnumClass::value(&enum_class, value);
                 let value = ::core::option::Option::unwrap(value);
                 let nick = #glib::EnumValue::nick(&value);
                 #glib::ToVariant::to_variant(nick)
             },
             quote! {
-                let ty = <Self as #glib::StaticType>::static_type();
-                let enum_class = #glib::EnumClass::new(ty)?;
+                let enum_class = #glib::EnumClass::new::<Self>();
                 let tag = #glib::Variant::str(&variant)?;
                 let value = #glib::EnumClass::value_by_nick(&enum_class, tag)?;
                 let value = #glib::EnumValue::value(&value);
@@ -581,16 +578,13 @@ fn derive_variant_for_c_enum(
         ),
         EnumMode::Flags { repr: false } => (
             quote! {
-                let ty = <Self as #glib::StaticType>::static_type();
-                let flags_class = #glib::FlagsClass::new(ty);
-                let flags_class = ::core::option::Option::unwrap(flags_class);
+                let flags_class = #glib::FlagsClass::new::<Self>();
                 let value = <Self as #glib::translate::IntoGlib>::into_glib(*self);
                 let s = #glib::FlagsClass::to_nick_string(&flags_class, value);
                 #glib::ToVariant::to_variant(&s)
             },
             quote! {
-                let ty = <Self as #glib::StaticType>::static_type();
-                let flags_class = #glib::FlagsClass::new(ty)?;
+                let flags_class = #glib::FlagsClass::new::<Self>();
                 let s = #glib::Variant::str(&variant)?;
                 let value = #glib::FlagsClass::from_nick_string(&flags_class, s).ok()?;
                 ::core::option::Option::Some(unsafe { #glib::translate::from_glib(value) })

glib-macros/tests/test.rs

@@ -120,7 +120,7 @@ fn derive_enum() {
     assert!(t.is_a(glib::Type::ENUM));
     assert_eq!(t.name(), "TestAnimalType");
 
-    let e = glib::EnumClass::new(t).expect("EnumClass::new failed");
+    let e = glib::EnumClass::with_type(t).expect("EnumClass::new failed");
     let v = e.value(0).expect("EnumClass::get_value(0) failed");
     assert_eq!(v.name(), "Goat");
     assert_eq!(v.nick(), "goat");
@@ -221,7 +221,7 @@ fn attr_flags() {
     assert!(t.is_a(glib::Type::FLAGS));
     assert_eq!(t.name(), "MyFlags");
 
-    let e = glib::FlagsClass::new(t).expect("FlagsClass::new failed");
+    let e = glib::FlagsClass::with_type(t).expect("FlagsClass::new failed");
     let v = e.value(1).expect("FlagsClass::get_value(1) failed");
     assert_eq!(v.name(), "Flag A");
     assert_eq!(v.nick(), "nick-a");

glib/src/enums.rs

@@ -5,7 +5,7 @@ use std::{cmp, ffi::CStr, fmt, ptr};
 use crate::{
     translate::*,
     value::{FromValue, ValueTypeChecker},
-    Type, Value,
+    HasParamSpec, ParamSpecEnum, ParamSpecFlags, StaticType, Type, Value,
 };
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
@@ -67,11 +67,18 @@ impl fmt::Debug for EnumClass {
 }
 
 impl EnumClass {
+    // rustdoc-stripper-ignore-next
+    /// Create a new `EnumClass` from a static type `T`.
+    ///
+    /// Panics if `T` is not representing an enum.
+    pub fn new<T: StaticType + HasParamSpec<ParamSpec = ParamSpecEnum>>() -> Self {
+        Self::with_type(T::static_type()).expect("invalid enum class")
+    }
     // rustdoc-stripper-ignore-next
     /// Create a new `EnumClass` from a `Type`.
     ///
     /// Returns `None` if `type_` is not representing an enum.
-    pub fn new(type_: Type) -> Option<Self> {
+    pub fn with_type(type_: Type) -> Option<Self> {
         unsafe {
             let is_enum: bool = from_glib(gobject_ffi::g_type_is_a(
                 type_.into_glib(),
@@ -255,7 +262,7 @@ impl EnumValue {
     /// Convert enum value from a `Value`.
     pub fn from_value(value: &Value) -> Option<(EnumClass, &EnumValue)> {
         unsafe {
-            let enum_class = EnumClass::new(value.type_())?;
+            let enum_class = EnumClass::with_type(value.type_())?;
             let v = enum_class.value(gobject_ffi::g_value_get_enum(value.to_glib_none().0))?;
             let v = &*(v as *const EnumValue);
             Some((enum_class, v))
@@ -341,11 +348,18 @@ impl fmt::Debug for FlagsClass {
 }
 
 impl FlagsClass {
+    // rustdoc-stripper-ignore-next
+    /// Create a new `FlagsClass` from a static type `T`.
+    ///
+    /// Panics if `T` is not representing an flags type.
+    pub fn new<T: StaticType + HasParamSpec<ParamSpec = ParamSpecFlags>>() -> Self {
+        Self::with_type(T::static_type()).expect("invalid flags class")
+    }
     // rustdoc-stripper-ignore-next
     /// Create a new `FlagsClass` from a `Type`
     ///
     /// Returns `None` if `type_` is not representing a flags type.
-    pub fn new(type_: Type) -> Option<Self> {
+    pub fn with_type(type_: Type) -> Option<Self> {
         unsafe {
             let is_flags: bool = from_glib(gobject_ffi::g_type_is_a(
                 type_.into_glib(),
@@ -771,7 +785,7 @@ impl FlagsValue {
     /// Convert flags values from a `Value`. This returns all flags that are set.
     pub fn from_value(value: &Value) -> Option<(FlagsClass, Vec<&FlagsValue>)> {
         unsafe {
-            let flags_class = FlagsClass::new(value.type_())?;
+            let flags_class = FlagsClass::with_type(value.type_())?;
             let mut res = Vec::new();
             let f = gobject_ffi::g_value_get_flags(value.to_glib_none().0);
             for v in flags_class.values() {
@@ -931,11 +945,10 @@ impl std::error::Error for InvalidFlagsError {}
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::StaticType;
 
     #[test]
     fn test_flags() {
-        let flags = FlagsClass::new(crate::BindingFlags::static_type()).unwrap();
+        let flags = FlagsClass::new::<crate::BindingFlags>();
         let values = flags.values();
         let def1 = values
             .iter()

glib/src/param_spec.rs

@@ -1027,7 +1027,7 @@ impl ParamSpecEnum {
 
             debug_assert!(!(*ptr).enum_class.is_null());
 
-            crate::EnumClass::new(from_glib((*(*ptr).enum_class).g_type_class.g_type))
+            crate::EnumClass::with_type(from_glib((*(*ptr).enum_class).g_type_class.g_type))
                 .expect("Invalid enum class")
         }
     }
@@ -1175,7 +1175,7 @@ impl ParamSpecFlags {
 
             debug_assert!(!(*ptr).flags_class.is_null());
 
-            crate::FlagsClass::new(from_glib((*(*ptr).flags_class).g_type_class.g_type))
+            crate::FlagsClass::with_type(from_glib((*(*ptr).flags_class).g_type_class.g_type))
                 .expect("Invalid flags class")
         }
     }