// 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;
use crate::Cancellable;
use crate::File;
use crate::FileInfo;
use glib::object::IsA;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::pin::Pin;
use std::ptr;

glib::wrapper! {
    /// [`FileEnumerator`][crate::FileEnumerator] allows you to operate on a set of `GFiles`,
    /// returning a [`FileInfo`][crate::FileInfo] structure for each file enumerated (e.g.
    /// [`FileExt::enumerate_children()`][crate::prelude::FileExt::enumerate_children()] will return a [`FileEnumerator`][crate::FileEnumerator] for each
    /// of the children within a directory).
    ///
    /// To get the next file's information from a [`FileEnumerator`][crate::FileEnumerator], use
    /// [`FileEnumeratorExt::next_file()`][crate::prelude::FileEnumeratorExt::next_file()] or its asynchronous version,
    /// [`FileEnumeratorExt::next_files_async()`][crate::prelude::FileEnumeratorExt::next_files_async()]. Note that the asynchronous
    /// version will return a list of `GFileInfos`, whereas the
    /// synchronous will only return the next file in the enumerator.
    ///
    /// The ordering of returned files is unspecified for non-Unix
    /// platforms; for more information, see `g_dir_read_name()`. On Unix,
    /// when operating on local files, returned files will be sorted by
    /// inode number. Effectively you can assume that the ordering of
    /// returned files will be stable between successive calls (and
    /// applications) assuming the directory is unchanged.
    ///
    /// If your application needs a specific ordering, such as by name or
    /// modification time, you will have to implement that in your
    /// application code.
    ///
    /// To close a [`FileEnumerator`][crate::FileEnumerator], use [`FileEnumeratorExt::close()`][crate::prelude::FileEnumeratorExt::close()], or
    /// its asynchronous version, [`FileEnumeratorExt::close_async()`][crate::prelude::FileEnumeratorExt::close_async()]. Once
    /// a [`FileEnumerator`][crate::FileEnumerator] is closed, no further actions may be performed
    /// on it, and it should be freed with `g_object_unref()`.
    ///
    /// # Implements
    ///
    /// [`FileEnumeratorExt`][trait@crate::prelude::FileEnumeratorExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GFileEnumerator")]
    pub struct FileEnumerator(Object<ffi::GFileEnumerator, ffi::GFileEnumeratorClass>);

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

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

/// Trait containing all [`struct@FileEnumerator`] methods.
///
/// # Implementors
///
/// [`FileEnumerator`][struct@crate::FileEnumerator]
pub trait FileEnumeratorExt: 'static {
    /// Releases all resources used by this enumerator, making the
    /// enumerator return [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed] on all calls.
    ///
    /// This will be automatically called when the last reference
    /// is dropped, but you might want to call this function to make
    /// sure resources are released as early as possible.
    /// ## `cancellable`
    /// optional [`Cancellable`][crate::Cancellable] object, [`None`] to ignore.
    ///
    /// # Returns
    ///
    /// [`true`] on success or [`false`] on error.
    #[doc(alias = "g_file_enumerator_close")]
    fn close(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error>;

    /// Asynchronously closes the file enumerator.
    ///
    /// 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 in
    /// `g_file_enumerator_close_finish()`.
    /// ## `io_priority`
    /// the [I/O priority][io-priority] of the request
    /// ## `cancellable`
    /// optional [`Cancellable`][crate::Cancellable] object, [`None`] to ignore.
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request is satisfied
    #[doc(alias = "g_file_enumerator_close_async")]
    fn close_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    );

    fn close_future(
        &self,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>>;

    /// Return a new [`File`][crate::File] which refers to the file named by `info` in the source
    /// directory of `self`. This function is primarily intended to be used
    /// inside loops with [`next_file()`][Self::next_file()].
    ///
    /// To use this, [`FILE_ATTRIBUTE_STANDARD_NAME`][crate::FILE_ATTRIBUTE_STANDARD_NAME] must have been listed in the
    /// attributes list used when creating the [`FileEnumerator`][crate::FileEnumerator].
    ///
    /// This is a convenience method that's equivalent to:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///   gchar *name = g_file_info_get_name (info);
    ///   GFile *child = g_file_get_child (g_file_enumerator_get_container (enumr),
    ///                                    name);
    /// ```
    /// ## `info`
    /// a [`FileInfo`][crate::FileInfo] gotten from [`next_file()`][Self::next_file()]
    ///  or the async equivalents.
    ///
    /// # Returns
    ///
    /// a [`File`][crate::File] for the [`FileInfo`][crate::FileInfo] passed it.
    #[doc(alias = "g_file_enumerator_get_child")]
    #[doc(alias = "get_child")]
    fn child(&self, info: &FileInfo) -> File;

    /// Get the [`File`][crate::File] container which is being enumerated.
    ///
    /// # Returns
    ///
    /// the [`File`][crate::File] which is being enumerated.
    #[doc(alias = "g_file_enumerator_get_container")]
    #[doc(alias = "get_container")]
    fn container(&self) -> File;

    /// Checks if the file enumerator has pending operations.
    ///
    /// # Returns
    ///
    /// [`true`] if the `self` has pending operations.
    #[doc(alias = "g_file_enumerator_has_pending")]
    fn has_pending(&self) -> bool;

    /// Checks if the file enumerator has been closed.
    ///
    /// # Returns
    ///
    /// [`true`] if the `self` is closed.
    #[doc(alias = "g_file_enumerator_is_closed")]
    fn is_closed(&self) -> bool;

    /// Returns information for the next file in the enumerated object.
    /// Will block until the information is available. The [`FileInfo`][crate::FileInfo]
    /// returned from this function will contain attributes that match the
    /// attribute string that was passed when the [`FileEnumerator`][crate::FileEnumerator] was created.
    ///
    /// See the documentation of [`FileEnumerator`][crate::FileEnumerator] for information about the
    /// order of returned files.
    ///
    /// On error, returns [`None`] and sets `error` to the error. If the
    /// enumerator is at the end, [`None`] will be returned and `error` will
    /// be unset.
    /// ## `cancellable`
    /// optional [`Cancellable`][crate::Cancellable] object, [`None`] to ignore.
    ///
    /// # Returns
    ///
    /// A [`FileInfo`][crate::FileInfo] or [`None`] on error
    ///  or end of enumerator. Free the returned object with
    ///  `g_object_unref()` when no longer needed.
    #[doc(alias = "g_file_enumerator_next_file")]
    fn next_file(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<Option<FileInfo>, glib::Error>;

    /// Request information for a number of files from the enumerator asynchronously.
    /// When all i/o for the operation is finished the `callback` will be called with
    /// the requested information.
    ///
    /// See the documentation of [`FileEnumerator`][crate::FileEnumerator] for information about the
    /// order of returned files.
    ///
    /// The callback can be called with less than `num_files` files in case of error
    /// or at the end of the enumerator. In case of a partial error the callback will
    /// be called with any succeeding items and no error, and on the next request the
    /// error will be reported. If a request is cancelled the callback will be called
    /// with [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled].
    ///
    /// During an async request no other sync and async calls are allowed, and will
    /// result in [`IOErrorEnum::Pending`][crate::IOErrorEnum::Pending] errors.
    ///
    /// Any outstanding i/o request with higher priority (lower numerical value) will
    /// be executed before an outstanding request with lower priority. Default
    /// priority is `G_PRIORITY_DEFAULT`.
    /// ## `num_files`
    /// the number of file info objects to request
    /// ## `io_priority`
    /// the [I/O priority][io-priority] of the request
    /// ## `cancellable`
    /// optional [`Cancellable`][crate::Cancellable] object, [`None`] to ignore.
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request is satisfied
    #[doc(alias = "g_file_enumerator_next_files_async")]
    fn next_files_async<P: FnOnce(Result<Vec<FileInfo>, glib::Error>) + 'static>(
        &self,
        num_files: i32,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    );

    fn next_files_future(
        &self,
        num_files: i32,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<FileInfo>, glib::Error>> + 'static>>;

    /// Sets the file enumerator as having pending operations.
    /// ## `pending`
    /// a boolean value.
    #[doc(alias = "g_file_enumerator_set_pending")]
    fn set_pending(&self, pending: bool);
}

impl<O: IsA<FileEnumerator>> FileEnumeratorExt for O {
    fn close(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let is_ok = ffi::g_file_enumerator_close(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn close_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 close_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,
        ) {
            let mut error = ptr::null_mut();
            let _ = ffi::g_file_enumerator_close_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 = close_async_trampoline::<P>;
        unsafe {
            ffi::g_file_enumerator_close_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 close_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.close_async(io_priority, Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    fn child(&self, info: &FileInfo) -> File {
        unsafe {
            from_glib_full(ffi::g_file_enumerator_get_child(
                self.as_ref().to_glib_none().0,
                info.to_glib_none().0,
            ))
        }
    }

    fn container(&self) -> File {
        unsafe {
            from_glib_none(ffi::g_file_enumerator_get_container(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn has_pending(&self) -> bool {
        unsafe {
            from_glib(ffi::g_file_enumerator_has_pending(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn is_closed(&self) -> bool {
        unsafe {
            from_glib(ffi::g_file_enumerator_is_closed(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn next_file(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<Option<FileInfo>, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::g_file_enumerator_next_file(
                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))
            }
        }
    }

    fn next_files_async<P: FnOnce(Result<Vec<FileInfo>, glib::Error>) + 'static>(
        &self,
        num_files: i32,
        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 next_files_async_trampoline<
            P: FnOnce(Result<Vec<FileInfo>, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let ret =
                ffi::g_file_enumerator_next_files_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(FromGlibPtrContainer::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 = next_files_async_trampoline::<P>;
        unsafe {
            ffi::g_file_enumerator_next_files_async(
                self.as_ref().to_glib_none().0,
                num_files,
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

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

    fn set_pending(&self, pending: bool) {
        unsafe {
            ffi::g_file_enumerator_set_pending(self.as_ref().to_glib_none().0, pending.into_glib());
        }
    }
}

impl fmt::Display for FileEnumerator {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("FileEnumerator")
    }
}