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

@@ -88,6 +88,7 @@ mod foo {
 
     pub mod imp {
         use glib::{ParamSpec, Value};
+        use glib::thread_guard::ThreadGuard;
         use std::rc::Rc;
 
         use super::*;
@@ -145,6 +146,8 @@ mod foo {
             cell: Cell<u8>,
             #[property(get = Self::overridden, override_class = Base)]
             overridden: PhantomData<u32>,
+            #[property(get, set, default = "")]
+            thread_guard: RefCell<ThreadGuard<String>>,
         }
 
         impl ObjectImpl for Foo {

glib/src/param_spec.rs

@@ -2065,6 +2065,17 @@ pub trait HasParamSpec {
     fn param_spec_builder() -> Self::BuilderFn;
 }
 
+impl<T: HasParamSpec> HasParamSpec
+    for crate::thread_guard::ThreadGuard<T>
+{
+    type ParamSpec = T::ParamSpec;
+    type SetValue = T::SetValue;
+    type BuilderFn = T::BuilderFn;
+
+    fn param_spec_builder() -> Self::BuilderFn {
+        T::param_spec_builder()
+    }
+}
 impl<T: crate::value::ToValueOptional + HasParamSpec> HasParamSpec for Option<T> {
     type ParamSpec = T::ParamSpec;
     type SetValue = T::SetValue;

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,40 @@ 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()
+    }
+}
+
+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 {
+        match T::Checker::check(value) {
+            Err(ValueTypeMismatchOrNoneError::UnexpectedNone) => panic!(),
+            Err(ValueTypeMismatchOrNoneError::WrongValueType(_err)) => {
+                // This should've been caught by the caller already.
+                unreachable!();
+            }
+            Ok(_) => Self::new(T::from_value(value)),
+        }
+    }
+}