mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-12-26 07:26:15 +01:00
18a33f72db
If we have an input parameter (or return value) we need to use (nullable). However, if it is an (inout) or (out) parameter, (optional) is sufficient. It looks like (nullable) could be used for everything according to the Annotation documentation, but (optional) is more specific.
870 lines
28 KiB
C
870 lines
28 KiB
C
/* GIO - GLib Input, Output and Streaming Library
|
|
*
|
|
* Copyright (C) 2006-2007 Red Hat, Inc.
|
|
*
|
|
* 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 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): a #GAsyncReadyCallback to call when the request is satisfied
|
|
* @user_data: (closure): 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.
|
|
*
|
|
* 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 %G_IO_ERROR_CANCELLED.
|
|
*
|
|
* 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): a #GAsyncReadyCallback to call when the request is satisfied
|
|
* @user_data: (closure): 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_warning ("g_file_enumerator_iterate() created without standard::name");
|
|
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().
|
|
*
|
|
* 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)
|
|
{
|
|
g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), NULL);
|
|
|
|
return g_file_get_child (enumerator->priv->container,
|
|
g_file_info_get_name (info));
|
|
}
|
|
|
|
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_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);
|
|
}
|
|
|