gio/gfileenumerator.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2006-2007 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: Alexander Larsson <alexl@redhat.com>
  21  */
  22
  23 #include "config.h"
  24 #include "gfileenumerator.h"
  25 #include "gfile.h"
  26 #include "gioscheduler.h"
  27 #include "gasyncresult.h"
  28 #include "gasynchelper.h"
  29 #include "gsimpleasyncresult.h"
  30 #include "gioerror.h"
  31 #include "glibintl.h"
  32
  33 #include "gioalias.h"
  34
  35 /**
  36  * SECTION:gfileenumerator
  37  * @short_description: Enumerated Files Routines
  38  * @include: gio/gio.h
  39  *
  40  * #GFileEnumerator allows you to operate on a set of #GFile<!-- -->s,
  41  * returning a #GFileInfo structure for each file enumerated (e.g.
  42  * g_file_enumerate_children() will return a #GFileEnumerator for each
  43  * of the children within a directory).
  44  *
  45  * To get the next file's information from a #GFileEnumerator, use
  46  * g_file_enumerator_next_file() or its asynchronous version,
  47  * g_file_enumerator_next_files_async(). Note that the asynchronous
  48  * version will return a list of #GFileInfo<!---->s, whereas the
  49  * synchronous will only return the next file in the enumerator.
  50  *
  51  * To close a #GFileEnumerator, use g_file_enumerator_close(), or
  52  * its asynchronous version, g_file_enumerator_close_async(). Once
  53  * a #GFileEnumerator is closed, no further actions may be performed
  54  * on it, and it should be freed with g_object_unref().
  55  *
  56  **/
  57
  58 G_DEFINE_TYPE (GFileEnumerator, g_file_enumerator, G_TYPE_OBJECT);
  59
  60 struct _GFileEnumeratorPrivate {
  61   /* TODO: Should be public for subclasses? */
  62   GFile *container;
  63   guint closed : 1;
  64   guint pending : 1;
  65   GAsyncReadyCallback outstanding_callback;
  66   GError *outstanding_error;
  67 };
  68
  69 enum {
  70   PROP_0,
  71   PROP_CONTAINER
  72 };
  73
  74 static void     g_file_enumerator_real_next_files_async  (GFileEnumerator      *enumerator,
  75                                                           int                   num_files,
  76                                                           int                   io_priority,
  77                                                           GCancellable         *cancellable,
  78                                                           GAsyncReadyCallback   callback,
  79                                                           gpointer              user_data);
  80 static GList *  g_file_enumerator_real_next_files_finish (GFileEnumerator      *enumerator,
  81                                                           GAsyncResult         *res,
  82                                                           GError              **error);
  83 static void     g_file_enumerator_real_close_async       (GFileEnumerator      *enumerator,
  84                                                           int                   io_priority,
  85                                                           GCancellable         *cancellable,
  86                                                           GAsyncReadyCallback   callback,
  87                                                           gpointer              user_data);
  88 static gboolean g_file_enumerator_real_close_finish      (GFileEnumerator      *enumerator,
  89                                                           GAsyncResult         *res,
  90                                                           GError              **error);
  91
  92 static void
  93 g_file_enumerator_set_property (GObject      *object,
  94                                 guint         property_id,
  95                                 const GValue *value,
  96                                 GParamSpec   *pspec)
  97 {
  98   GFileEnumerator *enumerator;
  99
 100   enumerator = G_FILE_ENUMERATOR (object);
 101
 102   switch (property_id) {
 103   case PROP_CONTAINER:
 104     enumerator->priv->container = g_value_dup_object (value);
 105     break;
 106   default:
 107     G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 108     break;
 109   }
 110 }
 111
 112 static void
 113 g_file_enumerator_dispose (GObject *object)
 114 {
 115   GFileEnumerator *enumerator;
 116
 117   enumerator = G_FILE_ENUMERATOR (object);
 118
 119   if (enumerator->priv->container) {
 120     g_object_unref (enumerator->priv->container);
 121     enumerator->priv->container = NULL;
 122   }
 123
 124   G_OBJECT_CLASS (g_file_enumerator_parent_class)->dispose (object);
 125 }
 126
 127 static void
 128 g_file_enumerator_finalize (GObject *object)
 129 {
 130   GFileEnumerator *enumerator;
 131
 132   enumerator = G_FILE_ENUMERATOR (object);
 133
 134   if (!enumerator->priv->closed)
 135     g_file_enumerator_close (enumerator, NULL, NULL);
 136
 137   G_OBJECT_CLASS (g_file_enumerator_parent_class)->finalize (object);
 138 }
 139
 140 static void
 141 g_file_enumerator_class_init (GFileEnumeratorClass *klass)
 142 {
 143   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 144
 145   g_type_class_add_private (klass, sizeof (GFileEnumeratorPrivate));
 146
 147   gobject_class->set_property = g_file_enumerator_set_property;
 148   gobject_class->dispose = g_file_enumerator_dispose;
 149   gobject_class->finalize = g_file_enumerator_finalize;
 150
 151   klass->next_files_async = g_file_enumerator_real_next_files_async;
 152   klass->next_files_finish = g_file_enumerator_real_next_files_finish;
 153   klass->close_async = g_file_enumerator_real_close_async;
 154   klass->close_finish = g_file_enumerator_real_close_finish;
 155
 156   g_object_class_install_property
 157     (gobject_class, PROP_CONTAINER,
 158      g_param_spec_object ("container", P_("Container"),
 159                           P_("The container that is being enumerated"),
 160                           G_TYPE_FILE,
 161                           G_PARAM_WRITABLE |
 162                           G_PARAM_CONSTRUCT_ONLY |
 163                           G_PARAM_STATIC_STRINGS));
 164 }
 165
 166 static void
 167 g_file_enumerator_init (GFileEnumerator *enumerator)
 168 {
 169   enumerator->priv = G_TYPE_INSTANCE_GET_PRIVATE (enumerator,
 170                                                   G_TYPE_FILE_ENUMERATOR,
 171                                                   GFileEnumeratorPrivate);
 172 }
 173
 174 /**
 175  * g_file_enumerator_next_file:
 176  * @enumerator: a #GFileEnumerator.
 177  * @cancellable: optional #GCancellable object, %NULL to ignore.
 178  * @error: location to store the error occuring, or %NULL to ignore
 179  *
 180  * Returns information for the next file in the enumerated object.
 181  * Will block until the information is available. The #GFileInfo
 182  * returned from this function will contain attributes that match the
 183  * attribute string that was passed when the #GFileEnumerator was created.
 184  *
 185  * On error, returns %NULL and sets @error to the error. If the
 186  * enumerator is at the end, %NULL will be returned and @error will
 187  * be unset.
 188  *
 189  * Return value: A #GFileInfo or %NULL on error or end of enumerator.
 190  *    Free the returned object with g_object_unref() when no longer needed.
 191  **/
 192 GFileInfo *
 193 g_file_enumerator_next_file (GFileEnumerator *enumerator,
 194                              GCancellable *cancellable,
 195                              GError **error)
 196 {
 197   GFileEnumeratorClass *class;
 198   GFileInfo *info;
 199
 200   g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), NULL);
 201   g_return_val_if_fail (enumerator != NULL, NULL);
 202
 203   if (enumerator->priv->closed)
 204     {
 205       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
 206                            _("Enumerator is closed"));
 207       return NULL;
 208     }
 209
 210   if (enumerator->priv->pending)
 211     {
 212       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PENDING,
 213                            _("File enumerator has outstanding operation"));
 214       return NULL;
 215     }
 216
 217   if (enumerator->priv->outstanding_error)
 218     {
 219       g_propagate_error (error, enumerator->priv->outstanding_error);
 220       enumerator->priv->outstanding_error = NULL;
 221       return NULL;
 222     }
 223
 224   class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
 225
 226   if (cancellable)
 227     g_cancellable_push_current (cancellable);
 228
 229   enumerator->priv->pending = TRUE;
 230   info = (* class->next_file) (enumerator, cancellable, error);
 231   enumerator->priv->pending = FALSE;
 232
 233   if (cancellable)
 234     g_cancellable_pop_current (cancellable);
 235
 236   return info;
 237 }
 238
 239 /**
 240  * g_file_enumerator_close:
 241  * @enumerator: a #GFileEnumerator.
 242  * @cancellable: optional #GCancellable object, %NULL to ignore.
 243  * @error: location to store the error occuring, or %NULL to ignore
 244  *
 245  * Releases all resources used by this enumerator, making the
 246  * enumerator return %G_IO_ERROR_CLOSED on all calls.
 247  *
 248  * This will be automatically called when the last reference
 249  * is dropped, but you might want to call this function to make
 250  * sure resources are released as early as possible.
 251  *
 252  * Return value: #TRUE on success or #FALSE on error.
 253  **/
 254 gboolean
 255 g_file_enumerator_close (GFileEnumerator  *enumerator,
 256                          GCancellable     *cancellable,
 257                          GError          **error)
 258 {
 259   GFileEnumeratorClass *class;
 260
 261   g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), FALSE);
 262   g_return_val_if_fail (enumerator != NULL, FALSE);
 263
 264   class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
 265
 266   if (enumerator->priv->closed)
 267     return TRUE;
 268
 269   if (enumerator->priv->pending)
 270     {
 271       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PENDING,
 272                            _("File enumerator has outstanding operation"));
 273       return FALSE;
 274     }
 275
 276   if (cancellable)
 277     g_cancellable_push_current (cancellable);
 278
 279   enumerator->priv->pending = TRUE;
 280   (* class->close_fn) (enumerator, cancellable, error);
 281   enumerator->priv->pending = FALSE;
 282   enumerator->priv->closed = TRUE;
 283
 284   if (cancellable)
 285     g_cancellable_pop_current (cancellable);
 286
 287   return TRUE;
 288 }
 289
 290 static void
 291 next_async_callback_wrapper (GObject      *source_object,
 292                              GAsyncResult *res,
 293                              gpointer      user_data)
 294 {
 295   GFileEnumerator *enumerator = G_FILE_ENUMERATOR (source_object);
 296
 297   enumerator->priv->pending = FALSE;
 298   if (enumerator->priv->outstanding_callback)
 299     (*enumerator->priv->outstanding_callback) (source_object, res, user_data);
 300   g_object_unref (enumerator);
 301 }
 302
 303 /**
 304  * g_file_enumerator_next_files_async:
 305  * @enumerator: a #GFileEnumerator.
 306  * @num_files: the number of file info objects to request
 307  * @io_priority: the <link linkend="gioscheduler">io priority</link>
 308  *     of the request.
 309  * @cancellable: optional #GCancellable object, %NULL to ignore.
 310  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
 311  * @user_data: the data to pass to callback function
 312  *
 313  * Request information for a number of files from the enumerator asynchronously.
 314  * When all i/o for the operation is finished the @callback will be called with
 315  * the requested information.
 316  *
 317  * The callback can be called with less than @num_files files in case of error
 318  * or at the end of the enumerator. In case of a partial error the callback will
 319  * be called with any succeeding items and no error, and on the next request the
 320  * error will be reported. If a request is cancelled the callback will be called
 321  * with %G_IO_ERROR_CANCELLED.
 322  *
 323  * During an async request no other sync and async calls are allowed, and will
 324  * result in %G_IO_ERROR_PENDING errors.
 325  *
 326  * Any outstanding i/o request with higher priority (lower numerical value) will
 327  * be executed before an outstanding request with lower priority. Default
 328  * priority is %G_PRIORITY_DEFAULT.
 329  **/
 330 void
 331 g_file_enumerator_next_files_async (GFileEnumerator     *enumerator,
 332                                     int                  num_files,
 333                                     int                  io_priority,
 334                                     GCancellable        *cancellable,
 335                                     GAsyncReadyCallback  callback,
 336                                     gpointer             user_data)
 337 {
 338   GFileEnumeratorClass *class;
 339   GSimpleAsyncResult *simple;
 340
 341   g_return_if_fail (G_IS_FILE_ENUMERATOR (enumerator));
 342   g_return_if_fail (enumerator != NULL);
 343   g_return_if_fail (num_files >= 0);
 344
 345   if (num_files == 0)
 346     {
 347       simple = g_simple_async_result_new (G_OBJECT (enumerator),
 348                                           callback,
 349                                           user_data,
 350                                           g_file_enumerator_next_files_async);
 351       g_simple_async_result_complete_in_idle (simple);
 352       g_object_unref (simple);
 353       return;
 354     }
 355
 356   if (enumerator->priv->closed)
 357     {
 358       g_simple_async_report_error_in_idle (G_OBJECT (enumerator),
 359                                            callback,
 360                                            user_data,
 361                                            G_IO_ERROR, G_IO_ERROR_CLOSED,
 362                                            _("File enumerator is already closed"));
 363       return;
 364     }
 365
 366   if (enumerator->priv->pending)
 367     {
 368       g_simple_async_report_error_in_idle (G_OBJECT (enumerator),
 369                                            callback,
 370                                            user_data,
 371                                            G_IO_ERROR, G_IO_ERROR_PENDING,
 372                                            _("File enumerator has outstanding operation"));
 373       return;
 374     }
 375
 376   class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
 377
 378   enumerator->priv->pending = TRUE;
 379   enumerator->priv->outstanding_callback = callback;
 380   g_object_ref (enumerator);
 381   (* class->next_files_async) (enumerator, num_files, io_priority, cancellable,
 382                                next_async_callback_wrapper, user_data);
 383 }
 384
 385 /**
 386  * g_file_enumerator_next_files_finish:
 387  * @enumerator: a #GFileEnumerator.
 388  * @result: a #GAsyncResult.
 389  * @error: a #GError location to store the error occuring, or %NULL to
 390  * ignore.
 391  *
 392  * Finishes the asynchronous operation started with g_file_enumerator_next_files_async().
 393  *
 394  * Returns: a #GList of #GFileInfo<!---->s. You must free the list with
 395  *     g_list_free() and unref the infos with g_object_unref() when you're
 396  *     done with them.
 397  **/
 398 GList *
 399 g_file_enumerator_next_files_finish (GFileEnumerator  *enumerator,
 400                                      GAsyncResult     *result,
 401                                      GError          **error)
 402 {
 403   GFileEnumeratorClass *class;
 404   GSimpleAsyncResult *simple;
 405
 406   g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), NULL);
 407   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
 408
 409   if (G_IS_SIMPLE_ASYNC_RESULT (result))
 410     {
 411       simple = G_SIMPLE_ASYNC_RESULT (result);
 412       if (g_simple_async_result_propagate_error (simple, error))
 413         return NULL;
 414
 415       /* Special case read of 0 files */
 416       if (g_simple_async_result_get_source_tag (simple) == g_file_enumerator_next_files_async)
 417         return NULL;
 418     }
 419
 420   class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
 421   return class->next_files_finish (enumerator, result, error);
 422 }
 423
 424 static void
 425 close_async_callback_wrapper (GObject      *source_object,
 426                               GAsyncResult *res,
 427                               gpointer      user_data)
 428 {
 429   GFileEnumerator *enumerator = G_FILE_ENUMERATOR (source_object);
 430
 431   enumerator->priv->pending = FALSE;
 432   enumerator->priv->closed = TRUE;
 433   if (enumerator->priv->outstanding_callback)
 434     (*enumerator->priv->outstanding_callback) (source_object, res, user_data);
 435   g_object_unref (enumerator);
 436 }
 437
 438 /**
 439  * g_file_enumerator_close_async:
 440  * @enumerator: a #GFileEnumerator.
 441  * @io_priority: the <link linkend="io-priority">I/O priority</link>
 442  *     of the request.
 443  * @cancellable: optional #GCancellable object, %NULL to ignore.
 444  * @callback: a #GAsyncReadyCallback to call when the request is satisfied
 445  * @user_data: the data to pass to callback function
 446  *
 447  * Asynchronously closes the file enumerator.
 448  *
 449  * If @cancellable is not %NULL, then the operation can be cancelled by
 450  * triggering the cancellable object from another thread. If the operation
 451  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned in
 452  * g_file_enumerator_close_finish().
 453  **/
 454 void
 455 g_file_enumerator_close_async (GFileEnumerator     *enumerator,
 456                                int                  io_priority,
 457                                GCancellable        *cancellable,
 458                                GAsyncReadyCallback  callback,
 459                                gpointer             user_data)
 460 {
 461   GFileEnumeratorClass *class;
 462
 463   g_return_if_fail (G_IS_FILE_ENUMERATOR (enumerator));
 464
 465   if (enumerator->priv->closed)
 466     {
 467       g_simple_async_report_error_in_idle (G_OBJECT (enumerator),
 468                                            callback,
 469                                            user_data,
 470                                            G_IO_ERROR, G_IO_ERROR_CLOSED,
 471                                            _("File enumerator is already closed"));
 472       return;
 473     }
 474
 475   if (enumerator->priv->pending)
 476     {
 477       g_simple_async_report_error_in_idle (G_OBJECT (enumerator),
 478                                            callback,
 479                                            user_data,
 480                                            G_IO_ERROR, G_IO_ERROR_PENDING,
 481                                            _("File enumerator has outstanding operation"));
 482       return;
 483     }
 484
 485   class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
 486
 487   enumerator->priv->pending = TRUE;
 488   enumerator->priv->outstanding_callback = callback;
 489   g_object_ref (enumerator);
 490   (* class->close_async) (enumerator, io_priority, cancellable,
 491                           close_async_callback_wrapper, user_data);
 492 }
 493
 494 /**
 495  * g_file_enumerator_close_finish:
 496  * @enumerator: a #GFileEnumerator.
 497  * @result: a #GAsyncResult.
 498  * @error: a #GError location to store the error occuring, or %NULL to
 499  * ignore.
 500  *
 501  * Finishes closing a file enumerator, started from g_file_enumerator_close_async().
 502  *
 503  * If the file enumerator was already closed when g_file_enumerator_close_async()
 504  * was called, then this function will report %G_IO_ERROR_CLOSED in @error, and
 505  * return %FALSE. If the file enumerator had pending operation when the close
 506  * operation was started, then this function will report %G_IO_ERROR_PENDING, and
 507  * return %FALSE.  If @cancellable was not %NULL, then the operation may have been
 508  * cancelled by triggering the cancellable object from another thread. If the operation
 509  * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %FALSE will be
 510  * returned.
 511  *
 512  * Returns: %TRUE if the close operation has finished successfully.
 513  **/
 514 gboolean
 515 g_file_enumerator_close_finish (GFileEnumerator  *enumerator,
 516                                 GAsyncResult     *result,
 517                                 GError          **error)
 518 {
 519   GSimpleAsyncResult *simple;
 520   GFileEnumeratorClass *class;
 521
 522   g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), FALSE);
 523   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
 524
 525   if (G_IS_SIMPLE_ASYNC_RESULT (result))
 526     {
 527       simple = G_SIMPLE_ASYNC_RESULT (result);
 528       if (g_simple_async_result_propagate_error (simple, error))
 529         return FALSE;
 530     }
 531
 532   class = G_FILE_ENUMERATOR_GET_CLASS (enumerator);
 533   return class->close_finish (enumerator, result, error);
 534 }
 535
 536 /**
 537  * g_file_enumerator_is_closed:
 538  * @enumerator: a #GFileEnumerator.
 539  *
 540  * Checks if the file enumerator has been closed.
 541  *
 542  * Returns: %TRUE if the @enumerator is closed.
 543  **/
 544 gboolean
 545 g_file_enumerator_is_closed (GFileEnumerator *enumerator)
 546 {
 547   g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), TRUE);
 548
 549   return enumerator->priv->closed;
 550 }
 551
 552 /**
 553  * g_file_enumerator_has_pending:
 554  * @enumerator: a #GFileEnumerator.
 555  *
 556  * Checks if the file enumerator has pending operations.
 557  *
 558  * Returns: %TRUE if the @enumerator has pending operations.
 559  **/
 560 gboolean
 561 g_file_enumerator_has_pending (GFileEnumerator *enumerator)
 562 {
 563   g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), TRUE);
 564
 565   return enumerator->priv->pending;
 566 }
 567
 568 /**
 569  * g_file_enumerator_set_pending:
 570  * @enumerator: a #GFileEnumerator.
 571  * @pending: a boolean value.
 572  *
 573  * Sets the file enumerator as having pending operations.
 574  **/
 575 void
 576 g_file_enumerator_set_pending (GFileEnumerator *enumerator,
 577                                gboolean         pending)
 578 {
 579   g_return_if_fail (G_IS_FILE_ENUMERATOR (enumerator));
 580
 581   enumerator->priv->pending = pending;
 582 }
 583
 584 /**
 585  * g_file_enumerator_get_container:
 586  * @enumerator: a #GFileEnumerator
 587  *
 588  * Get the #GFile container which is being enumerated.
 589  *
 590  * Returns: the #GFile which is being enumerated.
 591  *
 592  * Since: 2.18
 593  */
 594 GFile *
 595 g_file_enumerator_get_container (GFileEnumerator *enumerator)
 596 {
 597   g_return_val_if_fail (G_IS_FILE_ENUMERATOR (enumerator), NULL);
 598
 599   return enumerator->priv->container;
 600 }
 601
 602 typedef struct {
 603   int                num_files;
 604   GList             *files;
 605 } NextAsyncOp;
 606
 607 static void
 608 next_async_op_free (NextAsyncOp *op)
 609 {
 610   /* Free the list, if finish wasn't called */
 611   g_list_foreach (op->files, (GFunc)g_object_unref, NULL);
 612   g_list_free (op->files);
 613
 614   g_free (op);
 615 }
 616
 617
 618
 619 static void
 620 next_files_thread (GSimpleAsyncResult *res,
 621                    GObject            *object,
 622                    GCancellable       *cancellable)
 623 {
 624   NextAsyncOp *op;
 625   GFileEnumeratorClass *class;
 626   GError *error = NULL;
 627   GFileInfo *info;
 628   GFileEnumerator *enumerator;
 629   int i;
 630
 631   enumerator = G_FILE_ENUMERATOR (object);
 632   op = g_simple_async_result_get_op_res_gpointer (res);
 633
 634   class = G_FILE_ENUMERATOR_GET_CLASS (object);
 635
 636   for (i = 0; i < op->num_files; i++)
 637     {
 638       if (g_cancellable_set_error_if_cancelled (cancellable, &error))
 639         info = NULL;
 640       else
 641         info = class->next_file (enumerator, cancellable, &error);
 642
 643       if (info == NULL)
 644         {
 645           /* If we get an error after first file, return that on next operation */
 646           if (error != NULL && i > 0)
 647             {
 648               if (error->domain == G_IO_ERROR &&
 649                   error->code == G_IO_ERROR_CANCELLED)
 650                 g_error_free (error); /* Never propagate cancel errors to other call */
 651               else
 652                 enumerator->priv->outstanding_error = error;
 653               error = NULL;
 654             }
 655
 656           break;
 657         }
 658       else
 659         op->files = g_list_prepend (op->files, info);
 660     }
 661 }
 662
 663 static void
 664 g_file_enumerator_real_next_files_async (GFileEnumerator     *enumerator,
 665                                          int                  num_files,
 666                                          int                  io_priority,
 667                                          GCancellable        *cancellable,
 668                                          GAsyncReadyCallback  callback,
 669                                          gpointer             user_data)
 670 {
 671   GSimpleAsyncResult *res;
 672   NextAsyncOp *op;
 673
 674   op = g_new0 (NextAsyncOp, 1);
 675
 676   op->num_files = num_files;
 677   op->files = NULL;
 678
 679   res = g_simple_async_result_new (G_OBJECT (enumerator), callback, user_data, g_file_enumerator_real_next_files_async);
 680   g_simple_async_result_set_op_res_gpointer (res, op, (GDestroyNotify) next_async_op_free);
 681
 682   g_simple_async_result_run_in_thread (res, next_files_thread, io_priority, cancellable);
 683   g_object_unref (res);
 684 }
 685
 686 static GList *
 687 g_file_enumerator_real_next_files_finish (GFileEnumerator                *enumerator,
 688                                           GAsyncResult                   *result,
 689                                           GError                        **error)
 690 {
 691   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
 692   NextAsyncOp *op;
 693   GList *res;
 694
 695   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) ==
 696             g_file_enumerator_real_next_files_async);
 697
 698   op = g_simple_async_result_get_op_res_gpointer (simple);
 699
 700   res = op->files;
 701   op->files = NULL;
 702   return res;
 703 }
 704
 705 static void
 706 close_async_thread (GSimpleAsyncResult *res,
 707                     GObject            *object,
 708                     GCancellable       *cancellable)
 709 {
 710   GFileEnumeratorClass *class;
 711   GError *error = NULL;
 712   gboolean result;
 713
 714   /* Auto handling of cancelation disabled, and ignore
 715      cancellation, since we want to close things anyway, although
 716      possibly in a quick-n-dirty way. At least we never want to leak
 717      open handles */
 718
 719   class = G_FILE_ENUMERATOR_GET_CLASS (object);
 720   result = class->close_fn (G_FILE_ENUMERATOR (object), cancellable, &error);
 721   if (!result)
 722     {
 723       g_simple_async_result_set_from_error (res, error);
 724       g_error_free (error);
 725     }
 726 }
 727
 728
 729 static void
 730 g_file_enumerator_real_close_async (GFileEnumerator     *enumerator,
 731                                     int                  io_priority,
 732                                     GCancellable        *cancellable,
 733                                     GAsyncReadyCallback  callback,
 734                                     gpointer             user_data)
 735 {
 736   GSimpleAsyncResult *res;
 737
 738   res = g_simple_async_result_new (G_OBJECT (enumerator),
 739                                    callback,
 740                                    user_data,
 741                                    g_file_enumerator_real_close_async);
 742
 743   g_simple_async_result_set_handle_cancellation (res, FALSE);
 744
 745   g_simple_async_result_run_in_thread (res,
 746                                        close_async_thread,
 747                                        io_priority,
 748                                        cancellable);
 749   g_object_unref (res);
 750 }
 751
 752 static gboolean
 753 g_file_enumerator_real_close_finish (GFileEnumerator  *enumerator,
 754                                      GAsyncResult     *result,
 755                                      GError          **error)
 756 {
 757   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
 758   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) ==
 759             g_file_enumerator_real_close_async);
 760   return TRUE;
 761 }
 762
 763 #define __G_FILE_ENUMERATOR_C__
 764 #include "gioaliasdef.c"