Add ConstructCell with concrete Cell type, more tests

Author: ranfdev

glib-macros/tests/properties.rs

@@ -7,7 +7,7 @@ fn props() {
     mod foo {
         use glib::prelude::*;
         use glib::subclass::prelude::*;
-        use glib::ConstructRefCell;
+        use glib::{ConstructCell, ConstructRefCell};
         use glib_macros::Properties;
         use std::cell::Cell;
         use std::cell::RefCell;
@@ -92,6 +92,8 @@ fn props() {
                 #[property(get, set)]
                 cell: Cell<u8>,
                 #[property(get, set)]
+                construct_cell: ConstructCell<u8>,
+                #[property(get, set)]
                 construct_ref_cell: ConstructRefCell<u8>,
             }
 
@@ -111,6 +113,10 @@ fn props() {
                 fn property(&self, _obj: &Self::Type, _id: usize, _pspec: &ParamSpec) -> Value {
                     Self::derived_property(self, _obj, _id, _pspec).unwrap()
                 }
+                fn constructed(&self, _obj: &Self::Type) {
+                    self.construct_cell.replace(Some(1));
+                    self.construct_ref_cell.replace(Some(2));
+                }
             }
 
             #[glib::object_subclass]
@@ -227,6 +233,13 @@ fn props() {
         // member of struct field
         let author_nick = myfoo.author_nick();
         assert_eq!(author_nick, myfoo.property::<String>("author-nick"));
+
+        // construct_cell
+        let n = myfoo.construct_cell();
+        assert_eq!(n, myfoo.property::<u8>("construct-cell"));
+
+        let n = myfoo.construct_ref_cell();
+        assert_eq!(n, myfoo.property::<u8>("construct-ref-cell"));
     }
 
     // setters

glib/src/construct_cell.rs

@@ -4,6 +4,7 @@ use crate::{HasParamSpec, Property, PropertyGet, PropertySet, PropertySetNested}
 
 use once_cell::sync::OnceCell as SyncOnceCell;
 use once_cell::unsync::OnceCell;
+use std::cell::Cell;
 use std::cell::RefCell;
 use std::sync::Mutex;
 use std::sync::RwLock;
@@ -100,3 +101,47 @@ define_construct!(@with_uninit_type ConstructSyncOnceCell, SyncOnceCell, T,
         oc
     }
 );
+
+// Manual implementation because Cell often requires `Copy`, so `Debug` can't be derived,
+// `PropertyGet` and `PropertySet` can't be generated as with the other types...
+pub struct ConstructCell<T>(Cell<Option<T>>);
+impl<T> Default for ConstructCell<T> {
+    fn default() -> Self {
+        Self::new_empty()
+    }
+}
+impl<T: Property + HasParamSpec> Property for ConstructCell<T> {
+    type Value = T;
+}
+
+impl<T> std::ops::Deref for ConstructCell<T> {
+    type Target = Cell<Option<T>>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl<T> ConstructCell<T> {
+    pub fn new(value: T) -> Self {
+        Self(Cell::new(Some(value)))
+    }
+    pub fn new_empty() -> Self {
+        Self(Cell::default())
+    }
+}
+impl<T: Copy + std::fmt::Debug> std::fmt::Debug for ConstructCell<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ConstructCell").field("0", &self.0).finish()
+    }
+}
+impl<T: Copy> PropertySet for ConstructCell<T> {
+    type SetValue = T;
+    fn set(&self, v: T) {
+        PropertySet::set(&self.0, Some(v))
+    }
+}
+impl<T: Copy> PropertyGet for ConstructCell<T> {
+    type Value = T;
+    fn get<R, F: Fn(&Self::Value) -> R>(&self, f: F) -> R {
+        PropertyGet::get(&self.0, |v| f(v.as_ref().unwrap()))
+    }
+}