Implement gio::File::set_attribute

Signed-off-by: fbrouille <[email protected]>

Author: fbrouille

gio/src/file.rs

@@ -1,12 +1,14 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use std::{cell::RefCell, mem, pin::Pin, ptr};
+use std::{cell::RefCell, ffi::CStr, mem, pin::Pin, ptr};
 
 use glib::{prelude::*, translate::*};
 
 #[cfg(feature = "v2_74")]
 use crate::FileIOStream;
-use crate::{ffi, Cancellable, File, FileCreateFlags, FileEnumerator, FileQueryInfoFlags};
+use crate::{
+    ffi, Cancellable, File, FileAttributeType, FileCreateFlags, FileEnumerator, FileQueryInfoFlags,
+};
 
 impl File {
     #[cfg(feature = "v2_74")]
@@ -1111,6 +1113,177 @@ pub trait FileExtManual: IsA<File> + Sized {
 
         (fut, Box::pin(receiver))
     }
+
+    #[doc(alias = "g_file_set_attribute")]
+    fn set_attribute(
+        &self,
+        attribute: &str,
+        type_value: FileAttributeTypeValue,
+        flags: FileQueryInfoFlags,
+        cancellable: Option<&impl IsA<Cancellable>>,
+    ) -> Result<(), glib::Error> {
+        unsafe {
+            let mut error = std::ptr::null_mut();
+            let is_ok = ffi::g_file_set_attribute(
+                self.as_ref().to_glib_none().0,
+                attribute.to_glib_none().0,
+                type_value.as_ref().type_().into_glib(),
+                type_value.as_ref().value().as_ptr(),
+                flags.into_glib(),
+                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                &mut error,
+            );
+            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+            if error.is_null() {
+                Ok(())
+            } else {
+                Err(from_glib_full(error))
+            }
+        }
+    }
 }
 
 impl<O: IsA<File>> FileExtManual for O {}
+
+#[derive(Debug)]
+// checker-ignore-item
+pub struct FileAttributeTypeValue<'a>(FileAttributeTypeValueInner<'a>);
+
+impl<'a> FileAttributeTypeValue<'a> {
+    // new_pointer is private to gio crate to not allow creating values of arbitrary pointers from safe code
+    #[allow(dead_code)] // TODO remove this allow attribute when new_pointer will be used by this crate
+    pub(crate) fn new_pointer(type_: FileAttributeType, ptr: glib::ffi::gpointer) -> Self {
+        Self(FileAttributeTypeValueInner::Pointer(type_, ptr))
+    }
+
+    pub fn new_string(value: &'a str) -> Self {
+        Self(FileAttributeTypeValueInner::String(value))
+    }
+
+    pub fn new_byte_string(value: &'a CStr) -> Self {
+        Self(FileAttributeTypeValueInner::ByteString(value))
+    }
+
+    pub fn new_boolean(value: bool) -> Self {
+        Self(FileAttributeTypeValueInner::Boolean(value))
+    }
+
+    pub fn new_uint32(value: u32) -> Self {
+        Self(FileAttributeTypeValueInner::Uint32(value))
+    }
+
+    pub fn new_int32(value: i32) -> Self {
+        Self(FileAttributeTypeValueInner::Int32(value))
+    }
+
+    pub fn new_uint64(value: u64) -> Self {
+        Self(FileAttributeTypeValueInner::Uint64(value))
+    }
+
+    pub fn new_int64(value: i64) -> Self {
+        Self(FileAttributeTypeValueInner::Int64(value))
+    }
+
+    pub fn new_object<T: AsRef<glib::Object>>(value: &'a T) -> Self {
+        Self(FileAttributeTypeValueInner::Object(value.as_ref()))
+    }
+
+    pub fn new_stringv(value: &'a Vec<&'a str>) -> Self {
+        Self(FileAttributeTypeValueInner::Stringv(value))
+    }
+}
+
+impl<'a> AsRef<FileAttributeTypeValueInner<'a>> for FileAttributeTypeValue<'a> {
+    fn as_ref(&self) -> &FileAttributeTypeValueInner<'a> {
+        &self.0
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum FileAttributeTypeValueInner<'a> {
+    Pointer(FileAttributeType, glib::ffi::gpointer),
+    String(&'a str),
+    ByteString(&'a CStr),
+    Boolean(bool),
+    Uint32(u32),
+    Int32(i32),
+    Uint64(u64),
+    Int64(i64),
+    Object(&'a glib::Object),
+    Stringv(&'a Vec<&'a str>),
+}
+
+impl<'a> FileAttributeTypeValueInner<'a> {
+    pub(crate) fn type_(&self) -> FileAttributeType {
+        match self {
+            Self::Pointer(type_, _) => *type_,
+            Self::String(_) => FileAttributeType::String,
+            Self::ByteString(_) => FileAttributeType::ByteString,
+            Self::Boolean(_) => FileAttributeType::Boolean,
+            Self::Uint32(_) => FileAttributeType::Uint32,
+            Self::Int32(_) => FileAttributeType::Int32,
+            Self::Uint64(_) => FileAttributeType::Uint64,
+            Self::Int64(_) => FileAttributeType::Int64,
+            Self::Object(_) => FileAttributeType::Object,
+            Self::Stringv(_) => FileAttributeType::Stringv,
+        }
+    }
+
+    pub(crate) fn value(&self) -> FileAttributeTypeValueStorage<'a> {
+        match self {
+            Self::Pointer(_, pointer) => FileAttributeTypeValueStorage::Pointer(*pointer),
+            Self::String(value) => FileAttributeTypeValueStorage::String(
+                ToGlibPtr::<*mut libc::c_char>::to_glib_none(value).1,
+            ),
+            Self::ByteString(value) => {
+                FileAttributeTypeValueStorage::ByteString(
+                    ToGlibPtr::<*mut libc::c_char>::to_glib_none(value),
+                )
+            }
+            Self::Boolean(value) => FileAttributeTypeValueStorage::Boolean(value.into_glib()),
+            Self::Uint32(value) => FileAttributeTypeValueStorage::Uint32(*value),
+            Self::Int32(value) => FileAttributeTypeValueStorage::Int32(*value),
+            Self::Uint64(value) => FileAttributeTypeValueStorage::Uint64(*value),
+            Self::Int64(value) => FileAttributeTypeValueStorage::Int64(*value),
+            Self::Object(value) => {
+                FileAttributeTypeValueStorage::Object(ToGlibPtr::<
+                    <glib::Object as glib::translate::GlibPtrDefault>::GlibType,
+                >::to_glib_none(value))
+            }
+            Self::Stringv(value) => FileAttributeTypeValueStorage::Stringv(
+                ToGlibContainerFromSlice::<*mut *mut libc::c_char>::to_glib_none_from_slice(value)
+                    .1,
+            ),
+        }
+    }
+}
+
+pub(crate) enum FileAttributeTypeValueStorage<'a> {
+    Pointer(glib::ffi::gpointer),
+    String(<&'a str as ToGlibPtr<'a, *mut libc::c_char>>::Storage),
+    ByteString(Stash<'a, *mut libc::c_char, CStr>),
+    Boolean(glib::ffi::gboolean),
+    Uint32(u32),
+    Int32(i32),
+    Uint64(u64),
+    Int64(i64),
+    Object(Stash<'a, <glib::Object as glib::translate::GlibPtrDefault>::GlibType, glib::Object>),
+    Stringv(<&'a str as ToGlibContainerFromSlice<'a, *mut *mut libc::c_char>>::Storage),
+}
+
+impl FileAttributeTypeValueStorage<'_> {
+    pub(crate) fn as_ptr(&self) -> glib::ffi::gpointer {
+        match self {
+            Self::Pointer(s) => *s,
+            Self::String(s) => s.as_ptr() as _,
+            Self::ByteString(s) => s.0 as _,
+            Self::Boolean(s) => s as *const i32 as _,
+            Self::Uint32(s) => s as *const u32 as _,
+            Self::Int32(s) => s as *const i32 as _,
+            Self::Uint64(s) => s as *const u64 as _,
+            Self::Int64(s) => s as *const i64 as _,
+            Self::Object(s) => s.0 as _,
+            Self::Stringv(s) => s.1.as_ref().unwrap().as_ptr() as _,
+        }
+    }
+}

gio/src/lib.rs

@@ -43,6 +43,7 @@ mod debug_controller_dbus;
 mod desktop_app_info;
 mod error;
 mod file;
+pub use file::FileAttributeTypeValue;
 mod file_attribute_info;
 pub use crate::file_attribute_info::FileAttributeInfo;
 mod file_attribute_info_list;