ThreadGuard: Implement ToValue, Fromvalue and Default traits

This will also allow ThreadGuard to be used with the new property
macro.

Author: alatiera

glib-macros/tests/properties.rs

@@ -2,6 +2,7 @@
 
 use glib::prelude::*;
 use glib::ParamFlags;
+use glib::thread_guard::ThreadGuard;
 
 #[cfg(test)]
 mod base {
@@ -87,6 +88,7 @@ mod foo {
     }
 
     pub mod imp {
+        use glib::thread_guard::ThreadGuard;
         use glib::{ParamSpec, Value};
         use std::rc::Rc;
 
@@ -145,6 +147,8 @@ mod foo {
             cell: Cell<u8>,
             #[property(get = Self::overridden, override_class = Base)]
             overridden: PhantomData<u32>,
+            #[property(name = "thread-guard", get, set, default = "guarded")]
+            thread_guard: RefCell<ThreadGuard<String>>,
         }
 
         impl ObjectImpl for Foo {
@@ -195,6 +199,15 @@ fn props() {
     let bar: String = myfoo.property("bar");
     assert_eq!(bar, "".to_string());
 
+    // Set the thread guard
+    myfoo.set_property("thread-guard", "foobar".to_value());
+    // And grab directly the string from the guard after
+    let bar: String = myfoo.property("thread-guard");
+    assert_eq!(bar, "foobar".to_string());
+    // Read it as a thread guard
+    let bar = myfoo.property::<ThreadGuard<String>>("thread-guard");
+    assert_eq!(bar.get_ref(), "foobar");
+
     // Set bar
     myfoo.set_property("bar", "epic".to_value());
     let bar: String = myfoo.property("bar");

glib/src/property.rs

@@ -10,6 +10,7 @@ use std::sync::Mutex;
 use std::sync::RwLock;
 
 use crate::HasParamSpec;
+use crate::thread_guard::ThreadGuard;
 
 // rustdoc-stripper-ignore-next
 /// A type that can be used as a property. It covers every type which have an associated `ParamSpec`
@@ -37,6 +38,9 @@ impl<T: Property> Property for Mutex<T> {
 impl<T: Property> Property for RwLock<T> {
     type Value = T::Value;
 }
+impl<T: Property> Property for ThreadGuard<T> {
+    type Value = T::Value;
+}
 impl<T: Property> Property for once_cell::sync::OnceCell<T> {
     type Value = T::Value;
 }
@@ -131,6 +135,13 @@ impl<T> PropertySetNested for RwLock<T> {
     }
 }
 
+impl<T> PropertyGet for ThreadGuard<T> {
+    type Value = Self;
+    fn get<R, F: Fn(&Self::Value) -> R>(&self, f: F) -> R {
+        f(self)
+    }
+}
+
 impl<T> PropertyGet for once_cell::sync::OnceCell<T> {
     type Value = T;
     fn get<R, F: Fn(&Self::Value) -> R>(&self, f: F) -> R {

glib/src/thread_guard.rs

@@ -4,6 +4,10 @@ use std::{
     mem, ptr,
     sync::atomic::{AtomicUsize, Ordering},
 };
+
+use crate::value::{FromValue, ValueTypeChecker, ValueTypeMismatchOrNoneError};
+use crate::{StaticType, ToValue, Type, Value};
+
 fn next_thread_id() -> usize {
     static COUNTER: AtomicUsize = AtomicUsize::new(0);
     COUNTER.fetch_add(1, Ordering::SeqCst)
@@ -111,4 +115,42 @@ impl<T> Drop for ThreadGuard<T> {
     }
 }
 
+impl<T: Default> Default for ThreadGuard<T> {
+    fn default() -> Self {
+        Self::new(T::default())
+    }
+}
+
 unsafe impl<T> Send for ThreadGuard<T> {}
+
+impl<T: ToValue + StaticType> ToValue for ThreadGuard<T> {
+    fn to_value(&self) -> Value {
+        T::to_value(self.get_ref())
+    }
+
+    fn value_type(&self) -> Type {
+        T::static_type()
+    }
+}
+
+impl<T: From<Value>> From<ThreadGuard<T>> for Value
+where
+    Value: From<T>,
+{
+    fn from(guard: ThreadGuard<T>) -> Self {
+        Self::from(guard.into_inner())
+    }
+}
+
+unsafe impl<'a, T, C, E> FromValue<'a> for ThreadGuard<T>
+where
+    T: FromValue<'a, Checker = C> + StaticType,
+    C: ValueTypeChecker<Error = ValueTypeMismatchOrNoneError<E>>,
+    E: std::error::Error + Send + Sized + 'static,
+{
+    type Checker = T::Checker;
+
+    unsafe fn from_value(value: &'a Value) -> Self {
+        Self::new(T::from_value(value))
+    }
+}