Merge pull request #1071 from sdroege/value-path

glib: Allow using `Path` / `PathBuf` in `glib::Value`s

Author: sdroege

glib/src/param_spec.rs

@@ -1,6 +1,11 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use std::{char::CharTryFromError, convert::TryFrom, ffi::CStr};
+use std::{
+    char::CharTryFromError,
+    convert::TryFrom,
+    ffi::CStr,
+    path::{Path, PathBuf},
+};
 
 use crate::{
     object::{Interface, InterfaceRef, IsClass, IsInterface, ObjectClass},
@@ -2142,6 +2147,24 @@ impl HasParamSpec for Vec<String> {
         Self::ParamSpec::builder
     }
 }
+impl HasParamSpec for Path {
+    type ParamSpec = ParamSpecString;
+    type SetValue = Path;
+    type BuilderFn = fn(&str) -> ParamSpecStringBuilder;
+
+    fn param_spec_builder() -> Self::BuilderFn {
+        Self::ParamSpec::builder
+    }
+}
+impl HasParamSpec for PathBuf {
+    type ParamSpec = ParamSpecString;
+    type SetValue = Path;
+    type BuilderFn = fn(&str) -> ParamSpecStringBuilder;
+
+    fn param_spec_builder() -> Self::BuilderFn {
+        Self::ParamSpec::builder
+    }
+}
 impl HasParamSpec for char {
     type ParamSpec = ParamSpecUnichar;
     type SetValue = Self;

glib/src/types.rs

@@ -3,7 +3,13 @@
 // rustdoc-stripper-ignore-next
 //! Runtime type information.
 
-use std::{fmt, marker::PhantomData, mem, ptr};
+use std::{
+    fmt,
+    marker::PhantomData,
+    mem,
+    path::{Path, PathBuf},
+    ptr,
+};
 
 use crate::{translate::*, IntoGStr, Slice};
 
@@ -496,6 +502,8 @@ builtin!(f32, F32);
 builtin!(f64, F64);
 builtin!(str, STRING);
 builtin!(String, STRING);
+builtin!(PathBuf, STRING);
+builtin!(Path, STRING);
 builtin!(Pointer, POINTER);
 
 impl<'a> StaticType for [&'a str] {

glib/src/value.rs

@@ -40,7 +40,15 @@
 //! assert_eq!(str_none.get::<Option<String>>(), Ok(None));
 //! ```
 
-use std::{convert::Infallible, error, ffi::CStr, fmt, mem, ops::Deref, ptr};
+use std::{
+    convert::Infallible,
+    error,
+    ffi::CStr,
+    fmt, mem,
+    ops::Deref,
+    path::{Path, PathBuf},
+    ptr,
+};
 
 use libc::{c_char, c_void};
 
@@ -1012,6 +1020,80 @@ impl<'a> ToValue for &'a [&'a str] {
     }
 }
 
+impl ToValue for Path {
+    fn to_value(&self) -> Value {
+        unsafe {
+            let mut value = Value::for_value_type::<PathBuf>();
+
+            gobject_ffi::g_value_take_string(value.to_glib_none_mut().0, self.to_glib_full());
+
+            value
+        }
+    }
+
+    fn value_type(&self) -> Type {
+        PathBuf::static_type()
+    }
+}
+
+impl ToValue for &Path {
+    fn to_value(&self) -> Value {
+        (*self).to_value()
+    }
+
+    fn value_type(&self) -> Type {
+        PathBuf::static_type()
+    }
+}
+
+impl ToValueOptional for Path {
+    fn to_value_optional(s: Option<&Self>) -> Value {
+        let mut value = Value::for_value_type::<PathBuf>();
+        unsafe {
+            gobject_ffi::g_value_take_string(value.to_glib_none_mut().0, s.to_glib_full());
+        }
+
+        value
+    }
+}
+
+impl ValueType for PathBuf {
+    type Type = PathBuf;
+}
+
+impl ValueTypeOptional for PathBuf {}
+
+unsafe impl<'a> FromValue<'a> for PathBuf {
+    type Checker = GenericValueTypeOrNoneChecker<Self>;
+
+    unsafe fn from_value(value: &'a Value) -> Self {
+        from_glib_none(gobject_ffi::g_value_get_string(value.to_glib_none().0))
+    }
+}
+
+impl ToValue for PathBuf {
+    fn to_value(&self) -> Value {
+        <&Path>::to_value(&self.as_path())
+    }
+
+    fn value_type(&self) -> Type {
+        PathBuf::static_type()
+    }
+}
+
+impl From<PathBuf> for Value {
+    #[inline]
+    fn from(s: PathBuf) -> Self {
+        s.to_value()
+    }
+}
+
+impl ToValueOptional for PathBuf {
+    fn to_value_optional(s: Option<&Self>) -> Value {
+        <Path>::to_value_optional(s.as_ref().map(|s| s.as_path()))
+    }
+}
+
 impl ValueType for bool {
     type Type = Self;
 }