gio/auto/

subprocess.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::{AsyncResult, Cancellable, Initable, InputStream, OutputStream, SubprocessFlags, ffi};
use glib::{prelude::*, translate::*};
use std::{boxed::Box as Box_, pin::Pin};

glib::wrapper! {
    ///  remaining around for long periods of
    /// time.  [`wait()`][Self::wait()] can be used to wait for this to happen,
    /// but it will happen even without the call being explicitly made.
    ///
    /// As a matter of principle, `GSubprocess` has no API that accepts
    /// shell-style space-separated strings.  It will, however, match the
    /// typical shell behaviour of searching the `PATH` for executables that do
    /// not contain a directory separator in their name. By default, the `PATH`
    /// of the current process is used.  You can specify
    /// `G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP` to use the `PATH` of the
    /// launcher environment instead.
    ///
    /// `GSubprocess` attempts to have a very simple API for most uses (ie:
    /// spawning a subprocess with arguments and support for most typical
    /// kinds of input and output redirection).  See `Gio::Subprocess::new()`. The
    /// [`SubprocessLauncher`][crate::SubprocessLauncher] API is provided for more complicated cases
    /// (advanced types of redirection, environment variable manipulation,
    /// change of working directory, child setup functions, etc).
    ///
    /// A typical use of `GSubprocess` will involve calling
    /// `Gio::Subprocess::new()`, followed by [`wait_async()`][Self::wait_async()] or
    /// [`wait()`][Self::wait()].  After the process exits, the status can be
    /// checked using functions such as [`has_exited()`][Self::has_exited()] (which
    /// are similar to the familiar `WIFEXITED`-style POSIX macros).
    ///
    /// Note that as of GLib 2.82, creating a `GSubprocess` causes the signal
    /// `SIGPIPE` to be ignored for the remainder of the program. If you are writing
    /// a command-line utility that uses `GSubprocess`, you may need to take into
    /// account the fact that your program will not automatically be killed
    /// if it tries to write to `stdout` after it has been closed.
    ///
    /// ## Properties
    ///
    ///
    /// #### `argv`
    ///  Argument vector.
    ///
    /// Writable | Construct Only
    ///
    ///
    /// #### `flags`
    ///  Subprocess flags.
    ///
    /// Writable | Construct Only
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`], [`InitableExt`][trait@crate::prelude::InitableExt]
    #[doc(alias = "GSubprocess")]
    pub struct Subprocess(Object<ffi::GSubprocess>) @implements Initable;

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

impl Subprocess {
    //#[doc(alias = "g_subprocess_new")]
    //pub fn new(flags: SubprocessFlags, error: Option<&mut glib::Error>, argv0: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Subprocess {
    //    unsafe { TODO: call ffi:g_subprocess_new() }
    //}

    /// Create a new process with the given flags and argument list.
    ///
    /// The argument list is expected to be [`None`]-terminated.
    /// ## `argv`
    /// commandline arguments for the subprocess
    /// ## `flags`
    /// flags that define the behaviour of the subprocess
    ///
    /// # Returns
    ///
    /// A newly created #GSubprocess, or [`None`] on error (and @error
    ///   will be set)
    #[doc(alias = "g_subprocess_newv")]
    pub fn newv(
        argv: &[&std::ffi::OsStr],
        flags: SubprocessFlags,
    ) -> Result<Subprocess, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_subprocess_newv(argv.to_glib_none().0, flags.into_glib(), &mut error);
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Communicate with the subprocess until it terminates, and all input
    /// and output has been completed.
    ///
    /// If @stdin_buf is given, the subprocess must have been created with
    /// [`SubprocessFlags::STDIN_PIPE`][crate::SubprocessFlags::STDIN_PIPE].  The given data is fed to the
    /// stdin of the subprocess and the pipe is closed (ie: EOF).
    ///
    /// At the same time (as not to cause blocking when dealing with large
    /// amounts of data), if [`SubprocessFlags::STDOUT_PIPE`][crate::SubprocessFlags::STDOUT_PIPE] or
    /// [`SubprocessFlags::STDERR_PIPE`][crate::SubprocessFlags::STDERR_PIPE] were used, reads from those
    /// streams.  The data that was read is returned in @stdout and/or
    /// the @stderr.
    ///
    /// If the subprocess was created with [`SubprocessFlags::STDOUT_PIPE`][crate::SubprocessFlags::STDOUT_PIPE],
    /// @stdout_buf will contain the data read from stdout.  Otherwise, for
    /// subprocesses not created with [`SubprocessFlags::STDOUT_PIPE`][crate::SubprocessFlags::STDOUT_PIPE],
    /// @stdout_buf will be set to [`None`].  Similar provisions apply to
    /// @stderr_buf and [`SubprocessFlags::STDERR_PIPE`][crate::SubprocessFlags::STDERR_PIPE].
    ///
    /// As usual, any output variable may be given as [`None`] to ignore it.
    ///
    /// If you desire the stdout and stderr data to be interleaved, create
    /// the subprocess with [`SubprocessFlags::STDOUT_PIPE`][crate::SubprocessFlags::STDOUT_PIPE] and
    /// [`SubprocessFlags::STDERR_MERGE`][crate::SubprocessFlags::STDERR_MERGE].  The merged result will be returned
    /// in @stdout_buf and @stderr_buf will be set to [`None`].
    ///
    /// In case of any error (including cancellation), [`false`] will be
    /// returned with @error set.  Some or all of the stdin data may have
    /// been written.  Any stdout or stderr data that has been read will be
    /// discarded. None of the out variables (aside from @error) will have
    /// been set to anything in particular and should not be inspected.
    ///
    /// In the case that [`true`] is returned, the subprocess has exited and the
    /// exit status inspection APIs (eg: g_subprocess_get_if_exited(),
    /// g_subprocess_get_exit_status()) may be used.
    ///
    /// You should not attempt to use any of the subprocess pipes after
    /// starting this function, since they may be left in strange states,
    /// even if the operation was cancelled.  You should especially not
    /// attempt to interact with the pipes while the operation is in progress
    /// (either from another thread or if using the asynchronous version).
    /// ## `stdin_buf`
    /// data to send to the stdin of the subprocess, or [`None`]
    /// ## `cancellable`
    /// a #GCancellable
    ///
    /// # Returns
    ///
    /// [`true`] if successful
    ///
    /// ## `stdout_buf`
    /// data read from the subprocess stdout
    ///
    /// ## `stderr_buf`
    /// data read from the subprocess stderr
    #[doc(alias = "g_subprocess_communicate")]
    pub fn communicate(
        &self,
        stdin_buf: Option<&glib::Bytes>,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(Option<glib::Bytes>, Option<glib::Bytes>), glib::Error> {
        unsafe {
            let mut stdout_buf = std::ptr::null_mut();
            let mut stderr_buf = std::ptr::null_mut();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_subprocess_communicate(
                self.to_glib_none().0,
                stdin_buf.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut stdout_buf,
                &mut stderr_buf,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok((from_glib_full(stdout_buf), from_glib_full(stderr_buf)))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronous version of g_subprocess_communicate().  Complete
    /// invocation with g_subprocess_communicate_finish().
    /// ## `stdin_buf`
    /// Input data, or [`None`]
    /// ## `cancellable`
    /// Cancellable
    /// ## `callback`
    /// Callback
    #[doc(alias = "g_subprocess_communicate_async")]
    pub fn communicate_async<
        P: FnOnce(Result<(Option<glib::Bytes>, Option<glib::Bytes>), glib::Error>) + 'static,
    >(
        &self,
        stdin_buf: Option<&glib::Bytes>,
        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 communicate_async_trampoline<
            P: FnOnce(Result<(Option<glib::Bytes>, Option<glib::Bytes>), 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 stdout_buf = std::ptr::null_mut();
                let mut stderr_buf = std::ptr::null_mut();
                ffi::g_subprocess_communicate_finish(
                    _source_object as *mut _,
                    res,
                    &mut stdout_buf,
                    &mut stderr_buf,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok((from_glib_full(stdout_buf), from_glib_full(stderr_buf)))
                } 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 = communicate_async_trampoline::<P>;
        unsafe {
            ffi::g_subprocess_communicate_async(
                self.to_glib_none().0,
                stdin_buf.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn communicate_future(
        &self,
        stdin_buf: Option<&glib::Bytes>,
    ) -> Pin<
        Box_<
            dyn std::future::Future<
                    Output = Result<(Option<glib::Bytes>, Option<glib::Bytes>), glib::Error>,
                > + 'static,
        >,
    > {
        let stdin_buf = stdin_buf.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.communicate_async(
                    stdin_buf.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Like g_subprocess_communicate(), but validates the output of the
    /// process as UTF-8, and returns it as a regular NUL terminated string.
    ///
    /// On error, @stdout_buf and @stderr_buf will be set to undefined values and
    /// should not be used.
    /// ## `stdin_buf`
    /// data to send to the stdin of the subprocess, or [`None`]
    /// ## `cancellable`
    /// a #GCancellable
    ///
    /// # Returns
    ///
    ///
    /// ## `stdout_buf`
    /// data read from the subprocess stdout
    ///
    /// ## `stderr_buf`
    /// data read from the subprocess stderr
    #[doc(alias = "g_subprocess_communicate_utf8")]
    pub fn communicate_utf8(
        &self,
        stdin_buf: Option<&str>,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(Option<glib::GString>, Option<glib::GString>), glib::Error> {
        unsafe {
            let mut stdout_buf = std::ptr::null_mut();
            let mut stderr_buf = std::ptr::null_mut();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_subprocess_communicate_utf8(
                self.to_glib_none().0,
                stdin_buf.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut stdout_buf,
                &mut stderr_buf,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok((from_glib_full(stdout_buf), from_glib_full(stderr_buf)))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Use an operating-system specific method to attempt an immediate,
    /// forceful termination of the process.  There is no mechanism to
    /// determine whether or not the request itself was successful;
    /// however, you can use g_subprocess_wait() to monitor the status of
    /// the process after calling this function.
    ///
    /// On Unix, this function sends `SIGKILL`.
    #[doc(alias = "g_subprocess_force_exit")]
    pub fn force_exit(&self) {
        unsafe {
            ffi::g_subprocess_force_exit(self.to_glib_none().0);
        }
    }

    /// Check the exit status of the subprocess, given that it exited
    /// normally.  This is the value passed to the exit() system call or the
    /// return value from main.
    ///
    /// This is equivalent to the system WEXITSTATUS macro.
    ///
    /// It is an error to call this function before g_subprocess_wait() and
    /// unless g_subprocess_get_if_exited() returned [`true`].
    ///
    /// # Returns
    ///
    /// the exit status
    #[doc(alias = "g_subprocess_get_exit_status")]
    #[doc(alias = "get_exit_status")]
    pub fn exit_status(&self) -> i32 {
        unsafe { ffi::g_subprocess_get_exit_status(self.to_glib_none().0) }
    }

    /// On UNIX, returns the process ID as a decimal string.
    /// On Windows, returns the result of GetProcessId() also as a string.
    /// If the subprocess has terminated, this will return [`None`].
    ///
    /// # Returns
    ///
    /// the subprocess identifier, or [`None`] if the subprocess
    ///    has terminated
    #[doc(alias = "g_subprocess_get_identifier")]
    #[doc(alias = "get_identifier")]
    pub fn identifier(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::g_subprocess_get_identifier(self.to_glib_none().0)) }
    }

    /// Check if the given subprocess exited normally (ie: by way of exit()
    /// or return from main()).
    ///
    /// This is equivalent to the system WIFEXITED macro.
    ///
    /// It is an error to call this function before g_subprocess_wait() has
    /// returned.
    ///
    /// # Returns
    ///
    /// [`true`] if the case of a normal exit
    #[doc(alias = "g_subprocess_get_if_exited")]
    #[doc(alias = "get_if_exited")]
    pub fn has_exited(&self) -> bool {
        unsafe { from_glib(ffi::g_subprocess_get_if_exited(self.to_glib_none().0)) }
    }

    /// Check if the given subprocess terminated in response to a signal.
    ///
    /// This is equivalent to the system WIFSIGNALED macro.
    ///
    /// It is an error to call this function before g_subprocess_wait() has
    /// returned.
    ///
    /// # Returns
    ///
    /// [`true`] if the case of termination due to a signal
    #[doc(alias = "g_subprocess_get_if_signaled")]
    #[doc(alias = "get_if_signaled")]
    pub fn has_signaled(&self) -> bool {
        unsafe { from_glib(ffi::g_subprocess_get_if_signaled(self.to_glib_none().0)) }
    }

    /// Gets the raw status code of the process, as from waitpid().
    ///
    /// This value has no particular meaning, but it can be used with the
    /// macros defined by the system headers such as WIFEXITED.  It can also
    /// be used with g_spawn_check_wait_status().
    ///
    /// It is more likely that you want to use g_subprocess_get_if_exited()
    /// followed by g_subprocess_get_exit_status().
    ///
    /// It is an error to call this function before g_subprocess_wait() has
    /// returned.
    ///
    /// # Returns
    ///
    /// the (meaningless) waitpid() exit status from the kernel
    #[doc(alias = "g_subprocess_get_status")]
    #[doc(alias = "get_status")]
    pub fn status(&self) -> i32 {
        unsafe { ffi::g_subprocess_get_status(self.to_glib_none().0) }
    }

    /// Gets the #GInputStream from which to read the stderr output of
    /// @self.
    ///
    /// The process must have been created with [`SubprocessFlags::STDERR_PIPE`][crate::SubprocessFlags::STDERR_PIPE],
    /// otherwise [`None`] will be returned.
    ///
    /// # Returns
    ///
    /// the stderr pipe
    #[doc(alias = "g_subprocess_get_stderr_pipe")]
    #[doc(alias = "get_stderr_pipe")]
    pub fn stderr_pipe(&self) -> Option<InputStream> {
        unsafe { from_glib_none(ffi::g_subprocess_get_stderr_pipe(self.to_glib_none().0)) }
    }

    /// Gets the #GOutputStream that you can write to in order to give data
    /// to the stdin of @self.
    ///
    /// The process must have been created with [`SubprocessFlags::STDIN_PIPE`][crate::SubprocessFlags::STDIN_PIPE] and
    /// not [`SubprocessFlags::STDIN_INHERIT`][crate::SubprocessFlags::STDIN_INHERIT], otherwise [`None`] will be returned.
    ///
    /// # Returns
    ///
    /// the stdout pipe
    #[doc(alias = "g_subprocess_get_stdin_pipe")]
    #[doc(alias = "get_stdin_pipe")]
    pub fn stdin_pipe(&self) -> Option<OutputStream> {
        unsafe { from_glib_none(ffi::g_subprocess_get_stdin_pipe(self.to_glib_none().0)) }
    }

    /// Gets the #GInputStream from which to read the stdout output of
    /// @self.
    ///
    /// The process must have been created with [`SubprocessFlags::STDOUT_PIPE`][crate::SubprocessFlags::STDOUT_PIPE],
    /// otherwise [`None`] will be returned.
    ///
    /// # Returns
    ///
    /// the stdout pipe
    #[doc(alias = "g_subprocess_get_stdout_pipe")]
    #[doc(alias = "get_stdout_pipe")]
    pub fn stdout_pipe(&self) -> Option<InputStream> {
        unsafe { from_glib_none(ffi::g_subprocess_get_stdout_pipe(self.to_glib_none().0)) }
    }

    /// Checks if the process was "successful".  A process is considered
    /// successful if it exited cleanly with an exit status of 0, either by
    /// way of the exit() system call or return from main().
    ///
    /// It is an error to call this function before g_subprocess_wait() has
    /// returned.
    ///
    /// # Returns
    ///
    /// [`true`] if the process exited cleanly with a exit status of 0
    #[doc(alias = "g_subprocess_get_successful")]
    #[doc(alias = "get_successful")]
    pub fn is_successful(&self) -> bool {
        unsafe { from_glib(ffi::g_subprocess_get_successful(self.to_glib_none().0)) }
    }

    /// Get the signal number that caused the subprocess to terminate, given
    /// that it terminated due to a signal.
    ///
    /// This is equivalent to the system WTERMSIG macro.
    ///
    /// It is an error to call this function before g_subprocess_wait() and
    /// unless g_subprocess_get_if_signaled() returned [`true`].
    ///
    /// # Returns
    ///
    /// the signal causing termination
    #[doc(alias = "g_subprocess_get_term_sig")]
    #[doc(alias = "get_term_sig")]
    pub fn term_sig(&self) -> i32 {
        unsafe { ffi::g_subprocess_get_term_sig(self.to_glib_none().0) }
    }

    /// Sends the UNIX signal @signal_num to the subprocess, if it is still
    /// running.
    ///
    /// This API is race-free.  If the subprocess has terminated, it will not
    /// be signalled.
    ///
    /// This API is not available on Windows.
    /// ## `signal_num`
    /// the signal number to send
    #[cfg(not(windows))]
    #[cfg_attr(docsrs, doc(cfg(not(windows))))]
    #[doc(alias = "g_subprocess_send_signal")]
    pub fn send_signal(&self, signal_num: i32) {
        unsafe {
            ffi::g_subprocess_send_signal(self.to_glib_none().0, signal_num);
        }
    }

    /// Synchronously wait for the subprocess to terminate.
    ///
    /// After the process terminates you can query its exit status with
    /// functions such as g_subprocess_get_if_exited() and
    /// g_subprocess_get_exit_status().
    ///
    /// This function does not fail in the case of the subprocess having
    /// abnormal termination.  See g_subprocess_wait_check() for that.
    ///
    /// Cancelling @cancellable doesn't kill the subprocess.  Call
    /// g_subprocess_force_exit() if it is desirable.
    /// ## `cancellable`
    /// a #GCancellable
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] if @cancellable was cancelled
    #[doc(alias = "g_subprocess_wait")]
    pub fn wait(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_subprocess_wait(
                self.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))
            }
        }
    }

    /// Wait for the subprocess to terminate.
    ///
    /// This is the asynchronous version of g_subprocess_wait().
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the operation is complete
    #[doc(alias = "g_subprocess_wait_async")]
    pub fn wait_async<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 wait_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_subprocess_wait_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 = wait_async_trampoline::<P>;
        unsafe {
            ffi::g_subprocess_wait_async(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

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

    /// Combines g_subprocess_wait() with g_spawn_check_wait_status().
    /// ## `cancellable`
    /// a #GCancellable
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] if process exited abnormally, or
    /// @cancellable was cancelled
    #[doc(alias = "g_subprocess_wait_check")]
    pub fn wait_check(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_subprocess_wait_check(
                self.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))
            }
        }
    }

    /// Combines g_subprocess_wait_async() with g_spawn_check_wait_status().
    ///
    /// This is the asynchronous version of g_subprocess_wait_check().
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the operation is complete
    #[doc(alias = "g_subprocess_wait_check_async")]
    pub fn wait_check_async<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 wait_check_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_subprocess_wait_check_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 = wait_check_async_trampoline::<P>;
        unsafe {
            ffi::g_subprocess_wait_check_async(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

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