Merge pull request #1044 from SeaDve/box-str-value

glib: impl StaticType, FromValue, ToValue, HasParamSpec for Box<str>

Author: ranfdev

glib-macros/tests/value_delegate_derive.rs

@@ -5,6 +5,10 @@ fn higher_level_types() {
     #[derive(Debug, glib::ValueDelegate)]
     pub struct MyVec(Vec<String>);
 
+    #[derive(Debug, glib::ValueDelegate)]
+    #[value_delegate(nullable)]
+    pub struct MyString(Box<str>);
+
     #[derive(Debug, glib::ValueDelegate)]
     #[value_delegate(from = Option<String>)]
     struct MyVecManualFrom(Vec<String>);
@@ -23,7 +27,6 @@ fn higher_level_types() {
     let vec = vec!["foo".to_string(), "bar".to_string()];
     let vec_value = vec.to_value();
     let my_vec_value = MyVec(vec.clone()).to_value();
-
     assert_eq!(MyVec::static_type(), Vec::<String>::static_type());
     assert_eq!(
         vec_value.get::<Vec<String>>().unwrap(),
@@ -38,10 +41,88 @@ fn higher_level_types() {
         unsafe { MyVec::from_value(&my_vec_value).0 }
     );
 
+    let string = "foo".to_string();
+    let string_value = string.to_value();
+    let my_string_value = MyString(string.into()).to_value();
+    assert_eq!(MyString::static_type(), Box::<str>::static_type());
+    assert_eq!(
+        string_value.get::<Box<str>>().unwrap(),
+        my_string_value.get::<Box<str>>().unwrap(),
+    );
+    assert_eq!(string_value.value_type(), my_string_value.value_type());
+    assert_eq!(unsafe { Box::<str>::from_value(&string_value) }, unsafe {
+        MyString::from_value(&string_value).0
+    });
+    assert_eq!(
+        unsafe { Box::<str>::from_value(&my_string_value) },
+        unsafe { MyString::from_value(&my_string_value).0 }
+    );
+
+    let string_some = Some("foo".to_string());
+    let string_some_value = string_some.to_value();
+    let string_none_value = None::<String>.to_value();
+    let my_string_some_value = MyString(string_some.unwrap().into()).to_value();
+    let my_string_none_value = None::<MyString>.to_value();
+    assert_eq!(
+        Option::<MyString>::static_type(),
+        Option::<Box<str>>::static_type()
+    );
+    assert_eq!(
+        string_some_value
+            .get::<Option<Box<str>>>()
+            .unwrap()
+            .unwrap(),
+        my_string_some_value
+            .get::<Option<Box<str>>>()
+            .unwrap()
+            .unwrap(),
+    );
+    assert_eq!(
+        string_none_value
+            .get::<Option<Box<str>>>()
+            .unwrap()
+            .is_none(),
+        my_string_none_value
+            .get::<Option<Box<str>>>()
+            .unwrap()
+            .is_none(),
+    );
+    assert_eq!(
+        string_some_value.value_type(),
+        my_string_some_value.value_type()
+    );
+    assert_eq!(
+        string_none_value.value_type(),
+        my_string_none_value.value_type()
+    );
+    assert_eq!(
+        unsafe { Option::<Box<str>>::from_value(&string_some_value).unwrap() },
+        unsafe {
+            Option::<MyString>::from_value(&string_some_value)
+                .unwrap()
+                .0
+        }
+    );
+    assert_eq!(
+        unsafe { Option::<Box<str>>::from_value(&string_none_value).is_none() },
+        unsafe { Option::<MyString>::from_value(&string_none_value).is_none() }
+    );
+    assert_eq!(
+        unsafe { Option::<Box<str>>::from_value(&my_string_some_value).unwrap() },
+        unsafe {
+            Option::<MyString>::from_value(&my_string_some_value)
+                .unwrap()
+                .0
+        }
+    );
+    assert_eq!(
+        unsafe { Option::<Box<str>>::from_value(&my_string_none_value).is_none() },
+        unsafe { Option::<MyString>::from_value(&my_string_none_value).is_none() }
+    );
+
     let opt = Some("foo".to_string());
     let opt_value = opt.to_value();
     let my_vec_manual_from_value = MyVecManualFrom::from(opt).to_value();
-
     assert_eq!(
         MyVecManualFrom::static_type(),
         Option::<String>::static_type()

glib/src/param_spec.rs

@@ -2115,6 +2115,15 @@ impl HasParamSpec for String {
         Self::ParamSpec::builder
     }
 }
+impl HasParamSpec for Box<str> {
+    type ParamSpec = ParamSpecString;
+    type SetValue = str;
+    type BuilderFn = fn(&str) -> ParamSpecStringBuilder;
+
+    fn param_spec_builder() -> Self::BuilderFn {
+        Self::ParamSpec::builder
+    }
+}
 impl HasParamSpec for crate::StrV {
     type ParamSpec = ParamSpecBoxed;
     type SetValue = Self;

glib/src/value.rs

@@ -904,6 +904,49 @@ impl ToValueOptional for String {
     }
 }
 
+impl ValueType for Box<str> {
+    type Type = String;
+}
+
+impl ValueTypeOptional for Box<str> {}
+
+unsafe impl<'a> FromValue<'a> for Box<str> {
+    type Checker = GenericValueTypeOrNoneChecker<Self>;
+
+    unsafe fn from_value(value: &'a Value) -> Self {
+        Box::<str>::from(<&str>::from_value(value))
+    }
+}
+
+impl StaticType for Box<str> {
+    fn static_type() -> Type {
+        String::static_type()
+    }
+}
+
+impl ToValue for Box<str> {
+    fn to_value(&self) -> Value {
+        <&str>::to_value(&self.as_ref())
+    }
+
+    fn value_type(&self) -> Type {
+        String::static_type()
+    }
+}
+
+impl From<Box<str>> for Value {
+    #[inline]
+    fn from(s: Box<str>) -> Self {
+        s.to_value()
+    }
+}
+
+impl ToValueOptional for Box<str> {
+    fn to_value_optional(s: Option<&Self>) -> Value {
+        <str>::to_value_optional(s.as_ref().map(|s| s.as_ref()))
+    }
+}
+
 impl ValueType for Vec<String> {
     type Type = Vec<String>;
 }