luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-12-26 15:36:14 +01:00
Code Issues Packages Projects Releases Wiki Activity
57169dd92f
glib/gio/gfileenumerator.c
Michael Catanzaro 5d738ddcfe Audit and fix incorrect use of (closure) in glib 
Following Emmanuele's instructions for use of introspection annotations:

https://www.bassi.io/articles/2023/02/20/bindable-api-2023/

I have audited all uses of the (closure) annotation in glib and
determined that only a handful are correct. This commit changes almost
all of our use of (closure) annotations to conform to Emmanuele's rules.
2023-07-21 19:03:57 +01:00

937 lines
30 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* GIO - GLib Input, Output and Streaming Library
*
* Copyright (C) 2006-2007 Red Hat, Inc.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
*
* Author: Alexander Larsson <alexl@redhat.com>
*/
#include "config.h"
#include "gfileenumerator.h"
#include "gfile.h"
#include "gioscheduler.h"
#include "gasyncresult.h"
#include "gasynchelper.h"
#include "gioerror.h"
#include "glibintl.h"
struct _GFileEnumeratorPrivate {
/* TODO: Should be public for subclasses? */
GFile *container;
guint closed : 1;
guint pending : 1;
GAsyncReadyCallback outstanding_callback;
GError *outstanding_error;
};
/**
* SECTION:gfileenumerator
* @short_description: Enumerated Files Routines
* @include: gio/gio.h
*
* #GFileEnumerator allows you to operate on a set of #GFiles,
* returning a #GFileInfo structure for each file enumerated (e.g.
* g_file_enumerate_children() will return a #GFileEnumerator for each
* of the children within a directory).
*
* To get the next file's information from a #GFileEnumerator, use
* g_file_enumerator_next_file() or its asynchronous version,
* g_file_enumerator_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 #GFileEnumerator, use g_file_enumerator_close(), or
* its asynchronous version, g_file_enumerator_close_async(). Once
* a #GFileEnumerator is closed, no further actions may be performed
* on it, and it should be freed with g_object_unref().
*
**/
G_DEFINE_TYPE_WITH_PRIVATE (GFileEnumerator, g_file_enumerator, G_TYPE_OBJECT)
enum {
PROP_0,
PROP_CONTAINER
};
static void g_file_enumerator_real_next_files_async (GFileEnumerator *enumerator,
int num_files,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
static GList * g_file_enumerator_real_next_files_finish (GFileEnumerator *enumerator,
GAsyncResult *res,
GError **error);
static void g_file_enumerator_real_close_async (GFileEnumerator *enumerator,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
static gboolean g_file_enumerator_real_close_finish (GFileEnumerator *enumerator,
GAsyncResult *res,
GError **error);
static void
g_file_enumerator_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GFileEnumerator *enumerator;
enumerator = G_FILE_ENUMERATOR (object);
switch (property_id) {
case PROP_CONTAINER:
enumerator->priv->container = g_value_dup_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
g_file_enumerator_dispose (GObject *object)
{
GFileEnumerator *enumerator;
enumerator = G_FILE_ENUMERATOR (object);
if (enumerator->priv->container) {
g_object_unref (enumerator->priv->container);
enumerator->priv->container = NULL;
}
G_OBJECT_CLASS (g_file_enumerator_parent_class)->dispose (object);
}
static void
g_file_enumerator_finalize (GObject *object)
{
GFileEnumerator *enumerator;
enumerator = G_FILE_ENUMERATOR (object);
if (!enumerator->priv->closed)
g_file_enumerator_close (enumerator, NULL, NULL);
G_OBJECT_CLASS (g_file_enumerator_parent_class)->finalize (object);
}
static void
g_file_enumerator_class_init (GFileEnumeratorClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->set_property = g_file_enumerator_set_property;
gobject_class->dispose = g_file_enumerator_dispose;
gobject_class->finalize = g_file_enumerator_finalize;
klass->next_files_async = g_file_enumerator_real_next_files_async;
klass->next_files_finish = g_file_enumerator_real_next_files_finish;
klass->close_async = g_file_enumerator_real_close_async;
klass->close_finish = g_file_enumerator_real_close_finish;
g_object_class_install_property
(gobject_class, PROP_CONTAINER,
g_param_spec_object ("container", P_("Container"),
P_("The container that is being enumerated"),
G_TYPE_FILE,
G_PARAM_WRITABLE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
}
static void
g_file_enumerator_init (GFileEnumerator *enumerator)
{
enumerator->priv = g_file_enumerator_get_instance_private (enumerator);
}
/**
* g_file_enumerator_next_file:
* @enumerator: a #GFileEnumerator.
* @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
* @error: location to store the error occurring, or %NULL to ignore
*
* Returns information for the next file in the enumerated object.
* Will block until the information is available. The #GFileInfo
* returned from this function will contain attributes that match the
* attribute string that was passed when the #GFileEnumerator was created.
*
* See the documentation of #GFileEnumerator for information about the
* order of returned files.
*
* On error, returns %NULL and sets @error to the error. If the
* enumerator is at the end, %NULL will be returned and @error will
* be unset.
*
* Returns: (nullable) (transfer full): A #GFileInfo or %NULL on error
* or end of enumerator. Free the returned object with
* g_object_unref() when no longer needed.
**/
GFileInfo *
g_file_enumerator_next_file (GFileEnumerator *enumerator,
GCancellable *cancellable,
GError **error)
{
GFileEnumeratorClass *class;
GFileInfo *info;
g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), NULL);
g_return_val_if_fail (enumerator != NULL, NULL);
if (enumerator->priv->closed)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
_("Enumerator is closed"));
return NULL;
}
if (enumerator->priv->pending)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PENDING,
_("File enumerator has outstanding operation"));
return NULL;
}
if (enumerator->priv->outstanding_error)
{
g_propagate_error (error, enumerator->priv->outstanding_error);
enumerator->priv->outstanding_error = NULL;
return NULL;
}
class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
if (cancellable)
g_cancellable_push_current (cancellable);
enumerator->priv->pending = TRUE;
info = (* class->next_file) (enumerator, cancellable, error);
enumerator->priv->pending = FALSE;
if (cancellable)
g_cancellable_pop_current (cancellable);
return info;
}
/**
* g_file_enumerator_close:
* @enumerator: a #GFileEnumerator.
* @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
* @error: location to store the error occurring, or %NULL to ignore
*
* Releases all resources used by this enumerator, making the
* enumerator return %G_IO_ERROR_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.
*
* Returns: #TRUE on success or #FALSE on error.
**/
gboolean
g_file_enumerator_close (GFileEnumerator *enumerator,
GCancellable *cancellable,
GError **error)
{
GFileEnumeratorClass *class;
g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), FALSE);
g_return_val_if_fail (enumerator != NULL, FALSE);
class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
if (enumerator->priv->closed)
return TRUE;
if (enumerator->priv->pending)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PENDING,
_("File enumerator has outstanding operation"));
return FALSE;
}
if (cancellable)
g_cancellable_push_current (cancellable);
enumerator->priv->pending = TRUE;
(* class->close_fn) (enumerator, cancellable, error);
enumerator->priv->pending = FALSE;
enumerator->priv->closed = TRUE;
if (cancellable)
g_cancellable_pop_current (cancellable);
return TRUE;
}
static void
next_async_callback_wrapper (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GFileEnumerator *enumerator = G_FILE_ENUMERATOR (source_object);
enumerator->priv->pending = FALSE;
if (enumerator->priv->outstanding_callback)
(*enumerator->priv->outstanding_callback) (source_object, res, user_data);
g_object_unref (enumerator);
}
/**
* g_file_enumerator_next_files_async:
* @enumerator: a #GFileEnumerator.
* @num_files: the number of file info objects to request
* @io_priority: the [I/O priority][io-priority] of the request
* @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
* @callback: (scope async) (closure user_data): a #GAsyncReadyCallback
* to call when the request is satisfied
* @user_data: the data to pass to callback function
*
* 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 #GFileEnumerator for information about the
* order of returned files.
*
* Once the end of the enumerator is reached, or if an error occurs, the
* @callback will be called with an empty list. In this case, the previous call
* to g_file_enumerator_next_files_async() will typically have returned fewer
* than @num_files items.
*
* If a request is cancelled the callback will be called with
* %G_IO_ERROR_CANCELLED.
*
* This leads to the following pseudo-code usage:
* |[
* g_autoptr(GFile) dir = get_directory ();
* g_autoptr(GFileEnumerator) enumerator = NULL;
* g_autolist(GFileInfo) files = NULL;
* g_autoptr(GError) local_error = NULL;
*
* enumerator = yield g_file_enumerate_children_async (dir,
* G_FILE_ATTRIBUTE_STANDARD_NAME ","
* G_FILE_ATTRIBUTE_STANDARD_TYPE,
* G_FILE_QUERY_INFO_NONE,
* G_PRIORITY_DEFAULT,
* cancellable,
* …,
* &local_error);
* if (enumerator == NULL)
* g_error ("Error enumerating: %s", local_error->message);
*
* // Loop until no files are returned, either because the end of the enumerator
* // has been reached, or an error was returned.
* do
* {
* files = yield g_file_enumerator_next_files_async (enumerator,
* 5, // number of files to request
* G_PRIORITY_DEFAULT,
* cancellable,
* …,
* &local_error);
*
* // Process the returned files, but don’t assume that exactly 5 were returned.
* for (GList *l = files; l != NULL; l = l->next)
* {
* GFileInfo *info = l->data;
* handle_file_info (info);
* }
* }
* while (files != NULL);
*
* if (local_error != NULL &&
* !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
* g_error ("Error while enumerating: %s", local_error->message);
* ]|
*
* During an async request no other sync and async calls are allowed, and will
* result in %G_IO_ERROR_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.
**/
void
g_file_enumerator_next_files_async (GFileEnumerator *enumerator,
int num_files,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GFileEnumeratorClass *class;
g_return_if_fail (G_IS_FILE_ENUMERATOR (enumerator));
g_return_if_fail (enumerator != NULL);
g_return_if_fail (num_files >= 0);
if (num_files == 0)
{
GTask *task;
task = g_task_new (enumerator, cancellable, callback, user_data);
g_task_set_source_tag (task, g_file_enumerator_next_files_async);
g_task_return_pointer (task, NULL, NULL);
g_object_unref (task);
return;
}
if (enumerator->priv->closed)
{
g_task_report_new_error (enumerator, callback, user_data,
g_file_enumerator_next_files_async,
G_IO_ERROR, G_IO_ERROR_CLOSED,
_("File enumerator is already closed"));
return;
}
if (enumerator->priv->pending)
{
g_task_report_new_error (enumerator, callback, user_data,
g_file_enumerator_next_files_async,
G_IO_ERROR, G_IO_ERROR_PENDING,
_("File enumerator has outstanding operation"));
return;
}
class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
enumerator->priv->pending = TRUE;
enumerator->priv->outstanding_callback = callback;
g_object_ref (enumerator);
(* class->next_files_async) (enumerator, num_files, io_priority, cancellable,
next_async_callback_wrapper, user_data);
}
/**
* g_file_enumerator_next_files_finish:
* @enumerator: a #GFileEnumerator.
* @result: a #GAsyncResult.
* @error: a #GError location to store the error occurring, or %NULL to
* ignore.
*
* Finishes the asynchronous operation started with g_file_enumerator_next_files_async().
*
* Returns: (transfer full) (element-type Gio.FileInfo): a #GList of #GFileInfos. You must free the list with
* g_list_free() and unref the infos with g_object_unref() when you're
* done with them.
**/
GList *
g_file_enumerator_next_files_finish (GFileEnumerator *enumerator,
GAsyncResult *result,
GError **error)
{
GFileEnumeratorClass *class;
g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), NULL);
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
if (g_async_result_legacy_propagate_error (result, error))
return NULL;
else if (g_async_result_is_tagged (result, g_file_enumerator_next_files_async))
return g_task_propagate_pointer (G_TASK (result), error);
class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
return class->next_files_finish (enumerator, result, error);
}
static void
close_async_callback_wrapper (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GFileEnumerator *enumerator = G_FILE_ENUMERATOR (source_object);
enumerator->priv->pending = FALSE;
enumerator->priv->closed = TRUE;
if (enumerator->priv->outstanding_callback)
(*enumerator->priv->outstanding_callback) (source_object, res, user_data);
g_object_unref (enumerator);
}
/**
* g_file_enumerator_close_async:
* @enumerator: a #GFileEnumerator.
* @io_priority: the [I/O priority][io-priority] of the request
* @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
* @callback: (scope async) (closure user_data): a #GAsyncReadyCallback
* to call when the request is satisfied
* @user_data: the data to pass to callback function
*
* Asynchronously closes the file 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 %G_IO_ERROR_CANCELLED will be returned in
* g_file_enumerator_close_finish().
**/
void
g_file_enumerator_close_async (GFileEnumerator *enumerator,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GFileEnumeratorClass *class;
g_return_if_fail (G_IS_FILE_ENUMERATOR (enumerator));
if (enumerator->priv->closed)
{
g_task_report_new_error (enumerator, callback, user_data,
g_file_enumerator_close_async,
G_IO_ERROR, G_IO_ERROR_CLOSED,
_("File enumerator is already closed"));
return;
}
if (enumerator->priv->pending)
{
g_task_report_new_error (enumerator, callback, user_data,
g_file_enumerator_close_async,
G_IO_ERROR, G_IO_ERROR_PENDING,
_("File enumerator has outstanding operation"));
return;
}
class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
enumerator->priv->pending = TRUE;
enumerator->priv->outstanding_callback = callback;
g_object_ref (enumerator);
(* class->close_async) (enumerator, io_priority, cancellable,
close_async_callback_wrapper, user_data);
}
/**
* g_file_enumerator_close_finish:
* @enumerator: a #GFileEnumerator.
* @result: a #GAsyncResult.
* @error: a #GError location to store the error occurring, or %NULL to
* ignore.
*
* Finishes closing a file enumerator, started from g_file_enumerator_close_async().
*
* If the file enumerator was already closed when g_file_enumerator_close_async()
* was called, then this function will report %G_IO_ERROR_CLOSED in @error, and
* return %FALSE. If the file enumerator had pending operation when the close
* operation was started, then this function will report %G_IO_ERROR_PENDING, and
* return %FALSE. If @cancellable was not %NULL, then the operation may have been
* cancelled by triggering the cancellable object from another thread. If the operation
* was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %FALSE will be
* returned.
*
* Returns: %TRUE if the close operation has finished successfully.
**/
gboolean
g_file_enumerator_close_finish (GFileEnumerator *enumerator,
GAsyncResult *result,
GError **error)
{
GFileEnumeratorClass *class;
g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), FALSE);
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
if (g_async_result_legacy_propagate_error (result, error))
return FALSE;
else if (g_async_result_is_tagged (result, g_file_enumerator_close_async))
return g_task_propagate_boolean (G_TASK (result), error);
class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
return class->close_finish (enumerator, result, error);
}
/**
* g_file_enumerator_is_closed:
* @enumerator: a #GFileEnumerator.
*
* Checks if the file enumerator has been closed.
*
* Returns: %TRUE if the @enumerator is closed.
**/
gboolean
g_file_enumerator_is_closed (GFileEnumerator *enumerator)
{
g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), TRUE);
return enumerator->priv->closed;
}
/**
* g_file_enumerator_has_pending:
* @enumerator: a #GFileEnumerator.
*
* Checks if the file enumerator has pending operations.
*
* Returns: %TRUE if the @enumerator has pending operations.
**/
gboolean
g_file_enumerator_has_pending (GFileEnumerator *enumerator)
{
g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), TRUE);
return enumerator->priv->pending;
}
/**
* g_file_enumerator_set_pending:
* @enumerator: a #GFileEnumerator.
* @pending: a boolean value.
*
* Sets the file enumerator as having pending operations.
**/
void
g_file_enumerator_set_pending (GFileEnumerator *enumerator,
gboolean pending)
{
g_return_if_fail (G_IS_FILE_ENUMERATOR (enumerator));
enumerator->priv->pending = pending;
}
/**
* g_file_enumerator_iterate:
* @direnum: an open #GFileEnumerator
* @out_info: (out) (transfer none) (optional): Output location for the next #GFileInfo, or %NULL
* @out_child: (out) (transfer none) (optional): Output location for the next #GFile, or %NULL
* @cancellable: a #GCancellable
* @error: a #GError
*
* This is a version of g_file_enumerator_next_file() that's easier to
* use correctly from C programs. With g_file_enumerator_next_file(),
* the gboolean return value signifies "end of iteration or error", which
* requires allocation of a temporary #GError.
*
* In contrast, with this function, a %FALSE return from
* g_file_enumerator_iterate() *always* means
* "error". End of iteration is signaled by @out_info or @out_child being %NULL.
*
* Another crucial difference is that the references for @out_info and
* @out_child are owned by @direnum (they are cached as hidden
* properties). You must not unref them in your own code. This makes
* memory management significantly easier for C code in combination
* with loops.
*
* Finally, this function optionally allows retrieving a #GFile as
* well.
*
* You must specify at least one of @out_info or @out_child.
*
* The code pattern for correctly using g_file_enumerator_iterate() from C
* is:
*
* |[
* direnum = g_file_enumerate_children (file, ...);
* while (TRUE)
* {
* GFileInfo *info;
* if (!g_file_enumerator_iterate (direnum, &info, NULL, cancellable, error))
* goto out;
* if (!info)
* break;
* ... do stuff with "info"; do not unref it! ...
* }
*
* out:
* g_object_unref (direnum); // Note: frees the last @info
* ]|
*
*
* Since: 2.44
*/
gboolean
g_file_enumerator_iterate (GFileEnumerator *direnum,
GFileInfo **out_info,
GFile **out_child,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
GError *temp_error = NULL;
GFileInfo *ret_info = NULL;
static GQuark cached_info_quark;
static GQuark cached_child_quark;
static gsize quarks_initialized;
g_return_val_if_fail (direnum != NULL, FALSE);
g_return_val_if_fail (out_info != NULL || out_child != NULL, FALSE);
if (g_once_init_enter (&quarks_initialized))
{
cached_info_quark = g_quark_from_static_string ("g-cached-info");
cached_child_quark = g_quark_from_static_string ("g-cached-child");
g_once_init_leave (&quarks_initialized, 1);
}
ret_info = g_file_enumerator_next_file (direnum, cancellable, &temp_error);
if (temp_error != NULL)
{
g_propagate_error (error, temp_error);
goto out;
}
if (ret_info)
{
if (out_child != NULL)
{
const char *name = g_file_info_get_name (ret_info);
if (G_UNLIKELY (name == NULL))
{
g_critical ("g_file_enumerator_iterate() created without standard::name");
g_return_val_if_reached (FALSE);
}
else
{
*out_child = g_file_get_child (g_file_enumerator_get_container (direnum), name);
g_object_set_qdata_full ((GObject*)direnum, cached_child_quark, *out_child, (GDestroyNotify)g_object_unref);
}
}
if (out_info != NULL)
{
g_object_set_qdata_full ((GObject*)direnum, cached_info_quark, ret_info, (GDestroyNotify)g_object_unref);
*out_info = ret_info;
}
else
g_object_unref (ret_info);
}
else
{
if (out_info)
*out_info = NULL;
if (out_child)
*out_child = NULL;
}
ret = TRUE;
out:
return ret;
}
/**
* g_file_enumerator_get_container:
* @enumerator: a #GFileEnumerator
*
* Get the #GFile container which is being enumerated.
*
* Returns: (transfer none): the #GFile which is being enumerated.
*
* Since: 2.18
*/
GFile *
g_file_enumerator_get_container (GFileEnumerator *enumerator)
{
g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), NULL);
return enumerator->priv->container;
}
/**
* g_file_enumerator_get_child:
* @enumerator: a #GFileEnumerator
* @info: a #GFileInfo gotten from g_file_enumerator_next_file()
* or the async equivalents.
*
* Return a new #GFile which refers to the file named by @info in the source
* directory of @enumerator. This function is primarily intended to be used
* inside loops with g_file_enumerator_next_file().
*
* To use this, %G_FILE_ATTRIBUTE_STANDARD_NAME must have been listed in the
* attributes list used when creating the #GFileEnumerator.
*
* This is a convenience method that's equivalent to:
* |[<!-- language="C" -->
* gchar *name = g_file_info_get_name (info);
* GFile *child = g_file_get_child (g_file_enumerator_get_container (enumr),
* name);
* ]|
*
* Returns: (transfer full): a #GFile for the #GFileInfo passed it.
*
* Since: 2.36
*/
GFile *
g_file_enumerator_get_child (GFileEnumerator *enumerator,
GFileInfo *info)
{
const gchar *name;
g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), NULL);
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
name = g_file_info_get_name (info);
if (G_UNLIKELY (name == NULL))
{
g_critical ("GFileEnumerator created without standard::name");
g_return_val_if_reached (NULL);
}
return g_file_get_child (enumerator->priv->container, name);
}
static void
next_async_op_free (GList *files)
{
g_list_free_full (files, g_object_unref);
}
static void
next_files_thread (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GFileEnumerator *enumerator = source_object;
int num_files = GPOINTER_TO_INT (task_data);
GFileEnumeratorClass *class;
GList *files = NULL;
GError *error = NULL;
GFileInfo *info;
int i;
class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
for (i = 0; i < num_files; i++)
{
if (g_cancellable_set_error_if_cancelled (cancellable, &error))
info = NULL;
else
info = class->next_file (enumerator, cancellable, &error);
if (info == NULL)
{
/* If we get an error after first file, return that on next operation */
if (error != NULL && i > 0)
{
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_error_free (error); /* Never propagate cancel errors to other call */
else
enumerator->priv->outstanding_error = error;
error = NULL;
}
break;
}
else
files = g_list_prepend (files, info);
}
if (error)
{
g_list_free_full (files, g_object_unref);
g_task_return_error (task, error);
}
else
g_task_return_pointer (task, files, (GDestroyNotify)next_async_op_free);
}
static void
g_file_enumerator_real_next_files_async (GFileEnumerator *enumerator,
int num_files,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
task = g_task_new (enumerator, cancellable, callback, user_data);
g_task_set_source_tag (task, g_file_enumerator_real_next_files_async);
g_task_set_task_data (task, GINT_TO_POINTER (num_files), NULL);
g_task_set_priority (task, io_priority);
g_task_run_in_thread (task, next_files_thread);
g_object_unref (task);
}
static GList *
g_file_enumerator_real_next_files_finish (GFileEnumerator *enumerator,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (g_task_is_valid (result, enumerator), NULL);
return g_task_propagate_pointer (G_TASK (result), error);
}
static void
close_async_thread (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GFileEnumerator *enumerator = source_object;
GFileEnumeratorClass *class;
GError *error = NULL;
gboolean result;
class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
result = class->close_fn (enumerator, cancellable, &error);
if (result)
g_task_return_boolean (task, TRUE);
else
g_task_return_error (task, error);
}
static void
g_file_enumerator_real_close_async (GFileEnumerator *enumerator,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
task = g_task_new (enumerator, cancellable, callback, user_data);
g_task_set_source_tag (task, g_file_enumerator_real_close_async);
g_task_set_priority (task, io_priority);
g_task_run_in_thread (task, close_async_thread);
g_object_unref (task);
}
static gboolean
g_file_enumerator_real_close_finish (GFileEnumerator *enumerator,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (g_task_is_valid (result, enumerator), FALSE);
return g_task_propagate_boolean (G_TASK (result), error);
}
Reference in New Issue View Git Blame Copy Permalink