gio/auto/

file.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{
    AppInfo, AsyncResult, Cancellable, DriveStartFlags, FileAttributeInfoList, FileCopyFlags,
    FileCreateFlags, FileEnumerator, FileIOStream, FileInfo, FileInputStream, FileMeasureFlags,
    FileMonitor, FileMonitorFlags, FileOutputStream, FileQueryInfoFlags, FileType, Mount,
    MountMountFlags, MountOperation, MountUnmountFlags, ffi,
};
use glib::{prelude::*, translate::*};
use std::{boxed::Box as Box_, pin::Pin};

glib::wrapper! {
    /// `GFile` is a high level abstraction for manipulating files on a
    /// virtual file system. `GFile`s are lightweight, immutable objects
    /// that do no I/O upon creation. It is necessary to understand that
    /// `GFile` objects do not represent files, merely an identifier for a
    /// file. All file content I/O is implemented as streaming operations
    /// (see [`InputStream`][crate::InputStream] and [`OutputStream`][crate::OutputStream]).
    ///
    /// To construct a `GFile`, you can use:
    ///
    /// - [`for_path()`][Self::for_path()] if you have a path.
    /// - [`for_uri()`][Self::for_uri()] if you have a URI.
    /// - [`for_commandline_arg()`][Self::for_commandline_arg()] or
    ///   [`for_commandline_arg_and_cwd()`][Self::for_commandline_arg_and_cwd()] for a command line
    ///   argument.
    /// - [`new_tmp()`][Self::new_tmp()] to create a temporary file from a template.
    /// - [`new_tmp_async()`][Self::new_tmp_async()] to asynchronously create a temporary file.
    /// - [`new_tmp_dir_async()`][Self::new_tmp_dir_async()] to asynchronously create a temporary
    ///   directory.
    /// - [`for_parse_name()`][Self::for_parse_name()] from a UTF-8 string gotten from
    ///   [`FileExt::parse_name()`][crate::prelude::FileExt::parse_name()].
    /// - `Gio::File::new_build_filename()` or [`new_build_filenamev()`][Self::new_build_filenamev()]
    ///   to create a file from path elements.
    ///
    /// One way to think of a `GFile` is as an abstraction of a pathname. For
    /// normal files the system pathname is what is stored internally, but as
    /// `GFile`s are extensible it could also be something else that corresponds
    /// to a pathname in a userspace implementation of a filesystem.
    ///
    /// `GFile`s make up hierarchies of directories and files that correspond to
    /// the files on a filesystem. You can move through the file system with
    /// `GFile` using [`FileExt::parent()`][crate::prelude::FileExt::parent()] to get an identifier for the
    /// parent directory, [`FileExt::child()`][crate::prelude::FileExt::child()] to get a child within a
    /// directory, and [`FileExt::resolve_relative_path()`][crate::prelude::FileExt::resolve_relative_path()] to resolve a relative
    /// path between two `GFile`s. There can be multiple hierarchies, so you may not
    /// end up at the same root if you repeatedly call [`FileExt::parent()`][crate::prelude::FileExt::parent()]
    /// on two different files.
    ///
    /// All `GFile`s have a basename (get with [`FileExt::basename()`][crate::prelude::FileExt::basename()]). These
    /// names are byte strings that are used to identify the file on the filesystem
    /// (relative to its parent directory) and there is no guarantees that they
    /// have any particular charset encoding or even make any sense at all. If
    /// you want to use filenames in a user interface you should use the display
    /// name that you can get by requesting the
    /// `G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME` attribute with
    /// [`FileExt::query_info()`][crate::prelude::FileExt::query_info()]. This is guaranteed to be in UTF-8 and can be
    /// used in a user interface. But always store the real basename or the `GFile`
    /// to use to actually access the file, because there is no way to go from a
    /// display name to the actual name.
    ///
    /// Using `GFile` as an identifier has the same weaknesses as using a path
    /// in that there may be multiple aliases for the same file. For instance,
    /// hard or soft links may cause two different `GFile`s to refer to the same
    /// file. Other possible causes for aliases are: case insensitive filesystems,
    /// short and long names on FAT/NTFS, or bind mounts in Linux. If you want to
    /// check if two `GFile`s point to the same file you can query for the
    /// `G_FILE_ATTRIBUTE_ID_FILE` attribute. Note that `GFile` does some trivial
    /// canonicalization of pathnames passed in, so that trivial differences in
    /// the path string used at creation (duplicated slashes, slash at end of
    /// path, `.` or `..` path segments, etc) does not create different `GFile`s.
    ///
    /// Many `GFile` operations have both synchronous and asynchronous versions
    /// to suit your application. Asynchronous versions of synchronous functions
    /// simply have `_async()` appended to their function names. The asynchronous
    /// I/O functions call a `callback::Gio::AsyncReadyCallback which is then used to
    /// finalize the operation, producing a [`AsyncResult`][crate::AsyncResult] which is then
    /// passed to the function’s matching `_finish()` operation.
    ///
    /// It is highly recommended to use asynchronous calls when running within a
    /// shared main loop, such as in the main thread of an application. This avoids
    /// I/O operations blocking other sources on the main loop from being dispatched.
    /// Synchronous I/O operations should be performed from worker threads. See the
    /// [introduction to asynchronous programming section](overview.html#asynchronous-programming)
    /// for more.
    ///
    /// Some `GFile` operations almost always take a noticeable amount of time, and
    /// so do not have synchronous analogs. Notable cases include:
    ///
    /// - [`FileExt::mount_mountable()`][crate::prelude::FileExt::mount_mountable()] to mount a mountable file.
    /// - [`FileExt::unmount_mountable_with_operation()`][crate::prelude::FileExt::unmount_mountable_with_operation()] to unmount a mountable
    ///   file.
    /// - [`FileExt::eject_mountable_with_operation()`][crate::prelude::FileExt::eject_mountable_with_operation()] to eject a mountable file.
    ///
    /// ## Entity Tags
    ///
    /// One notable feature of `GFile`s are entity tags, or ‘etags’ for
    /// short. Entity tags are somewhat like a more abstract version of the
    /// traditional mtime, and can be used to quickly determine if the file
    /// has been modified from the version on the file system. See the
    /// description of HTTP ETags in
    /// [RFC9110](https://www.rfc-editor.org/rfc/rfc9110.html#name-etag).
    /// `GFile` Entity Tags are a very similar concept.
    ///
    /// # Implements
    ///
    /// [`FileExt`][trait@crate::prelude::FileExt], [`FileExtManual`][trait@crate::prelude::FileExtManual]
    #[doc(alias = "GFile")]
    pub struct File(Interface<ffi::GFile, ffi::GFileIface>);

    match fn {
        type_ => || ffi::g_file_get_type(),
    }
}

impl File {
    pub const NONE: Option<&'static File> = None;

    //#[doc(alias = "g_file_new_build_filename")]
    //pub fn new_build_filename(first_element: impl AsRef<std::path::Path>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> File {
    //    unsafe { TODO: call ffi:g_file_new_build_filename() }
    //}

    /// Constructs a #GFile from a vector of elements using the correct
    /// separator for filenames.
    ///
    /// Using this function is equivalent to calling g_build_filenamev(),
    /// followed by g_file_new_for_path() on the result.
    /// ## `args`
    /// [`None`]-terminated
    ///   array of strings containing the path elements.
    ///
    /// # Returns
    ///
    /// a new #GFile
    #[cfg(feature = "v2_78")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_78")))]
    #[doc(alias = "g_file_new_build_filenamev")]
    pub fn new_build_filenamev(args: &[&std::path::Path]) -> File {
        unsafe { from_glib_full(ffi::g_file_new_build_filenamev(args.to_glib_none().0)) }
    }

    /// Creates a #GFile with the given argument from the command line.
    /// The value of @arg can be either a URI, an absolute path or a
    /// relative path resolved relative to the current working directory.
    /// This operation never fails, but the returned object might not
    /// support any I/O operation if @arg points to a malformed path.
    ///
    /// Note that on Windows, this function expects its argument to be in
    /// UTF-8 -- not the system code page.  This means that you
    /// should not use this function with string from argv as it is passed
    /// to main().  g_win32_get_command_line() will return a UTF-8 version of
    /// the commandline.  #GApplication also uses UTF-8 but
    /// g_application_command_line_create_file_for_arg() may be more useful
    /// for you there.  It is also always possible to use this function with
    /// #GOptionContext arguments of type [`glib::OptionArg::Filename`][crate::glib::OptionArg::Filename].
    /// ## `arg`
    /// a command line string
    ///
    /// # Returns
    ///
    /// a new #GFile.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_new_for_commandline_arg")]
    #[doc(alias = "new_for_commandline_arg")]
    pub fn for_commandline_arg(arg: impl AsRef<std::ffi::OsStr>) -> File {
        unsafe {
            from_glib_full(ffi::g_file_new_for_commandline_arg(
                arg.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Creates a #GFile with the given argument from the command line.
    ///
    /// This function is similar to g_file_new_for_commandline_arg() except
    /// that it allows for passing the current working directory as an
    /// argument instead of using the current working directory of the
    /// process.
    ///
    /// This is useful if the commandline argument was given in a context
    /// other than the invocation of the current process.
    ///
    /// See also g_application_command_line_create_file_for_arg().
    /// ## `arg`
    /// a command line string
    /// ## `cwd`
    /// the current working directory of the commandline
    ///
    /// # Returns
    ///
    /// a new #GFile
    #[doc(alias = "g_file_new_for_commandline_arg_and_cwd")]
    #[doc(alias = "new_for_commandline_arg_and_cwd")]
    pub fn for_commandline_arg_and_cwd(
        arg: impl AsRef<std::ffi::OsStr>,
        cwd: impl AsRef<std::path::Path>,
    ) -> File {
        unsafe {
            from_glib_full(ffi::g_file_new_for_commandline_arg_and_cwd(
                arg.as_ref().to_glib_none().0,
                cwd.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Constructs a #GFile for a given path. This operation never
    /// fails, but the returned object might not support any I/O
    /// operation if @path is malformed.
    /// ## `path`
    /// a string containing a relative or absolute path.
    ///   The string must be encoded in the glib filename encoding.
    ///
    /// # Returns
    ///
    /// a new #GFile for the given @path.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_new_for_path")]
    #[doc(alias = "new_for_path")]
    pub fn for_path(path: impl AsRef<std::path::Path>) -> File {
        unsafe { from_glib_full(ffi::g_file_new_for_path(path.as_ref().to_glib_none().0)) }
    }

    /// Constructs a #GFile for a given URI. This operation never
    /// fails, but the returned object might not support any I/O
    /// operation if @uri is malformed or if the uri type is
    /// not supported.
    /// ## `uri`
    /// a UTF-8 string containing a URI
    ///
    /// # Returns
    ///
    /// a new #GFile for the given @uri.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_new_for_uri")]
    #[doc(alias = "new_for_uri")]
    pub fn for_uri(uri: &str) -> File {
        unsafe { from_glib_full(ffi::g_file_new_for_uri(uri.to_glib_none().0)) }
    }

    /// Opens a file in the preferred directory for temporary files (as
    /// returned by g_get_tmp_dir()) and returns a #GFile and
    /// #GFileIOStream pointing to it.
    ///
    /// @tmpl should be a string in the GLib file name encoding
    /// containing a sequence of six 'X' characters, and containing no
    /// directory components. If it is [`None`], a default template is used.
    ///
    /// Unlike the other #GFile constructors, this will return [`None`] if
    /// a temporary file could not be created.
    /// ## `tmpl`
    /// Template for the file
    ///   name, as in g_file_open_tmp(), or [`None`] for a default template
    ///
    /// # Returns
    ///
    /// a new #GFile.
    ///   Free the returned object with g_object_unref().
    ///
    /// ## `iostream`
    /// on return, a #GFileIOStream for the created file
    #[doc(alias = "g_file_new_tmp")]
    pub fn new_tmp(
        tmpl: Option<impl AsRef<std::path::Path>>,
    ) -> Result<(File, FileIOStream), glib::Error> {
        unsafe {
            let mut iostream = std::ptr::null_mut();
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_new_tmp(
                tmpl.as_ref().map(|p| p.as_ref()).to_glib_none().0,
                &mut iostream,
                &mut error,
            );
            if error.is_null() {
                Ok((from_glib_full(ret), from_glib_full(iostream)))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Constructs a #GFile with the given @parse_name (i.e. something
    /// given by g_file_get_parse_name()). This operation never fails,
    /// but the returned object might not support any I/O operation if
    /// the @parse_name cannot be parsed.
    /// ## `parse_name`
    /// a file name or path to be parsed
    ///
    /// # Returns
    ///
    /// a new #GFile.
    #[doc(alias = "g_file_parse_name")]
    #[doc(alias = "parse_name")]
    pub fn for_parse_name(parse_name: &str) -> File {
        unsafe { from_glib_full(ffi::g_file_parse_name(parse_name.to_glib_none().0)) }
    }
}

unsafe impl Send for File {}
unsafe impl Sync for File {}

/// Trait containing all [`struct@File`] methods.
///
/// # Implementors
///
/// [`File`][struct@crate::File]
pub trait FileExt: IsA<File> + 'static {
    /// Gets an output stream for appending data to the file.
    /// If the file doesn't already exist it is created.
    ///
    /// By default files created are generally readable by everyone,
    /// but if you pass [`FileCreateFlags::PRIVATE`][crate::FileCreateFlags::PRIVATE] in @flags the file
    /// will be made readable only to the current user, to the level that
    /// is supported on the target filesystem.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled
    /// by triggering the cancellable object from another thread. If the
    /// operation was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be
    /// returned.
    ///
    /// Some file systems don't allow all file names, and may return an
    /// [`IOErrorEnum::InvalidFilename`][crate::IOErrorEnum::InvalidFilename] error. If the file is a directory the
    /// [`IOErrorEnum::IsDirectory`][crate::IOErrorEnum::IsDirectory] error will be returned. Other errors are
    /// possible too, and depend on what kind of filesystem the file is on.
    /// ## `flags`
    /// a set of #GFileCreateFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GFileOutputStream, or [`None`] on error.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_append_to")]
    fn append_to(
        &self,
        flags: FileCreateFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileOutputStream, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_append_to(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously opens @self for appending.
    ///
    /// For more details, see g_file_append_to() which is
    /// the synchronous version of this call.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_append_to_finish() to get the result
    /// of the operation.
    /// ## `flags`
    /// a set of #GFileCreateFlags
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_append_to_async")]
    fn append_to_async<P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static>(
        &self,
        flags: FileCreateFlags,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn append_to_async_trampoline<
            P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::g_file_append_to_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = append_to_async_trampoline::<P>;
        unsafe {
            ffi::g_file_append_to_async(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn append_to_future(
        &self,
        flags: FileCreateFlags,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileOutputStream, glib::Error>> + 'static>>
    {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.append_to_async(flags, io_priority, Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    #[cfg(feature = "v2_68")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_68")))]
    #[doc(alias = "g_file_build_attribute_list_for_copy")]
    fn build_attribute_list_for_copy(
        &self,
        flags: FileCopyFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<glib::GString, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_build_attribute_list_for_copy(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "g_file_copy")]
    fn copy(
        &self,
        destination: &impl IsA<File>,
        flags: FileCopyFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
        progress_callback: Option<&mut dyn FnMut(i64, i64)>,
    ) -> Result<(), glib::Error> {
        let mut progress_callback_data: Option<&mut dyn FnMut(i64, i64)> = progress_callback;
        unsafe extern "C" fn progress_callback_func(
            current_num_bytes: i64,
            total_num_bytes: i64,
            data: glib::ffi::gpointer,
        ) {
            unsafe {
                let callback = data as *mut Option<&mut dyn FnMut(i64, i64)>;
                if let Some(ref mut callback) = *callback {
                    callback(current_num_bytes, total_num_bytes)
                } else {
                    panic!("cannot get closure...")
                }
            }
        }
        let progress_callback = if progress_callback_data.is_some() {
            Some(progress_callback_func as _)
        } else {
            None
        };
        let super_callback0: &mut Option<&mut dyn FnMut(i64, i64)> = &mut progress_callback_data;
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_file_copy(
                self.as_ref().to_glib_none().0,
                destination.as_ref().to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                progress_callback,
                super_callback0 as *mut _ as *mut _,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Copies the file attributes from @self to @destination.
    ///
    /// Normally only a subset of the file attributes are copied,
    /// those that are copies in a normal file copy operation
    /// (which for instance does not include e.g. owner). However
    /// if [`FileCopyFlags::ALL_METADATA`][crate::FileCopyFlags::ALL_METADATA] is specified in @flags, then
    /// all the metadata that is possible to copy is copied. This
    /// is useful when implementing move by copy + delete source.
    /// ## `destination`
    /// a #GFile to copy attributes to
    /// ## `flags`
    /// a set of #GFileCopyFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] if the attributes were copied successfully,
    ///   [`false`] otherwise.
    #[doc(alias = "g_file_copy_attributes")]
    fn copy_attributes(
        &self,
        destination: &impl IsA<File>,
        flags: FileCopyFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_file_copy_attributes(
                self.as_ref().to_glib_none().0,
                destination.as_ref().to_glib_none().0,
                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))
            }
        }
    }

    /// Creates a new file and returns an output stream for writing to it.
    /// The file must not already exist.
    ///
    /// By default files created are generally readable by everyone,
    /// but if you pass [`FileCreateFlags::PRIVATE`][crate::FileCreateFlags::PRIVATE] in @flags the file
    /// will be made readable only to the current user, to the level
    /// that is supported on the target filesystem.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled
    /// by triggering the cancellable object from another thread. If the
    /// operation was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be
    /// returned.
    ///
    /// If a file or directory with this name already exists the
    /// [`IOErrorEnum::Exists`][crate::IOErrorEnum::Exists] error will be returned. Some file systems don't
    /// allow all file names, and may return an [`IOErrorEnum::InvalidFilename`][crate::IOErrorEnum::InvalidFilename]
    /// error, and if the name is to long [`IOErrorEnum::FilenameTooLong`][crate::IOErrorEnum::FilenameTooLong] will
    /// be returned. Other errors are possible too, and depend on what kind
    /// of filesystem the file is on.
    /// ## `flags`
    /// a set of #GFileCreateFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GFileOutputStream for the newly created
    ///   file, or [`None`] on error.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_create")]
    fn create(
        &self,
        flags: FileCreateFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileOutputStream, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_create(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously creates a new file and returns an output stream
    /// for writing to it. The file must not already exist.
    ///
    /// For more details, see g_file_create() which is
    /// the synchronous version of this call.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_create_finish() to get the result
    /// of the operation.
    /// ## `flags`
    /// a set of #GFileCreateFlags
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_create_async")]
    fn create_async<P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static>(
        &self,
        flags: FileCreateFlags,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn create_async_trampoline<
            P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::g_file_create_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = create_async_trampoline::<P>;
        unsafe {
            ffi::g_file_create_async(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn create_future(
        &self,
        flags: FileCreateFlags,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileOutputStream, glib::Error>> + 'static>>
    {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.create_async(flags, io_priority, Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Creates a new file and returns a stream for reading and
    /// writing to it. The file must not already exist.
    ///
    /// By default files created are generally readable by everyone,
    /// but if you pass [`FileCreateFlags::PRIVATE`][crate::FileCreateFlags::PRIVATE] in @flags the file
    /// will be made readable only to the current user, to the level
    /// that is supported on the target filesystem.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled
    /// by triggering the cancellable object from another thread. If the
    /// operation was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be
    /// returned.
    ///
    /// If a file or directory with this name already exists, the
    /// [`IOErrorEnum::Exists`][crate::IOErrorEnum::Exists] error will be returned. Some file systems don't
    /// allow all file names, and may return an [`IOErrorEnum::InvalidFilename`][crate::IOErrorEnum::InvalidFilename]
    /// error, and if the name is too long, [`IOErrorEnum::FilenameTooLong`][crate::IOErrorEnum::FilenameTooLong]
    /// will be returned. Other errors are possible too, and depend on what
    /// kind of filesystem the file is on.
    ///
    /// Note that in many non-local file cases read and write streams are
    /// not supported, so make sure you really need to do read and write
    /// streaming, rather than just opening for reading or writing.
    /// ## `flags`
    /// a set of #GFileCreateFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GFileIOStream for the newly created
    ///   file, or [`None`] on error.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_create_readwrite")]
    fn create_readwrite(
        &self,
        flags: FileCreateFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileIOStream, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_create_readwrite(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously creates a new file and returns a stream
    /// for reading and writing to it. The file must not already exist.
    ///
    /// For more details, see g_file_create_readwrite() which is
    /// the synchronous version of this call.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_create_readwrite_finish() to get
    /// the result of the operation.
    /// ## `flags`
    /// a set of #GFileCreateFlags
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_create_readwrite_async")]
    fn create_readwrite_async<P: FnOnce(Result<FileIOStream, glib::Error>) + 'static>(
        &self,
        flags: FileCreateFlags,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn create_readwrite_async_trampoline<
            P: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret =
                    ffi::g_file_create_readwrite_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = create_readwrite_async_trampoline::<P>;
        unsafe {
            ffi::g_file_create_readwrite_async(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn create_readwrite_future(
        &self,
        flags: FileCreateFlags,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileIOStream, glib::Error>> + 'static>>
    {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.create_readwrite_async(flags, io_priority, Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Deletes a file. If the @self is a directory, it will only be
    /// deleted if it is empty. This has the same semantics as g_unlink().
    ///
    /// If @self doesn’t exist, [`IOErrorEnum::NotFound`][crate::IOErrorEnum::NotFound] will be returned. This allows
    /// for deletion to be implemented avoiding
    /// [time-of-check to time-of-use races](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use):
    ///
    /// ```text
    /// g_autoptr(GError) local_error = NULL;
    /// if (!g_file_delete (my_file, my_cancellable, &local_error) &&
    ///     !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
    ///   {
    ///     // deletion failed for some reason other than the file not existing:
    ///     // so report the error
    ///     g_warning ("Failed to delete %s: %s",
    ///                g_file_peek_path (my_file), local_error->message);
    ///   }
    /// ```
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] if the file was deleted. [`false`] otherwise.
    #[doc(alias = "g_file_delete")]
    fn delete(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_file_delete(
                self.as_ref().to_glib_none().0,
                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))
            }
        }
    }

    /// Asynchronously delete a file. If the @self is a directory, it will
    /// only be deleted if it is empty.  This has the same semantics as
    /// g_unlink().
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call
    ///   when the request is satisfied
    #[doc(alias = "g_file_delete_async")]
    fn delete_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn delete_async_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_file_delete_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = delete_async_trampoline::<P>;
        unsafe {
            ffi::g_file_delete_async(
                self.as_ref().to_glib_none().0,
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn delete_future(
        &self,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.delete_async(io_priority, Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Duplicates a #GFile handle. This operation does not duplicate
    /// the actual file or directory represented by the #GFile; see
    /// g_file_copy() if attempting to copy a file.
    ///
    /// g_file_dup() is useful when a second handle is needed to the same underlying
    /// file, for use in a separate thread (#GFile is not thread-safe). For use
    /// within the same thread, use g_object_ref() to increment the existing object’s
    /// reference count.
    ///
    /// This call does no blocking I/O.
    ///
    /// # Returns
    ///
    /// a new #GFile that is a duplicate
    ///   of the given #GFile.
    #[doc(alias = "g_file_dup")]
    #[must_use]
    fn dup(&self) -> File {
        unsafe { from_glib_full(ffi::g_file_dup(self.as_ref().to_glib_none().0)) }
    }

    /// Starts an asynchronous eject on a mountable.
    /// When this operation has completed, @callback will be called with
    /// @user_user data, and the operation can be finalized with
    /// g_file_eject_mountable_with_operation_finish().
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `flags`
    /// flags affecting the operation
    /// ## `mount_operation`
    /// a #GMountOperation,
    ///   or [`None`] to avoid user interaction
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_eject_mountable_with_operation")]
    fn eject_mountable_with_operation<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&impl IsA<MountOperation>>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn eject_mountable_with_operation_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_file_eject_mountable_with_operation_finish(
                    _source_object as *mut _,
                    res,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = eject_mountable_with_operation_trampoline::<P>;
        unsafe {
            ffi::g_file_eject_mountable_with_operation(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn eject_mountable_with_operation_future(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let mount_operation = mount_operation.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.eject_mountable_with_operation(
                    flags,
                    mount_operation.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Gets the requested information about the files in a directory.
    /// The result is a [`FileEnumerator`][crate::FileEnumerator] object that will give out
    /// [`FileInfo`][crate::FileInfo] objects for all the files in the directory.
    ///
    /// The @attributes value is a string that specifies the file
    /// attributes that should be gathered. It is not an error if
    /// it's not possible to read a particular requested attribute
    /// from a file - it just won't be set. @attributes should
    /// be a comma-separated list of attributes or attribute wildcards.
    /// The wildcard `*` means all attributes, and a wildcard like
    /// `"standard::*"` means all attributes in the standard namespace.
    /// An example attribute query be `"standard::*,owner::user"`.
    /// The standard attributes are available as defines, like
    /// `FILE_ATTRIBUTE_STANDARD_NAME`. `FILE_ATTRIBUTE_STANDARD_NAME` should
    /// always be specified if you plan to call [`FileEnumeratorExt::child()`][crate::prelude::FileEnumeratorExt::child()] or
    /// `FileEnumerator::iterate()` on the returned enumerator.
    ///
    /// If @cancellable is not `NULL`, then the operation can be cancelled
    /// by triggering the cancellable object from another thread. If the
    /// operation was cancelled, the error [error@Gio.IOErrorEnum.CANCELLED] will be
    /// returned.
    ///
    /// If the file does not exist, the [error@Gio.IOErrorEnum.NOT_FOUND] error will
    /// be returned. If the file is not a directory, the [error@Gio.IOErrorEnum.NOT_DIRECTORY]
    /// error will be returned. Other errors are possible too.
    /// ## `attributes`
    /// an attribute query string
    /// ## `flags`
    /// a set of #GFileQueryInfoFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// A #GFileEnumerator if successful,
    ///   [`None`] on error. Free the returned object with `GObject::Object::unref()`.
    #[doc(alias = "g_file_enumerate_children")]
    fn enumerate_children(
        &self,
        attributes: &str,
        flags: FileQueryInfoFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileEnumerator, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_enumerate_children(
                self.as_ref().to_glib_none().0,
                attributes.to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "g_file_equal")]
    fn equal(&self, file2: &impl IsA<File>) -> bool {
        unsafe {
            from_glib(ffi::g_file_equal(
                self.as_ref().to_glib_none().0,
                file2.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets a #GMount for the #GFile.
    ///
    /// #GMount is returned only for user interesting locations, see
    /// #GVolumeMonitor. If the #GFileIface for @self does not have a #mount,
    /// @error will be set to [`IOErrorEnum::NotFound`][crate::IOErrorEnum::NotFound] and [`None`] #will be returned.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GMount where the @self is located
    ///   or [`None`] on error.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_find_enclosing_mount")]
    fn find_enclosing_mount(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<Mount, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_find_enclosing_mount(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets the base name (the last component of the path) for a given #GFile.
    ///
    /// If called for the top level of a system (such as the filesystem root
    /// or a uri like sftp://host/) it will return a single directory separator
    /// (and on Windows, possibly a drive letter).
    ///
    /// The base name is a byte string (not UTF-8). It has no defined encoding
    /// or rules other than it may not contain zero bytes.  If you want to use
    /// filenames in a user interface you should use the display name that you
    /// can get by requesting the [`FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME`][crate::FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME]
    /// attribute with g_file_query_info().
    ///
    /// This call does no blocking I/O.
    ///
    /// # Returns
    ///
    /// string containing the #GFile's
    ///   base name, or [`None`] if given #GFile is invalid. The returned string
    ///   should be freed with g_free() when no longer needed.
    #[doc(alias = "g_file_get_basename")]
    #[doc(alias = "get_basename")]
    fn basename(&self) -> Option<std::path::PathBuf> {
        unsafe { from_glib_full(ffi::g_file_get_basename(self.as_ref().to_glib_none().0)) }
    }

    /// Gets a child of @self with basename equal to @name.
    ///
    /// Note that the file with that specific name might not exist, but
    /// you can still have a #GFile that points to it. You can use this
    /// for instance to create that file.
    ///
    /// This call does no blocking I/O.
    /// ## `name`
    /// string containing the child's basename
    ///
    /// # Returns
    ///
    /// a #GFile to a child specified by @name.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_get_child")]
    #[doc(alias = "get_child")]
    #[must_use]
    fn child(&self, name: impl AsRef<std::path::Path>) -> File {
        unsafe {
            from_glib_full(ffi::g_file_get_child(
                self.as_ref().to_glib_none().0,
                name.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the child of @self for a given @display_name (i.e. a UTF-8
    /// version of the name). If this function fails, it returns [`None`]
    /// and @error will be set. This is very useful when constructing a
    /// #GFile for a new file and the user entered the filename in the
    /// user interface, for instance when you select a directory and
    /// type a filename in the file selector.
    ///
    /// This call does no blocking I/O.
    /// ## `display_name`
    /// string to a possible child
    ///
    /// # Returns
    ///
    /// a #GFile to the specified child, or
    ///   [`None`] if the display name couldn't be converted.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_get_child_for_display_name")]
    #[doc(alias = "get_child_for_display_name")]
    fn child_for_display_name(&self, display_name: &str) -> Result<File, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_get_child_for_display_name(
                self.as_ref().to_glib_none().0,
                display_name.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets the parent directory for the @self.
    /// If the @self represents the root directory of the
    /// file system, then [`None`] will be returned.
    ///
    /// This call does no blocking I/O.
    ///
    /// # Returns
    ///
    /// a #GFile structure to the
    ///   parent of the given #GFile or [`None`] if there is no parent. Free
    ///   the returned object with g_object_unref().
    #[doc(alias = "g_file_get_parent")]
    #[doc(alias = "get_parent")]
    #[must_use]
    fn parent(&self) -> Option<File> {
        unsafe { from_glib_full(ffi::g_file_get_parent(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the parse name of the @self.
    /// A parse name is a UTF-8 string that describes the
    /// file such that one can get the #GFile back using
    /// g_file_parse_name().
    ///
    /// This is generally used to show the #GFile as a nice
    /// full-pathname kind of string in a user interface,
    /// like in a location entry.
    ///
    /// For local files with names that can safely be converted
    /// to UTF-8 the pathname is used, otherwise the IRI is used
    /// (a form of URI that allows UTF-8 characters unescaped).
    ///
    /// This call does no blocking I/O.
    ///
    /// # Returns
    ///
    /// a string containing the #GFile's parse name.
    ///   The returned string should be freed with g_free()
    ///   when no longer needed.
    #[doc(alias = "g_file_get_parse_name")]
    #[doc(alias = "get_parse_name")]
    fn parse_name(&self) -> glib::GString {
        unsafe { from_glib_full(ffi::g_file_get_parse_name(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the local pathname for #GFile, if one exists. If non-[`None`], this is
    /// guaranteed to be an absolute, canonical path. It might contain symlinks.
    ///
    /// This call does no blocking I/O.
    ///
    /// # Returns
    ///
    /// string containing the #GFile's path,
    ///   or [`None`] if no such path exists. The returned string should be freed
    ///   with g_free() when no longer needed.
    #[doc(alias = "g_file_get_path")]
    #[doc(alias = "get_path")]
    fn path(&self) -> Option<std::path::PathBuf> {
        unsafe { from_glib_full(ffi::g_file_get_path(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the path for @descendant relative to @self.
    ///
    /// This call does no blocking I/O.
    /// ## `descendant`
    /// input #GFile
    ///
    /// # Returns
    ///
    /// string with the relative path from
    ///   @descendant to @self, or [`None`] if @descendant doesn't have @self as
    ///   prefix. The returned string should be freed with g_free() when
    ///   no longer needed.
    #[doc(alias = "g_file_get_relative_path")]
    #[doc(alias = "get_relative_path")]
    fn relative_path(&self, descendant: &impl IsA<File>) -> Option<std::path::PathBuf> {
        unsafe {
            from_glib_full(ffi::g_file_get_relative_path(
                self.as_ref().to_glib_none().0,
                descendant.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the URI for the @self.
    ///
    /// This call does no blocking I/O.
    ///
    /// # Returns
    ///
    /// a string containing the #GFile's URI. If the #GFile was constructed
    ///   with an invalid URI, an invalid URI is returned.
    ///   The returned string should be freed with g_free()
    ///   when no longer needed.
    #[doc(alias = "g_file_get_uri")]
    #[doc(alias = "get_uri")]
    fn uri(&self) -> glib::GString {
        unsafe { from_glib_full(ffi::g_file_get_uri(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the URI scheme for a #GFile.
    /// RFC 3986 decodes the scheme as:
    ///
    /// ```text
    /// URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
    /// ```
    /// Common schemes include "file", "http", "ftp", etc.
    ///
    /// The scheme can be different from the one used to construct the #GFile,
    /// in that it might be replaced with one that is logically equivalent to the #GFile.
    ///
    /// This call does no blocking I/O.
    ///
    /// # Returns
    ///
    /// a string containing the URI scheme for the given
    ///   #GFile or [`None`] if the #GFile was constructed with an invalid URI. The
    ///   returned string should be freed with g_free() when no longer needed.
    #[doc(alias = "g_file_get_uri_scheme")]
    #[doc(alias = "get_uri_scheme")]
    fn uri_scheme(&self) -> Option<glib::GString> {
        unsafe { from_glib_full(ffi::g_file_get_uri_scheme(self.as_ref().to_glib_none().0)) }
    }

    /// Checks if @self has a parent, and optionally, if it is @parent.
    ///
    /// If @parent is [`None`] then this function returns [`true`] if @self has any
    /// parent at all.  If @parent is non-[`None`] then [`true`] is only returned
    /// if @self is an immediate child of @parent.
    /// ## `parent`
    /// the parent to check for, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if @self is an immediate child of @parent (or any parent in
    ///   the case that @parent is [`None`]).
    #[doc(alias = "g_file_has_parent")]
    fn has_parent(&self, parent: Option<&impl IsA<File>>) -> bool {
        unsafe {
            from_glib(ffi::g_file_has_parent(
                self.as_ref().to_glib_none().0,
                parent.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

    /// Checks whether @self has the prefix specified by @prefix.
    ///
    /// In other words, if the names of initial elements of @self's
    /// pathname match @prefix. Only full pathname elements are matched,
    /// so a path like /foo is not considered a prefix of /foobar, only
    /// of /foo/bar.
    ///
    /// A #GFile is not a prefix of itself. If you want to check for
    /// equality, use g_file_equal().
    ///
    /// This call does no I/O, as it works purely on names. As such it can
    /// sometimes return [`false`] even if @self is inside a @prefix (from a
    /// filesystem point of view), because the prefix of @self is an alias
    /// of @prefix.
    /// ## `prefix`
    /// input #GFile
    ///
    /// # Returns
    ///
    /// [`true`] if the @self's parent, grandparent, etc is @prefix,
    ///   [`false`] otherwise.
    #[doc(alias = "g_file_has_prefix")]
    fn has_prefix(&self, prefix: &impl IsA<File>) -> bool {
        unsafe {
            from_glib(ffi::g_file_has_prefix(
                self.as_ref().to_glib_none().0,
                prefix.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks to see if a #GFile has a given URI scheme.
    ///
    /// This call does no blocking I/O.
    /// ## `uri_scheme`
    /// a string containing a URI scheme
    ///
    /// # Returns
    ///
    /// [`true`] if #GFile's backend supports the
    ///   given URI scheme, [`false`] if URI scheme is [`None`],
    ///   not supported, or #GFile is invalid.
    #[doc(alias = "g_file_has_uri_scheme")]
    fn has_uri_scheme(&self, uri_scheme: &str) -> bool {
        unsafe {
            from_glib(ffi::g_file_has_uri_scheme(
                self.as_ref().to_glib_none().0,
                uri_scheme.to_glib_none().0,
            ))
        }
    }

    /// Checks to see if a file is native to the platform.
    ///
    /// A native file is one expressed in the platform-native filename format,
    /// e.g. "C:\Windows" or "/usr/bin/". This does not mean the file is local,
    /// as it might be on a locally mounted remote filesystem.
    ///
    /// On some systems non-native files may be available using the native
    /// filesystem via a userspace filesystem (FUSE), in these cases this call
    /// will return [`false`], but g_file_get_path() will still return a native path.
    ///
    /// This call does no blocking I/O.
    ///
    /// # Returns
    ///
    /// [`true`] if @self is native
    #[doc(alias = "g_file_is_native")]
    fn is_native(&self) -> bool {
        unsafe { from_glib(ffi::g_file_is_native(self.as_ref().to_glib_none().0)) }
    }

    /// Loads the contents of @self and returns it as #GBytes.
    ///
    /// If @self is a resource:// based URI, the resulting bytes will reference the
    /// embedded resource instead of a copy. Otherwise, this is equivalent to calling
    /// g_file_load_contents() and g_bytes_new_take().
    ///
    /// For resources, @etag_out will be set to [`None`].
    ///
    /// The data contained in the resulting #GBytes is always zero-terminated, but
    /// this is not included in the #GBytes length. The resulting #GBytes should be
    /// freed with g_bytes_unref() when no longer in use.
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    ///
    /// # Returns
    ///
    /// a #GBytes or [`None`] and @error is set
    ///
    /// ## `etag_out`
    /// a location to place the current
    ///   entity tag for the file, or [`None`] if the entity tag is not needed
    #[doc(alias = "g_file_load_bytes")]
    fn load_bytes(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(glib::Bytes, Option<glib::GString>), glib::Error> {
        unsafe {
            let mut etag_out = std::ptr::null_mut();
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_load_bytes(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut etag_out,
                &mut error,
            );
            if error.is_null() {
                Ok((from_glib_full(ret), from_glib_full(etag_out)))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously loads the contents of @self as #GBytes.
    ///
    /// If @self is a resource:// based URI, the resulting bytes will reference the
    /// embedded resource instead of a copy. Otherwise, this is equivalent to calling
    /// g_file_load_contents_async() and g_bytes_new_take().
    ///
    /// @callback should call g_file_load_bytes_finish() to get the result of this
    /// asynchronous operation.
    ///
    /// See g_file_load_bytes() for more information.
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_load_bytes_async")]
    fn load_bytes_async<
        P: FnOnce(Result<(glib::Bytes, Option<glib::GString>), glib::Error>) + 'static,
    >(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn load_bytes_async_trampoline<
            P: FnOnce(Result<(glib::Bytes, Option<glib::GString>), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let mut etag_out = std::ptr::null_mut();
                let ret = ffi::g_file_load_bytes_finish(
                    _source_object as *mut _,
                    res,
                    &mut etag_out,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok((from_glib_full(ret), from_glib_full(etag_out)))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = load_bytes_async_trampoline::<P>;
        unsafe {
            ffi::g_file_load_bytes_async(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn load_bytes_future(
        &self,
    ) -> Pin<
        Box_<
            dyn std::future::Future<
                    Output = Result<(glib::Bytes, Option<glib::GString>), glib::Error>,
                > + 'static,
        >,
    > {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.load_bytes_async(Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Creates a directory.
    ///
    /// Note that this will only create a child directory
    /// of the immediate parent directory of the path or URI given by the #GFile.
    /// To recursively create directories, see g_file_make_directory_with_parents().
    ///
    /// This function will fail if the parent directory does not exist, setting
    /// @error to [`IOErrorEnum::NotFound`][crate::IOErrorEnum::NotFound]. If the file system doesn't support
    /// creating directories, this function will fail, setting @error to
    /// [`IOErrorEnum::NotSupported`][crate::IOErrorEnum::NotSupported]. If the directory already exists,
    /// [error@Gio.IOErrorEnum.EXISTS] will be returned.
    ///
    /// For a local #GFile the newly created directory will have the default
    /// (current) ownership and permissions of the current process.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] on successful creation, [`false`] otherwise.
    #[doc(alias = "g_file_make_directory")]
    fn make_directory(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_file_make_directory(
                self.as_ref().to_glib_none().0,
                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))
            }
        }
    }

    /// Asynchronously creates a directory.
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call
    ///   when the request is satisfied
    #[doc(alias = "g_file_make_directory_async")]
    fn make_directory_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn make_directory_async_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_file_make_directory_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = make_directory_async_trampoline::<P>;
        unsafe {
            ffi::g_file_make_directory_async(
                self.as_ref().to_glib_none().0,
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn make_directory_future(
        &self,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.make_directory_async(io_priority, Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Creates a directory and any parent directories that may not
    /// exist similar to 'mkdir -p'. If the file system does not support
    /// creating directories, this function will fail, setting @error to
    /// [`IOErrorEnum::NotSupported`][crate::IOErrorEnum::NotSupported]. If the directory itself already exists,
    /// this function will fail setting @error to [`IOErrorEnum::Exists`][crate::IOErrorEnum::Exists], unlike
    /// the similar g_mkdir_with_parents().
    ///
    /// For a local #GFile the newly created directories will have the default
    /// (current) ownership and permissions of the current process.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] if all directories have been successfully created, [`false`]
    /// otherwise.
    #[doc(alias = "g_file_make_directory_with_parents")]
    fn make_directory_with_parents(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_file_make_directory_with_parents(
                self.as_ref().to_glib_none().0,
                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))
            }
        }
    }

    /// Creates a symbolic link named @self which contains the string
    /// @symlink_value.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `symlink_value`
    /// a string with the path for the target
    ///   of the new symlink
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] on the creation of a new symlink, [`false`] otherwise.
    #[doc(alias = "g_file_make_symbolic_link")]
    fn make_symbolic_link(
        &self,
        symlink_value: impl AsRef<std::path::Path>,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_file_make_symbolic_link(
                self.as_ref().to_glib_none().0,
                symlink_value.as_ref().to_glib_none().0,
                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))
            }
        }
    }

    /// Recursively measures the disk usage of @self.
    ///
    /// This is essentially an analog of the 'du' command, but it also
    /// reports the number of directories and non-directory files encountered
    /// (including things like symbolic links).
    ///
    /// By default, errors are only reported against the toplevel file
    /// itself.  Errors found while recursing are silently ignored, unless
    /// [`FileMeasureFlags::REPORT_ANY_ERROR`][crate::FileMeasureFlags::REPORT_ANY_ERROR] is given in @flags.
    ///
    /// The returned size, @disk_usage, is in bytes and should be formatted
    /// with g_format_size() in order to get something reasonable for showing
    /// in a user interface.
    ///
    /// @progress_callback and @progress_data can be given to request
    /// periodic progress updates while scanning.  See the documentation for
    /// #GFileMeasureProgressCallback for information about when and how the
    /// callback will be invoked.
    /// ## `flags`
    /// #GFileMeasureFlags
    /// ## `cancellable`
    /// optional #GCancellable
    /// ## `progress_callback`
    /// a #GFileMeasureProgressCallback
    /// ## `progress_data`
    /// user_data for @progress_callback
    ///
    /// # Returns
    ///
    /// [`true`] if successful, with the out parameters set.
    ///   [`false`] otherwise, with @error set.
    ///
    /// ## `disk_usage`
    /// the number of bytes of disk space used
    ///
    /// ## `num_dirs`
    /// the number of directories encountered
    ///
    /// ## `num_files`
    /// the number of non-directories encountered
    #[doc(alias = "g_file_measure_disk_usage")]
    fn measure_disk_usage(
        &self,
        flags: FileMeasureFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
        progress_callback: Option<&mut dyn FnMut(bool, u64, u64, u64)>,
    ) -> Result<(u64, u64, u64), glib::Error> {
        let mut progress_callback_data: Option<&mut dyn FnMut(bool, u64, u64, u64)> =
            progress_callback;
        unsafe extern "C" fn progress_callback_func(
            reporting: glib::ffi::gboolean,
            current_size: u64,
            num_dirs: u64,
            num_files: u64,
            data: glib::ffi::gpointer,
        ) {
            unsafe {
                let reporting = from_glib(reporting);
                let callback = data as *mut Option<&mut dyn FnMut(bool, u64, u64, u64)>;
                if let Some(ref mut callback) = *callback {
                    callback(reporting, current_size, num_dirs, num_files)
                } else {
                    panic!("cannot get closure...")
                }
            }
        }
        let progress_callback = if progress_callback_data.is_some() {
            Some(progress_callback_func as _)
        } else {
            None
        };
        let super_callback0: &mut Option<&mut dyn FnMut(bool, u64, u64, u64)> =
            &mut progress_callback_data;
        unsafe {
            let mut disk_usage = std::mem::MaybeUninit::uninit();
            let mut num_dirs = std::mem::MaybeUninit::uninit();
            let mut num_files = std::mem::MaybeUninit::uninit();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_file_measure_disk_usage(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                progress_callback,
                super_callback0 as *mut _ as *mut _,
                disk_usage.as_mut_ptr(),
                num_dirs.as_mut_ptr(),
                num_files.as_mut_ptr(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok((
                    disk_usage.assume_init(),
                    num_dirs.assume_init(),
                    num_files.assume_init(),
                ))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Obtains a file or directory monitor for the given file,
    /// depending on the type of the file.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `flags`
    /// a set of #GFileMonitorFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GFileMonitor for the given @self,
    ///   or [`None`] on error.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_monitor")]
    fn monitor(
        &self,
        flags: FileMonitorFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileMonitor, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_monitor(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Obtains a directory monitor for the given file.
    /// This may fail if directory monitoring is not supported.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    ///
    /// It does not make sense for @flags to contain
    /// [`FileMonitorFlags::WATCH_HARD_LINKS`][crate::FileMonitorFlags::WATCH_HARD_LINKS], since hard links can not be made to
    /// directories.  It is not possible to monitor all the files in a
    /// directory for changes made via hard links; if you want to do this then
    /// you must register individual watches with g_file_monitor().
    /// ## `flags`
    /// a set of #GFileMonitorFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GFileMonitor for the given @self,
    ///   or [`None`] on error. Free the returned object with g_object_unref().
    #[doc(alias = "g_file_monitor_directory")]
    fn monitor_directory(
        &self,
        flags: FileMonitorFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileMonitor, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_monitor_directory(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Obtains a file monitor for the given file. If no file notification
    /// mechanism exists, then regular polling of the file is used.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    ///
    /// If @flags contains [`FileMonitorFlags::WATCH_HARD_LINKS`][crate::FileMonitorFlags::WATCH_HARD_LINKS] then the monitor
    /// will also attempt to report changes made to the file via another
    /// filename (ie, a hard link). Without this flag, you can only rely on
    /// changes made through the filename contained in @self to be
    /// reported. Using this flag may result in an increase in resource
    /// usage, and may not have any effect depending on the #GFileMonitor
    /// backend and/or filesystem type.
    /// ## `flags`
    /// a set of #GFileMonitorFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GFileMonitor for the given @self,
    ///   or [`None`] on error.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_monitor_file")]
    fn monitor_file(
        &self,
        flags: FileMonitorFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileMonitor, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_monitor_file(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Starts a @mount_operation, mounting the volume that contains
    /// the file @self.
    ///
    /// When this operation has completed, @callback will be called with
    /// @user_user data, and the operation can be finalized with
    /// g_file_mount_enclosing_volume_finish().
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `flags`
    /// flags affecting the operation
    /// ## `mount_operation`
    /// a #GMountOperation
    ///   or [`None`] to avoid user interaction
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call
    ///   when the request is satisfied, or [`None`]
    #[doc(alias = "g_file_mount_enclosing_volume")]
    fn mount_enclosing_volume<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        flags: MountMountFlags,
        mount_operation: Option<&impl IsA<MountOperation>>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn mount_enclosing_volume_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_file_mount_enclosing_volume_finish(
                    _source_object as *mut _,
                    res,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = mount_enclosing_volume_trampoline::<P>;
        unsafe {
            ffi::g_file_mount_enclosing_volume(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn mount_enclosing_volume_future(
        &self,
        flags: MountMountFlags,
        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let mount_operation = mount_operation.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.mount_enclosing_volume(
                    flags,
                    mount_operation.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Mounts a file of type G_FILE_TYPE_MOUNTABLE.
    /// Using @mount_operation, you can request callbacks when, for instance,
    /// passwords are needed during authentication.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_mount_mountable_finish() to get
    /// the result of the operation.
    /// ## `flags`
    /// flags affecting the operation
    /// ## `mount_operation`
    /// a #GMountOperation,
    ///   or [`None`] to avoid user interaction
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_mount_mountable")]
    fn mount_mountable<P: FnOnce(Result<File, glib::Error>) + 'static>(
        &self,
        flags: MountMountFlags,
        mount_operation: Option<&impl IsA<MountOperation>>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn mount_mountable_trampoline<
            P: FnOnce(Result<File, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret =
                    ffi::g_file_mount_mountable_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = mount_mountable_trampoline::<P>;
        unsafe {
            ffi::g_file_mount_mountable(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn mount_mountable_future(
        &self,
        flags: MountMountFlags,
        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<File, glib::Error>> + 'static>> {
        let mount_operation = mount_operation.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.mount_mountable(
                    flags,
                    mount_operation.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Tries to move the file or directory @self to the location specified
    /// by @destination. If native move operations are supported then this is
    /// used, otherwise a copy + delete fallback is used. The native
    /// implementation may support moving directories (for instance on moves
    /// inside the same filesystem), but the fallback code does not.
    ///
    /// If the flag [`FileCopyFlags::OVERWRITE`][crate::FileCopyFlags::OVERWRITE] is specified an already
    /// existing @destination file is overwritten.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    ///
    /// If @progress_callback is not [`None`], then the operation can be monitored
    /// by setting this to a #GFileProgressCallback function.
    /// @progress_callback_data will be passed to this function. It is
    /// guaranteed that this callback will be called after all data has been
    /// transferred with the total number of bytes copied during the operation.
    ///
    /// If the @self file does not exist, then the [`IOErrorEnum::NotFound`][crate::IOErrorEnum::NotFound]
    /// error is returned, independent on the status of the @destination.
    ///
    /// If [`FileCopyFlags::OVERWRITE`][crate::FileCopyFlags::OVERWRITE] is not specified and the target exists,
    /// then the error [`IOErrorEnum::Exists`][crate::IOErrorEnum::Exists] is returned.
    ///
    /// If trying to overwrite a file over a directory, the [`IOErrorEnum::IsDirectory`][crate::IOErrorEnum::IsDirectory]
    /// error is returned. If trying to overwrite a directory with a directory the
    /// [`IOErrorEnum::WouldMerge`][crate::IOErrorEnum::WouldMerge] error is returned.
    ///
    /// If the source is a directory and the target does not exist, or
    /// [`FileCopyFlags::OVERWRITE`][crate::FileCopyFlags::OVERWRITE] is specified and the target is a file, then
    /// the [`IOErrorEnum::WouldRecurse`][crate::IOErrorEnum::WouldRecurse] error may be returned (if the native
    /// move operation isn't available).
    /// ## `destination`
    /// #GFile pointing to the destination location
    /// ## `flags`
    /// set of #GFileCopyFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `progress_callback`
    /// #GFileProgressCallback
    ///   function for updates
    /// ## `progress_callback_data`
    /// gpointer to user data for
    ///   the callback function
    ///
    /// # Returns
    ///
    /// [`true`] on successful move, [`false`] otherwise.
    #[doc(alias = "g_file_move")]
    #[doc(alias = "move")]
    fn move_(
        &self,
        destination: &impl IsA<File>,
        flags: FileCopyFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
        progress_callback: Option<&mut dyn FnMut(i64, i64)>,
    ) -> Result<(), glib::Error> {
        let mut progress_callback_data: Option<&mut dyn FnMut(i64, i64)> = progress_callback;
        unsafe extern "C" fn progress_callback_func(
            current_num_bytes: i64,
            total_num_bytes: i64,
            data: glib::ffi::gpointer,
        ) {
            unsafe {
                let callback = data as *mut Option<&mut dyn FnMut(i64, i64)>;
                if let Some(ref mut callback) = *callback {
                    callback(current_num_bytes, total_num_bytes)
                } else {
                    panic!("cannot get closure...")
                }
            }
        }
        let progress_callback = if progress_callback_data.is_some() {
            Some(progress_callback_func as _)
        } else {
            None
        };
        let super_callback0: &mut Option<&mut dyn FnMut(i64, i64)> = &mut progress_callback_data;
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_file_move(
                self.as_ref().to_glib_none().0,
                destination.as_ref().to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                progress_callback,
                super_callback0 as *mut _ as *mut _,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Opens an existing file for reading and writing. The result is
    /// a #GFileIOStream that can be used to read and write the contents
    /// of the file.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled
    /// by triggering the cancellable object from another thread. If the
    /// operation was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be
    /// returned.
    ///
    /// If the file does not exist, the [`IOErrorEnum::NotFound`][crate::IOErrorEnum::NotFound] error will
    /// be returned. If the file is a directory, the [`IOErrorEnum::IsDirectory`][crate::IOErrorEnum::IsDirectory]
    /// error will be returned. Other errors are possible too, and depend on
    /// what kind of filesystem the file is on. Note that in many non-local
    /// file cases read and write streams are not supported, so make sure you
    /// really need to do read and write streaming, rather than just opening
    /// for reading or writing.
    /// ## `cancellable`
    /// a #GCancellable
    ///
    /// # Returns
    ///
    /// #GFileIOStream or [`None`] on error.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_open_readwrite")]
    fn open_readwrite(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileIOStream, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_open_readwrite(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously opens @self for reading and writing.
    ///
    /// For more details, see g_file_open_readwrite() which is
    /// the synchronous version of this call.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_open_readwrite_finish() to get
    /// the result of the operation.
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_open_readwrite_async")]
    fn open_readwrite_async<P: FnOnce(Result<FileIOStream, glib::Error>) + 'static>(
        &self,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn open_readwrite_async_trampoline<
            P: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret =
                    ffi::g_file_open_readwrite_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = open_readwrite_async_trampoline::<P>;
        unsafe {
            ffi::g_file_open_readwrite_async(
                self.as_ref().to_glib_none().0,
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn open_readwrite_future(
        &self,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileIOStream, glib::Error>> + 'static>>
    {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.open_readwrite_async(io_priority, Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Exactly like g_file_get_path(), but caches the result via
    /// g_object_set_qdata_full().  This is useful for example in C
    /// applications which mix `g_file_*` APIs with native ones.  It
    /// also avoids an extra duplicated string when possible, so will be
    /// generally more efficient.
    ///
    /// This call does no blocking I/O.
    ///
    /// # Returns
    ///
    /// string containing the #GFile's path,
    ///   or [`None`] if no such path exists. The returned string is owned by @self.
    #[doc(alias = "g_file_peek_path")]
    fn peek_path(&self) -> Option<std::path::PathBuf> {
        unsafe { from_glib_none(ffi::g_file_peek_path(self.as_ref().to_glib_none().0)) }
    }

    /// Polls a file of type [`FileType::Mountable`][crate::FileType::Mountable].
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_mount_mountable_finish() to get
    /// the result of the operation.
    /// ## `cancellable`
    /// optional #GCancellable object, [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call
    ///   when the request is satisfied, or [`None`]
    #[doc(alias = "g_file_poll_mountable")]
    fn poll_mountable<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn poll_mountable_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_file_poll_mountable_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = poll_mountable_trampoline::<P>;
        unsafe {
            ffi::g_file_poll_mountable(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn poll_mountable_future(
        &self,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.poll_mountable(Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Returns the #GAppInfo that is registered as the default
    /// application to handle the file specified by @self.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `cancellable`
    /// optional #GCancellable object, [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GAppInfo if the handle was found,
    ///   [`None`] if there were errors.
    ///   When you are done with it, release it with g_object_unref()
    #[doc(alias = "g_file_query_default_handler")]
    fn query_default_handler(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<AppInfo, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_query_default_handler(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Async version of g_file_query_default_handler().
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object, [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is done
    #[cfg(feature = "v2_60")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
    #[doc(alias = "g_file_query_default_handler_async")]
    fn query_default_handler_async<P: FnOnce(Result<AppInfo, glib::Error>) + 'static>(
        &self,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn query_default_handler_async_trampoline<
            P: FnOnce(Result<AppInfo, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::g_file_query_default_handler_finish(
                    _source_object as *mut _,
                    res,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = query_default_handler_async_trampoline::<P>;
        unsafe {
            ffi::g_file_query_default_handler_async(
                self.as_ref().to_glib_none().0,
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    #[cfg(feature = "v2_60")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
    fn query_default_handler_future(
        &self,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<AppInfo, glib::Error>> + 'static>> {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.query_default_handler_async(io_priority, Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Utility function to check if a particular file exists.
    ///
    /// The fallback implementation of this API is using [`query_info()`][Self::query_info()]
    /// and therefore may do blocking I/O. To asynchronously query the existence
    /// of a file, use [`query_info_async()`][Self::query_info_async()].
    ///
    /// Note that in many cases it is [racy to first check for file existence](https://en.wikipedia.org/wiki/Time_of_check_to_time_of_use)
    /// and then execute something based on the outcome of that, because the
    /// file might have been created or removed in between the operations. The
    /// general approach to handling that is to not check, but just do the
    /// operation and handle the errors as they come.
    ///
    /// As an example of race-free checking, take the case of reading a file,
    /// and if it doesn't exist, creating it. There are two racy versions: read
    /// it, and on error create it; and: check if it exists, if not create it.
    /// These can both result in two processes creating the file (with perhaps
    /// a partially written file as the result). The correct approach is to
    /// always try to create the file with g_file_create() which will either
    /// atomically create the file or fail with a [`IOErrorEnum::Exists`][crate::IOErrorEnum::Exists] error.
    ///
    /// However, in many cases an existence check is useful in a user interface,
    /// for instance to make a menu item sensitive/insensitive, so that you don't
    /// have to fool users that something is possible and then just show an error
    /// dialog. If you do this, you should make sure to also handle the errors
    /// that can happen due to races when you execute the operation.
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] if the file exists (and can be detected without error),
    ///   [`false`] otherwise (or if cancelled).
    #[doc(alias = "g_file_query_exists")]
    fn query_exists(&self, cancellable: Option<&impl IsA<Cancellable>>) -> bool {
        unsafe {
            from_glib(ffi::g_file_query_exists(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

    /// Utility function to inspect the #GFileType of a file. This is
    /// implemented using g_file_query_info() and as such does blocking I/O.
    ///
    /// The primary use case of this method is to check if a file is
    /// a regular file, directory, or symlink.
    /// ## `flags`
    /// a set of #GFileQueryInfoFlags passed to g_file_query_info()
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// The #GFileType of the file and [`FileType::Unknown`][crate::FileType::Unknown]
    ///   if the file does not exist
    #[doc(alias = "g_file_query_file_type")]
    fn query_file_type(
        &self,
        flags: FileQueryInfoFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> FileType {
        unsafe {
            from_glib(ffi::g_file_query_file_type(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

    /// Similar to g_file_query_info(), but obtains information
    /// about the filesystem the @self is on, rather than the file itself.
    /// For instance the amount of space available and the type of
    /// the filesystem.
    ///
    /// The @attributes value is a string that specifies the attributes
    /// that should be gathered. It is not an error if it's not possible
    /// to read a particular requested attribute from a file - it just
    /// won't be set. @attributes should be a comma-separated list of
    /// attributes or attribute wildcards. The wildcard "\*" means all
    /// attributes, and a wildcard like "filesystem::*" means all attributes
    /// in the filesystem namespace. The standard namespace for filesystem
    /// attributes is "filesystem". Common attributes of interest are
    /// [`FILE_ATTRIBUTE_FILESYSTEM_SIZE`][crate::FILE_ATTRIBUTE_FILESYSTEM_SIZE] (the total size of the filesystem
    /// in bytes), [`FILE_ATTRIBUTE_FILESYSTEM_FREE`][crate::FILE_ATTRIBUTE_FILESYSTEM_FREE] (number of bytes available),
    /// and [`FILE_ATTRIBUTE_FILESYSTEM_TYPE`][crate::FILE_ATTRIBUTE_FILESYSTEM_TYPE] (type of the filesystem).
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled
    /// by triggering the cancellable object from another thread. If the
    /// operation was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be
    /// returned.
    ///
    /// If the file does not exist, the [`IOErrorEnum::NotFound`][crate::IOErrorEnum::NotFound] error will
    /// be returned. Other errors are possible too, and depend on what
    /// kind of filesystem the file is on.
    /// ## `attributes`
    /// an attribute query string
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GFileInfo or [`None`] if there was an error.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_query_filesystem_info")]
    fn query_filesystem_info(
        &self,
        attributes: &str,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileInfo, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_query_filesystem_info(
                self.as_ref().to_glib_none().0,
                attributes.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously gets the requested information about the filesystem
    /// that the specified @self is on. The result is a #GFileInfo object
    /// that contains key-value attributes (such as type or size for the
    /// file).
    ///
    /// For more details, see g_file_query_filesystem_info() which is the
    /// synchronous version of this call.
    ///
    /// When the operation is finished, @callback will be called. You can
    /// then call g_file_query_info_finish() to get the result of the
    /// operation.
    /// ## `attributes`
    /// an attribute query string
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_query_filesystem_info_async")]
    fn query_filesystem_info_async<P: FnOnce(Result<FileInfo, glib::Error>) + 'static>(
        &self,
        attributes: &str,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn query_filesystem_info_async_trampoline<
            P: FnOnce(Result<FileInfo, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::g_file_query_filesystem_info_finish(
                    _source_object as *mut _,
                    res,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = query_filesystem_info_async_trampoline::<P>;
        unsafe {
            ffi::g_file_query_filesystem_info_async(
                self.as_ref().to_glib_none().0,
                attributes.to_glib_none().0,
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn query_filesystem_info_future(
        &self,
        attributes: &str,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileInfo, glib::Error>> + 'static>> {
        let attributes = String::from(attributes);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.query_filesystem_info_async(
                    &attributes,
                    io_priority,
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Gets the requested information about specified @self.
    ///
    /// The result is a [`FileInfo`][crate::FileInfo] object that contains key-value
    /// attributes (such as the type or size of the file).
    ///
    /// The @attributes value is a string that specifies the file
    /// attributes that should be gathered. It is not an error if
    /// it’s not possible to read a particular requested attribute
    /// from a file — it just won't be set. In particular this means that if a file
    /// is inaccessible (due to being in a folder with restrictive permissions), for
    /// example, you can expect the returned [`FileInfo`][crate::FileInfo] to have very few
    /// attributes set. You should check whether an attribute is set using
    /// [`FileInfo::has_attribute()`][crate::FileInfo::has_attribute()] before trying to retrieve its value.
    ///
    /// It is guaranteed that if any of the following attributes are listed in
    /// @attributes, they will always be set in the returned [`FileInfo`][crate::FileInfo],
    /// even if the user doesn’t have permissions to access the file:
    ///
    ///  - `Gio::FILE_ATTRIBUTE_STANDARD_NAME`
    ///  - `Gio::FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME`
    ///
    /// @attributes should be a comma-separated list of attributes or attribute
    /// wildcards. The wildcard `"\*"` means all attributes, and a wildcard like
    /// `"standard::*"` means all attributes in the standard namespace.
    /// An example attribute query might be `"standard::*,owner::user"`.
    /// The standard attributes are available as defines, like
    /// `Gio::FILE_ATTRIBUTE_STANDARD_NAME`.
    ///
    /// If @cancellable is not `NULL`, then the operation can be cancelled
    /// by triggering the cancellable object from another thread. If the
    /// operation was cancelled, the error [error@Gio.IOErrorEnum.CANCELLED] will be
    /// returned.
    ///
    /// For symlinks, normally the information about the target of the
    /// symlink is returned, rather than information about the symlink
    /// itself. However if you pass [flags@Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS]
    /// in @flags the information about the symlink itself will be returned.
    /// Also, for symlinks that point to non-existing files the information
    /// about the symlink itself will be returned.
    ///
    /// If the file does not exist, the [error@Gio.IOErrorEnum.NOT_FOUND] error will be
    /// returned. Other errors are possible too, and depend on what kind of
    /// file system the file is on.
    /// ## `attributes`
    /// an attribute query string
    /// ## `flags`
    /// flags to affect the query operation
    /// ## `cancellable`
    /// optional cancellable object
    ///
    /// # Returns
    ///
    /// a [`FileInfo`][crate::FileInfo] for the given @self
    #[doc(alias = "g_file_query_info")]
    fn query_info(
        &self,
        attributes: &str,
        flags: FileQueryInfoFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileInfo, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_query_info(
                self.as_ref().to_glib_none().0,
                attributes.to_glib_none().0,
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously gets the requested information about specified @self.
    /// The result is a #GFileInfo object that contains key-value attributes
    /// (such as type or size for the file).
    ///
    /// For more details, see g_file_query_info() which is the synchronous
    /// version of this call.
    ///
    /// When the operation is finished, @callback will be called. You can
    /// then call g_file_query_info_finish() to get the result of the operation.
    /// ## `attributes`
    /// an attribute query string
    /// ## `flags`
    /// a set of #GFileQueryInfoFlags
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_query_info_async")]
    fn query_info_async<P: FnOnce(Result<FileInfo, glib::Error>) + 'static>(
        &self,
        attributes: &str,
        flags: FileQueryInfoFlags,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn query_info_async_trampoline<
            P: FnOnce(Result<FileInfo, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::g_file_query_info_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = query_info_async_trampoline::<P>;
        unsafe {
            ffi::g_file_query_info_async(
                self.as_ref().to_glib_none().0,
                attributes.to_glib_none().0,
                flags.into_glib(),
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn query_info_future(
        &self,
        attributes: &str,
        flags: FileQueryInfoFlags,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileInfo, glib::Error>> + 'static>> {
        let attributes = String::from(attributes);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.query_info_async(
                    &attributes,
                    flags,
                    io_priority,
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Obtain the list of settable attributes for the file.
    ///
    /// Returns the type and full attribute name of all the attributes
    /// that can be set on this file. This doesn't mean setting it will
    /// always succeed though, you might get an access failure, or some
    /// specific file may not support a specific attribute.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GFileAttributeInfoList describing the settable attributes.
    ///   When you are done with it, release it with
    ///   g_file_attribute_info_list_unref()
    #[doc(alias = "g_file_query_settable_attributes")]
    fn query_settable_attributes(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileAttributeInfoList, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_query_settable_attributes(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Obtain the list of attribute namespaces where new attributes
    /// can be created by a user. An example of this is extended
    /// attributes (in the "xattr" namespace).
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GFileAttributeInfoList describing the writable namespaces.
    ///   When you are done with it, release it with
    ///   g_file_attribute_info_list_unref()
    #[doc(alias = "g_file_query_writable_namespaces")]
    fn query_writable_namespaces(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileAttributeInfoList, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_query_writable_namespaces(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Opens a file for reading. The result is a #GFileInputStream that
    /// can be used to read the contents of the file.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    ///
    /// If the file does not exist, the [`IOErrorEnum::NotFound`][crate::IOErrorEnum::NotFound] error will be
    /// returned. If the file is a directory, the [`IOErrorEnum::IsDirectory`][crate::IOErrorEnum::IsDirectory]
    /// error will be returned. Other errors are possible too, and depend
    /// on what kind of filesystem the file is on.
    /// ## `cancellable`
    /// a #GCancellable
    ///
    /// # Returns
    ///
    /// #GFileInputStream or [`None`] on error.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_read")]
    fn read(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileInputStream, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_read(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously opens @self for reading.
    ///
    /// For more details, see g_file_read() which is
    /// the synchronous version of this call.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_read_finish() to get the result
    /// of the operation.
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_read_async")]
    fn read_async<P: FnOnce(Result<FileInputStream, glib::Error>) + 'static>(
        &self,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn read_async_trampoline<
            P: FnOnce(Result<FileInputStream, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::g_file_read_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = read_async_trampoline::<P>;
        unsafe {
            ffi::g_file_read_async(
                self.as_ref().to_glib_none().0,
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn read_future(
        &self,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileInputStream, glib::Error>> + 'static>>
    {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.read_async(io_priority, Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Returns an output stream for overwriting the file, possibly
    /// creating a backup copy of the file first. If the file doesn't exist,
    /// it will be created.
    ///
    /// This will try to replace the file in the safest way possible so
    /// that any errors during the writing will not affect an already
    /// existing copy of the file. For instance, for local files it
    /// may write to a temporary file and then atomically rename over
    /// the destination when the stream is closed.
    ///
    /// By default files created are generally readable by everyone,
    /// but if you pass [`FileCreateFlags::PRIVATE`][crate::FileCreateFlags::PRIVATE] in @flags the file
    /// will be made readable only to the current user, to the level that
    /// is supported on the target filesystem.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled
    /// by triggering the cancellable object from another thread. If the
    /// operation was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be
    /// returned.
    ///
    /// If you pass in a non-[`None`] @etag value and @self already exists, then
    /// this value is compared to the current entity tag of the file, and if
    /// they differ an [`IOErrorEnum::WrongEtag`][crate::IOErrorEnum::WrongEtag] error is returned. This
    /// generally means that the file has been changed since you last read
    /// it. You can get the new etag from g_file_output_stream_get_etag()
    /// after you've finished writing and closed the #GFileOutputStream. When
    /// you load a new file you can use g_file_input_stream_query_info() to
    /// get the etag of the file.
    ///
    /// If @make_backup is [`true`], this function will attempt to make a
    /// backup of the current file before overwriting it. If this fails
    /// a [`IOErrorEnum::CantCreateBackup`][crate::IOErrorEnum::CantCreateBackup] error will be returned. If you
    /// want to replace anyway, try again with @make_backup set to [`false`].
    ///
    /// If the file is a directory the [`IOErrorEnum::IsDirectory`][crate::IOErrorEnum::IsDirectory] error will
    /// be returned, and if the file is some other form of non-regular file
    /// then a [`IOErrorEnum::NotRegularFile`][crate::IOErrorEnum::NotRegularFile] error will be returned. Some
    /// file systems don't allow all file names, and may return an
    /// [`IOErrorEnum::InvalidFilename`][crate::IOErrorEnum::InvalidFilename] error, and if the name is to long
    /// [`IOErrorEnum::FilenameTooLong`][crate::IOErrorEnum::FilenameTooLong] will be returned. Other errors are
    /// possible too, and depend on what kind of filesystem the file is on.
    /// ## `etag`
    /// an optional [entity tag](#entity-tags)
    ///   for the current #GFile, or #NULL to ignore
    /// ## `make_backup`
    /// [`true`] if a backup should be created
    /// ## `flags`
    /// a set of #GFileCreateFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GFileOutputStream or [`None`] on error.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_replace")]
    fn replace(
        &self,
        etag: Option<&str>,
        make_backup: bool,
        flags: FileCreateFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileOutputStream, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_replace(
                self.as_ref().to_glib_none().0,
                etag.to_glib_none().0,
                make_backup.into_glib(),
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously overwrites the file, replacing the contents,
    /// possibly creating a backup copy of the file first.
    ///
    /// For more details, see g_file_replace() which is
    /// the synchronous version of this call.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_replace_finish() to get the result
    /// of the operation.
    /// ## `etag`
    /// an [entity tag](#entity-tags) for the current #GFile,
    ///   or [`None`] to ignore
    /// ## `make_backup`
    /// [`true`] if a backup should be created
    /// ## `flags`
    /// a set of #GFileCreateFlags
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_replace_async")]
    fn replace_async<P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static>(
        &self,
        etag: Option<&str>,
        make_backup: bool,
        flags: FileCreateFlags,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn replace_async_trampoline<
            P: FnOnce(Result<FileOutputStream, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::g_file_replace_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = replace_async_trampoline::<P>;
        unsafe {
            ffi::g_file_replace_async(
                self.as_ref().to_glib_none().0,
                etag.to_glib_none().0,
                make_backup.into_glib(),
                flags.into_glib(),
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn replace_future(
        &self,
        etag: Option<&str>,
        make_backup: bool,
        flags: FileCreateFlags,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileOutputStream, glib::Error>> + 'static>>
    {
        let etag = etag.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.replace_async(
                    etag.as_ref().map(::std::borrow::Borrow::borrow),
                    make_backup,
                    flags,
                    io_priority,
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Replaces the contents of @self with @contents of @length bytes.
    ///
    /// If @etag is specified (not [`None`]), any existing file must have that etag,
    /// or the error [`IOErrorEnum::WrongEtag`][crate::IOErrorEnum::WrongEtag] will be returned.
    ///
    /// If @make_backup is [`true`], this function will attempt to make a backup
    /// of @self. Internally, it uses g_file_replace(), so will try to replace the
    /// file contents in the safest way possible. For example, atomic renames are
    /// used when replacing local files’ contents.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    ///
    /// The returned @new_etag can be used to verify that the file hasn't
    /// changed the next time it is saved over.
    /// ## `contents`
    /// a string containing the new contents for @self
    /// ## `etag`
    /// the old [entity-tag](#entity-tags) for the document,
    ///   or [`None`]
    /// ## `make_backup`
    /// [`true`] if a backup should be created
    /// ## `flags`
    /// a set of #GFileCreateFlags
    /// ## `cancellable`
    /// optional #GCancellable object, [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] if successful. If an error has occurred, this function
    ///   will return [`false`] and set @error appropriately if present.
    ///
    /// ## `new_etag`
    /// a location to a new [entity tag](#entity-tags)
    ///   for the document. This should be freed with g_free() when no longer
    ///   needed, or [`None`]
    #[doc(alias = "g_file_replace_contents")]
    fn replace_contents(
        &self,
        contents: &[u8],
        etag: Option<&str>,
        make_backup: bool,
        flags: FileCreateFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<Option<glib::GString>, glib::Error> {
        let length = contents.len() as _;
        unsafe {
            let mut new_etag = std::ptr::null_mut();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_file_replace_contents(
                self.as_ref().to_glib_none().0,
                contents.to_glib_none().0,
                length,
                etag.to_glib_none().0,
                make_backup.into_glib(),
                flags.into_glib(),
                &mut new_etag,
                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(from_glib_full(new_etag))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Same as g_file_replace_contents_async() but takes a #GBytes input instead.
    /// This function will keep a ref on @contents until the operation is done.
    /// Unlike g_file_replace_contents_async() this allows forgetting about the
    /// content without waiting for the callback.
    ///
    /// When this operation has completed, @callback will be called with
    /// @user_user data, and the operation can be finalized with
    /// g_file_replace_contents_finish().
    /// ## `contents`
    /// a #GBytes
    /// ## `etag`
    /// a new [entity tag](#entity-tags) for the @self, or [`None`]
    /// ## `make_backup`
    /// [`true`] if a backup should be created
    /// ## `flags`
    /// a set of #GFileCreateFlags
    /// ## `cancellable`
    /// optional #GCancellable object, [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is satisfied
    #[doc(alias = "g_file_replace_contents_bytes_async")]
    fn replace_contents_bytes_async<
        P: FnOnce(Result<Option<glib::GString>, glib::Error>) + 'static,
    >(
        &self,
        contents: &glib::Bytes,
        etag: Option<&str>,
        make_backup: bool,
        flags: FileCreateFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn replace_contents_bytes_async_trampoline<
            P: FnOnce(Result<Option<glib::GString>, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let mut new_etag = std::ptr::null_mut();
                ffi::g_file_replace_contents_finish(
                    _source_object as *mut _,
                    res,
                    &mut new_etag,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok(from_glib_full(new_etag))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = replace_contents_bytes_async_trampoline::<P>;
        unsafe {
            ffi::g_file_replace_contents_bytes_async(
                self.as_ref().to_glib_none().0,
                contents.to_glib_none().0,
                etag.to_glib_none().0,
                make_backup.into_glib(),
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn replace_contents_bytes_future(
        &self,
        contents: &glib::Bytes,
        etag: Option<&str>,
        make_backup: bool,
        flags: FileCreateFlags,
    ) -> Pin<
        Box_<
            dyn std::future::Future<Output = Result<Option<glib::GString>, glib::Error>> + 'static,
        >,
    > {
        let contents = contents.clone();
        let etag = etag.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.replace_contents_bytes_async(
                    &contents,
                    etag.as_ref().map(::std::borrow::Borrow::borrow),
                    make_backup,
                    flags,
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Returns an output stream for overwriting the file in readwrite mode,
    /// possibly creating a backup copy of the file first. If the file doesn't
    /// exist, it will be created.
    ///
    /// For details about the behaviour, see g_file_replace() which does the
    /// same thing but returns an output stream only.
    ///
    /// Note that in many non-local file cases read and write streams are not
    /// supported, so make sure you really need to do read and write streaming,
    /// rather than just opening for reading or writing.
    /// ## `etag`
    /// an optional [entity tag](#entity-tags)
    ///   for the current #GFile, or #NULL to ignore
    /// ## `make_backup`
    /// [`true`] if a backup should be created
    /// ## `flags`
    /// a set of #GFileCreateFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GFileIOStream or [`None`] on error.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_replace_readwrite")]
    fn replace_readwrite(
        &self,
        etag: Option<&str>,
        make_backup: bool,
        flags: FileCreateFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<FileIOStream, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_replace_readwrite(
                self.as_ref().to_glib_none().0,
                etag.to_glib_none().0,
                make_backup.into_glib(),
                flags.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously overwrites the file in read-write mode,
    /// replacing the contents, possibly creating a backup copy
    /// of the file first.
    ///
    /// For more details, see g_file_replace_readwrite() which is
    /// the synchronous version of this call.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_replace_readwrite_finish() to get
    /// the result of the operation.
    /// ## `etag`
    /// an [entity tag](#entity-tags) for the current #GFile,
    ///   or [`None`] to ignore
    /// ## `make_backup`
    /// [`true`] if a backup should be created
    /// ## `flags`
    /// a set of #GFileCreateFlags
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_replace_readwrite_async")]
    fn replace_readwrite_async<P: FnOnce(Result<FileIOStream, glib::Error>) + 'static>(
        &self,
        etag: Option<&str>,
        make_backup: bool,
        flags: FileCreateFlags,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn replace_readwrite_async_trampoline<
            P: FnOnce(Result<FileIOStream, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret =
                    ffi::g_file_replace_readwrite_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = replace_readwrite_async_trampoline::<P>;
        unsafe {
            ffi::g_file_replace_readwrite_async(
                self.as_ref().to_glib_none().0,
                etag.to_glib_none().0,
                make_backup.into_glib(),
                flags.into_glib(),
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn replace_readwrite_future(
        &self,
        etag: Option<&str>,
        make_backup: bool,
        flags: FileCreateFlags,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileIOStream, glib::Error>> + 'static>>
    {
        let etag = etag.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.replace_readwrite_async(
                    etag.as_ref().map(::std::borrow::Borrow::borrow),
                    make_backup,
                    flags,
                    io_priority,
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Resolves a relative path for @self to an absolute path.
    ///
    /// This call does no blocking I/O.
    ///
    /// If the @relative_path is an absolute path name, the resolution
    /// is done absolutely (without taking @self path as base).
    /// ## `relative_path`
    /// a given relative path string
    ///
    /// # Returns
    ///
    /// a #GFile for the resolved path.
    #[doc(alias = "g_file_resolve_relative_path")]
    #[must_use]
    fn resolve_relative_path(&self, relative_path: impl AsRef<std::path::Path>) -> File {
        unsafe {
            from_glib_full(ffi::g_file_resolve_relative_path(
                self.as_ref().to_glib_none().0,
                relative_path.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "g_file_set_attribute")]
    //fn set_attribute(&self, attribute: &str, type_: FileAttributeType, value_p: /*Unimplemented*/Option<Basic: Pointer>, flags: FileQueryInfoFlags, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
    //    unsafe { TODO: call ffi:g_file_set_attribute() }
    //}

    /// Sets @attribute of type [`FileAttributeType::ByteString`][crate::FileAttributeType::ByteString] to @value.
    /// If @attribute is of a different type, this operation will fail,
    /// returning [`false`].
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `attribute`
    /// a string containing the attribute's name
    /// ## `value`
    /// a string containing the attribute's new value
    /// ## `flags`
    /// a #GFileQueryInfoFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] if the @attribute was successfully set to @value
    ///   in the @self, [`false`] otherwise.
    #[doc(alias = "g_file_set_attribute_byte_string")]
    fn set_attribute_byte_string(
        &self,
        attribute: &str,
        value: &str,
        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_byte_string(
                self.as_ref().to_glib_none().0,
                attribute.to_glib_none().0,
                value.to_glib_none().0,
                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))
            }
        }
    }

    /// Sets @attribute of type [`FileAttributeType::Int32`][crate::FileAttributeType::Int32] to @value.
    /// If @attribute is of a different type, this operation will fail.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `attribute`
    /// a string containing the attribute's name
    /// ## `value`
    /// a #gint32 containing the attribute's new value
    /// ## `flags`
    /// a #GFileQueryInfoFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] if the @attribute was successfully set to @value
    ///   in the @self, [`false`] otherwise.
    #[doc(alias = "g_file_set_attribute_int32")]
    fn set_attribute_int32(
        &self,
        attribute: &str,
        value: i32,
        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_int32(
                self.as_ref().to_glib_none().0,
                attribute.to_glib_none().0,
                value,
                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))
            }
        }
    }

    /// Sets @attribute of type [`FileAttributeType::Int64`][crate::FileAttributeType::Int64] to @value.
    /// If @attribute is of a different type, this operation will fail.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `attribute`
    /// a string containing the attribute's name
    /// ## `value`
    /// a #guint64 containing the attribute's new value
    /// ## `flags`
    /// a #GFileQueryInfoFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] if the @attribute was successfully set, [`false`] otherwise.
    #[doc(alias = "g_file_set_attribute_int64")]
    fn set_attribute_int64(
        &self,
        attribute: &str,
        value: i64,
        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_int64(
                self.as_ref().to_glib_none().0,
                attribute.to_glib_none().0,
                value,
                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))
            }
        }
    }

    /// Sets @attribute of type [`FileAttributeType::String`][crate::FileAttributeType::String] to @value.
    /// If @attribute is of a different type, this operation will fail.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `attribute`
    /// a string containing the attribute's name
    /// ## `value`
    /// a string containing the attribute's value
    /// ## `flags`
    /// #GFileQueryInfoFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] if the @attribute was successfully set, [`false`] otherwise.
    #[doc(alias = "g_file_set_attribute_string")]
    fn set_attribute_string(
        &self,
        attribute: &str,
        value: &str,
        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_string(
                self.as_ref().to_glib_none().0,
                attribute.to_glib_none().0,
                value.to_glib_none().0,
                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))
            }
        }
    }

    /// Sets @attribute of type [`FileAttributeType::Uint32`][crate::FileAttributeType::Uint32] to @value.
    /// If @attribute is of a different type, this operation will fail.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `attribute`
    /// a string containing the attribute's name
    /// ## `value`
    /// a #guint32 containing the attribute's new value
    /// ## `flags`
    /// a #GFileQueryInfoFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] if the @attribute was successfully set to @value
    ///   in the @self, [`false`] otherwise.
    #[doc(alias = "g_file_set_attribute_uint32")]
    fn set_attribute_uint32(
        &self,
        attribute: &str,
        value: u32,
        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_uint32(
                self.as_ref().to_glib_none().0,
                attribute.to_glib_none().0,
                value,
                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))
            }
        }
    }

    /// Sets @attribute of type [`FileAttributeType::Uint64`][crate::FileAttributeType::Uint64] to @value.
    /// If @attribute is of a different type, this operation will fail.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `attribute`
    /// a string containing the attribute's name
    /// ## `value`
    /// a #guint64 containing the attribute's new value
    /// ## `flags`
    /// a #GFileQueryInfoFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] if the @attribute was successfully set to @value
    ///   in the @self, [`false`] otherwise.
    #[doc(alias = "g_file_set_attribute_uint64")]
    fn set_attribute_uint64(
        &self,
        attribute: &str,
        value: u64,
        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_uint64(
                self.as_ref().to_glib_none().0,
                attribute.to_glib_none().0,
                value,
                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))
            }
        }
    }

    /// Asynchronously sets the attributes of @self with @info.
    ///
    /// For more details, see g_file_set_attributes_from_info(),
    /// which is the synchronous version of this call.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_set_attributes_finish() to get
    /// the result of the operation.
    /// ## `info`
    /// a #GFileInfo
    /// ## `flags`
    /// a #GFileQueryInfoFlags
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_set_attributes_async")]
    fn set_attributes_async<P: FnOnce(Result<FileInfo, glib::Error>) + 'static>(
        &self,
        info: &FileInfo,
        flags: FileQueryInfoFlags,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn set_attributes_async_trampoline<
            P: FnOnce(Result<FileInfo, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let mut info = std::ptr::null_mut();
                ffi::g_file_set_attributes_finish(
                    _source_object as *mut _,
                    res,
                    &mut info,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok(from_glib_full(info))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = set_attributes_async_trampoline::<P>;
        unsafe {
            ffi::g_file_set_attributes_async(
                self.as_ref().to_glib_none().0,
                info.to_glib_none().0,
                flags.into_glib(),
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn set_attributes_future(
        &self,
        info: &FileInfo,
        flags: FileQueryInfoFlags,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<FileInfo, glib::Error>> + 'static>> {
        let info = info.clone();
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.set_attributes_async(
                    &info,
                    flags,
                    io_priority,
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Tries to set all attributes in the #GFileInfo on the target
    /// values, not stopping on the first error.
    ///
    /// If there is any error during this operation then @error will
    /// be set to the first error. Error on particular fields are flagged
    /// by setting the "status" field in the attribute value to
    /// [`FileAttributeStatus::ErrorSetting`][crate::FileAttributeStatus::ErrorSetting], which means you can
    /// also detect further errors.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `info`
    /// a #GFileInfo
    /// ## `flags`
    /// #GFileQueryInfoFlags
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`false`] if there was any error, [`true`] otherwise.
    #[doc(alias = "g_file_set_attributes_from_info")]
    fn set_attributes_from_info(
        &self,
        info: &FileInfo,
        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_attributes_from_info(
                self.as_ref().to_glib_none().0,
                info.to_glib_none().0,
                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))
            }
        }
    }

    /// Renames @self to the specified display name.
    ///
    /// The display name is converted from UTF-8 to the correct encoding
    /// for the target filesystem if possible and the @self is renamed to this.
    ///
    /// If you want to implement a rename operation in the user interface the
    /// edit name ([`FILE_ATTRIBUTE_STANDARD_EDIT_NAME`][crate::FILE_ATTRIBUTE_STANDARD_EDIT_NAME]) should be used as the
    /// initial value in the rename widget, and then the result after editing
    /// should be passed to g_file_set_display_name().
    ///
    /// On success the resulting converted filename is returned.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `display_name`
    /// a string
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// a #GFile specifying what @self was renamed to,
    ///   or [`None`] if there was an error.
    ///   Free the returned object with g_object_unref().
    #[doc(alias = "g_file_set_display_name")]
    fn set_display_name(
        &self,
        display_name: &str,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<File, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_file_set_display_name(
                self.as_ref().to_glib_none().0,
                display_name.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously sets the display name for a given #GFile.
    ///
    /// For more details, see g_file_set_display_name() which is
    /// the synchronous version of this call.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_set_display_name_finish() to get
    /// the result of the operation.
    /// ## `display_name`
    /// a string
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_set_display_name_async")]
    fn set_display_name_async<P: FnOnce(Result<File, glib::Error>) + 'static>(
        &self,
        display_name: &str,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn set_display_name_async_trampoline<
            P: FnOnce(Result<File, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret =
                    ffi::g_file_set_display_name_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = set_display_name_async_trampoline::<P>;
        unsafe {
            ffi::g_file_set_display_name_async(
                self.as_ref().to_glib_none().0,
                display_name.to_glib_none().0,
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn set_display_name_future(
        &self,
        display_name: &str,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<File, glib::Error>> + 'static>> {
        let display_name = String::from(display_name);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.set_display_name_async(
                    &display_name,
                    io_priority,
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Starts a file of type [`FileType::Mountable`][crate::FileType::Mountable].
    /// Using @start_operation, you can request callbacks when, for instance,
    /// passwords are needed during authentication.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_mount_mountable_finish() to get
    /// the result of the operation.
    /// ## `flags`
    /// flags affecting the operation
    /// ## `start_operation`
    /// a #GMountOperation, or [`None`] to avoid user interaction
    /// ## `cancellable`
    /// optional #GCancellable object, [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is satisfied, or [`None`]
    #[doc(alias = "g_file_start_mountable")]
    fn start_mountable<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        flags: DriveStartFlags,
        start_operation: Option<&impl IsA<MountOperation>>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn start_mountable_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_file_start_mountable_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = start_mountable_trampoline::<P>;
        unsafe {
            ffi::g_file_start_mountable(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                start_operation.map(|p| p.as_ref()).to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn start_mountable_future(
        &self,
        flags: DriveStartFlags,
        start_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let start_operation = start_operation.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.start_mountable(
                    flags,
                    start_operation.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Stops a file of type [`FileType::Mountable`][crate::FileType::Mountable].
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_stop_mountable_finish() to get
    /// the result of the operation.
    /// ## `flags`
    /// flags affecting the operation
    /// ## `mount_operation`
    /// a #GMountOperation,
    ///   or [`None`] to avoid user interaction.
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call
    ///   when the request is satisfied, or [`None`]
    #[doc(alias = "g_file_stop_mountable")]
    fn stop_mountable<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&impl IsA<MountOperation>>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn stop_mountable_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_file_stop_mountable_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = stop_mountable_trampoline::<P>;
        unsafe {
            ffi::g_file_stop_mountable(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn stop_mountable_future(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let mount_operation = mount_operation.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.stop_mountable(
                    flags,
                    mount_operation.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Checks if @self supports thread-default main contexts
    /// (see [`glib::MainContext::push_thread_default()`][crate::glib::MainContext::push_thread_default()])
    /// If this returns [`false`], you cannot perform asynchronous operations on
    /// @self in a thread that has a thread-default context.
    ///
    /// # Returns
    ///
    /// Whether or not @self supports thread-default contexts.
    #[doc(alias = "g_file_supports_thread_contexts")]
    fn supports_thread_contexts(&self) -> bool {
        unsafe {
            from_glib(ffi::g_file_supports_thread_contexts(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sends @self to the "Trashcan", if possible. This is similar to
    /// deleting it, but the user can recover it before emptying the trashcan.
    /// Trashing is disabled for system mounts by default (see
    /// g_unix_mount_entry_is_system_internal()), so this call can return the
    /// [`IOErrorEnum::NotSupported`][crate::IOErrorEnum::NotSupported] error. Since GLib 2.66, the `x-gvfs-notrash` unix
    /// mount option can be used to disable g_file_trash() support for particular
    /// mounts, the [`IOErrorEnum::NotSupported`][crate::IOErrorEnum::NotSupported] error will be returned in that case.
    /// Since 2.82, the `x-gvfs-trash` unix mount option can be used to enable
    /// g_file_trash() support for particular system mounts.
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    ///
    /// # Returns
    ///
    /// [`true`] on successful trash, [`false`] otherwise.
    #[doc(alias = "g_file_trash")]
    fn trash(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_file_trash(
                self.as_ref().to_glib_none().0,
                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))
            }
        }
    }

    /// Asynchronously sends @self to the Trash location, if possible.
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call
    ///   when the request is satisfied
    #[doc(alias = "g_file_trash_async")]
    fn trash_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn trash_async_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_file_trash_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = trash_async_trampoline::<P>;
        unsafe {
            ffi::g_file_trash_async(
                self.as_ref().to_glib_none().0,
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn trash_future(
        &self,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.trash_async(io_priority, Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Unmounts a file of type [`FileType::Mountable`][crate::FileType::Mountable].
    ///
    /// If @cancellable is not [`None`], then the operation can be cancelled by
    /// triggering the cancellable object from another thread. If the operation
    /// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be returned.
    ///
    /// When the operation is finished, @callback will be called.
    /// You can then call g_file_unmount_mountable_finish() to get
    /// the result of the operation.
    /// ## `flags`
    /// flags affecting the operation
    /// ## `mount_operation`
    /// a #GMountOperation,
    ///   or [`None`] to avoid user interaction
    /// ## `cancellable`
    /// optional #GCancellable object,
    ///   [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback
    ///   to call when the request is satisfied
    #[doc(alias = "g_file_unmount_mountable_with_operation")]
    fn unmount_mountable_with_operation<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&impl IsA<MountOperation>>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn unmount_mountable_with_operation_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_file_unmount_mountable_with_operation_finish(
                    _source_object as *mut _,
                    res,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = unmount_mountable_with_operation_trampoline::<P>;
        unsafe {
            ffi::g_file_unmount_mountable_with_operation(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                mount_operation.map(|p| p.as_ref()).to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn unmount_mountable_with_operation_future(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&(impl IsA<MountOperation> + Clone + 'static)>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let mount_operation = mount_operation.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.unmount_mountable_with_operation(
                    flags,
                    mount_operation.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }
}

impl<O: IsA<File>> FileExt for O {}