gio/gsimpleasyncresult.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
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <string.h>
  28 #include <errno.h>
  29 #include <fcntl.h>
  30 #ifdef HAVE_UNISTD_H
  31 #include <unistd.h>
  32 #endif
  33
  34 #include "gsimpleasyncresult.h"
  35 #include "gasyncresult.h"
  36 #include "gcancellable.h"
  37 #include "gioscheduler.h"
  38 #include <gio/gioerror.h>
  39 #include "glibintl.h"
  40
  41 #include "gioalias.h"
  42
  43 /**
  44  * SECTION:gsimpleasyncresult
  45  * @short_description: Simple asynchronous results implementation
  46  * @include: gio/gio.h
  47  * @see_also: #GAsyncResult
  48  *
  49  * Implements #GAsyncResult for simple cases. Most of the time, this
  50  * will be all an application needs, and will be used transparently.
  51  * Because of this, #GSimpleAsyncResult is used throughout GIO for
  52  * handling asynchronous functions.
  53  *
  54  * GSimpleAsyncResult handles #GAsyncReadyCallback<!-- -->s, error
  55  * reporting, operation cancellation and the final state of an operation,
  56  * completely transparent to the application. Results can be returned
  57  * as a pointer e.g. for functions that return data that is collected
  58  * asynchronously, a boolean value for checking the success or failure
  59  * of an operation, or a #gssize for operations which return the number
  60  * of bytes modified by the operation; all of the simple return cases
  61  * are covered.
  62  *
  63  * Most of the time, an application will not need to know of the details
  64  * of this API; it is handled transparently, and any necessary operations
  65  * are handled by #GAsyncResult's interface. However, if implementing a
  66  * new GIO module, for writing language bindings, or for complex
  67  * applications that need better control of how asynchronous operations
  68  * are completed, it is important to understand this functionality.
  69  *
  70  * GSimpleAsyncResults are tagged with the calling function to ensure
  71  * that asynchronous functions and their finishing functions are used
  72  * together correctly.
  73  *
  74  * To create a new #GSimpleAsyncResult, call g_simple_async_result_new().
  75  * If the result needs to be created for a #GError, use
  76  * g_simple_async_result_new_from_error(). If a #GError is not available
  77  * (e.g. the asynchronous operation's doesn't take a #GError argument),
  78  * but the result still needs to be created for an error condition, use
  79  * g_simple_async_result_new_error() (or g_simple_async_result_set_error_va()
  80  * if your application or binding requires passing a variable argument list
  81  * directly), and the error can then be propegated through the use of
  82  * g_simple_async_result_propagate_error().
  83  *
  84  * An asynchronous operation can be made to ignore a cancellation event by
  85  * calling g_simple_async_result_set_handle_cancellation() with a
  86  * #GSimpleAsyncResult for the operation and %FALSE.
  87  *
  88  * GSimpleAsyncResult can integrate into GLib's event loop, #GMainLoop,
  89  * or it can use #GThread<!-- -->s if available.
  90  * g_simple_async_result_complete() will finish an I/O task directly within
  91  * the main event loop. g_simple_async_result_complete_in_idle() will
  92  * integrate the I/O task into the main event loop as an idle function and
  93  * g_simple_async_result_run_in_thread() will run the job in a separate
  94  * thread.
  95  *
  96  * To set the results of an asynchronous function,
  97  * g_simple_async_result_set_op_res_gpointer(),
  98  * g_simple_async_result_set_op_res_gboolean(), and
  99  * g_simple_async_result_set_op_res_gssize()
 100  * are provided, setting the operation's result to a gpointer, gboolean, or
 101  * gssize, respectively.
 102  *
 103  * Likewise, to get the result of an asynchronous function,
 104  * g_simple_async_result_get_op_res_gpointer(),
 105  * g_simple_async_result_get_op_res_gboolean(), and
 106  * g_simple_async_result_get_op_res_gssize() are
 107  * provided, getting the operation's result as a gpointer, gboolean, and
 108  * gssize, respectively.
 109  **/
 110
 111 static void g_simple_async_result_async_result_iface_init (GAsyncResultIface       *iface);
 112
 113 struct _GSimpleAsyncResult
 114 {
 115   GObject parent_instance;
 116
 117   GObject *source_object;
 118   GAsyncReadyCallback callback;
 119   gpointer user_data;
 120   GError *error;
 121   gboolean failed;
 122   gboolean handle_cancellation;
 123
 124   gpointer source_tag;
 125
 126   union {
 127     gpointer v_pointer;
 128     gboolean v_boolean;
 129     gssize   v_ssize;
 130   } op_res;
 131
 132   GDestroyNotify destroy_op_res;
 133 };
 134
 135 struct _GSimpleAsyncResultClass
 136 {
 137   GObjectClass parent_class;
 138 };
 139
 140
 141 G_DEFINE_TYPE_WITH_CODE (GSimpleAsyncResult, g_simple_async_result, G_TYPE_OBJECT,
 142                          G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_RESULT,
 143                                                 g_simple_async_result_async_result_iface_init))
 144
 145 static void
 146 g_simple_async_result_finalize (GObject *object)
 147 {
 148   GSimpleAsyncResult *simple;
 149
 150   simple = G_SIMPLE_ASYNC_RESULT (object);
 151
 152   if (simple->source_object)
 153     g_object_unref (simple->source_object);
 154
 155   if (simple->destroy_op_res)
 156     simple->destroy_op_res (simple->op_res.v_pointer);
 157
 158   if (simple->error)
 159     g_error_free (simple->error);
 160
 161   G_OBJECT_CLASS (g_simple_async_result_parent_class)->finalize (object);
 162 }
 163
 164 static void
 165 g_simple_async_result_class_init (GSimpleAsyncResultClass *klass)
 166 {
 167   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 168
 169   gobject_class->finalize = g_simple_async_result_finalize;
 170 }
 171
 172 static void
 173 g_simple_async_result_init (GSimpleAsyncResult *simple)
 174 {
 175   simple->handle_cancellation = TRUE;
 176 }
 177
 178 /**
 179  * g_simple_async_result_new:
 180  * @source_object: a #GObject the asynchronous function was called with.
 181  * @callback: a #GAsyncReadyCallback.
 182  * @user_data: user data passed to @callback.
 183  * @source_tag: the asynchronous function.
 184  *
 185  * Creates a #GSimpleAsyncResult.
 186  *
 187  * Returns: a #GSimpleAsyncResult.
 188  **/
 189 GSimpleAsyncResult *
 190 g_simple_async_result_new (GObject             *source_object,
 191                            GAsyncReadyCallback  callback,
 192                            gpointer             user_data,
 193                            gpointer             source_tag)
 194 {
 195   GSimpleAsyncResult *simple;
 196
 197   g_return_val_if_fail (G_IS_OBJECT (source_object), NULL);
 198
 199   simple = g_object_new (G_TYPE_SIMPLE_ASYNC_RESULT, NULL);
 200   simple->callback = callback;
 201   simple->source_object = g_object_ref (source_object);
 202   simple->user_data = user_data;
 203   simple->source_tag = source_tag;
 204
 205   return simple;
 206 }
 207
 208 /**
 209  * g_simple_async_result_new_from_error:
 210  * @source_object: a #GObject.
 211  * @callback: a #GAsyncReadyCallback.
 212  * @user_data: user data passed to @callback.
 213  * @error: a #GError location.
 214  *
 215  * Creates a #GSimpleAsyncResult from an error condition.
 216  *
 217  * Returns: a #GSimpleAsyncResult.
 218  **/
 219 GSimpleAsyncResult *
 220 g_simple_async_result_new_from_error (GObject             *source_object,
 221                                       GAsyncReadyCallback  callback,
 222                                       gpointer             user_data,
 223                                       GError              *error)
 224 {
 225   GSimpleAsyncResult *simple;
 226
 227   g_return_val_if_fail (G_IS_OBJECT (source_object), NULL);
 228
 229   simple = g_simple_async_result_new (source_object,
 230                                       callback,
 231                                       user_data, NULL);
 232   g_simple_async_result_set_from_error (simple, error);
 233
 234   return simple;
 235 }
 236
 237 /**
 238  * g_simple_async_result_new_error:
 239  * @source_object: a #GObject.
 240  * @callback: a #GAsyncReadyCallback.
 241  * @user_data: user data passed to @callback.
 242  * @domain: a #GQuark.
 243  * @code: an error code.
 244  * @format: a string with format characters.
 245  * @...: a list of values to insert into @format.
 246  *
 247  * Creates a new #GSimpleAsyncResult with a set error.
 248  *
 249  * Returns: a #GSimpleAsyncResult.
 250  **/
 251 GSimpleAsyncResult *
 252 g_simple_async_result_new_error (GObject             *source_object,
 253                                  GAsyncReadyCallback  callback,
 254                                  gpointer             user_data,
 255                                  GQuark               domain,
 256                                  gint                 code,
 257                                  const char          *format,
 258                                  ...)
 259 {
 260   GSimpleAsyncResult *simple;
 261   va_list args;
 262
 263   g_return_val_if_fail (G_IS_OBJECT (source_object), NULL);
 264   g_return_val_if_fail (domain != 0, NULL);
 265   g_return_val_if_fail (format != NULL, NULL);
 266
 267   simple = g_simple_async_result_new (source_object,
 268                                       callback,
 269                                       user_data, NULL);
 270
 271   va_start (args, format);
 272   g_simple_async_result_set_error_va (simple, domain, code, format, args);
 273   va_end (args);
 274
 275   return simple;
 276 }
 277
 278
 279 static gpointer
 280 g_simple_async_result_get_user_data (GAsyncResult *res)
 281 {
 282   return G_SIMPLE_ASYNC_RESULT (res)->user_data;
 283 }
 284
 285 static GObject *
 286 g_simple_async_result_get_source_object (GAsyncResult *res)
 287 {
 288   if (G_SIMPLE_ASYNC_RESULT (res)->source_object)
 289     return g_object_ref (G_SIMPLE_ASYNC_RESULT (res)->source_object);
 290   return NULL;
 291 }
 292
 293 static void
 294 g_simple_async_result_async_result_iface_init (GAsyncResultIface *iface)
 295 {
 296   iface->get_user_data = g_simple_async_result_get_user_data;
 297   iface->get_source_object = g_simple_async_result_get_source_object;
 298 }
 299
 300 /**
 301  * g_simple_async_result_set_handle_cancellation:
 302  * @simple: a #GSimpleAsyncResult.
 303  * @handle_cancellation: a #gboolean.
 304  *
 305  * Sets whether to handle cancellation within the asynchronous operation.
 306  *
 307  **/
 308 void
 309 g_simple_async_result_set_handle_cancellation (GSimpleAsyncResult *simple,
 310                                                gboolean            handle_cancellation)
 311 {
 312   g_return_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple));
 313   simple->handle_cancellation = handle_cancellation;
 314 }
 315
 316 /**
 317  * g_simple_async_result_get_source_tag:
 318  * @simple: a #GSimpleAsyncResult.
 319  *
 320  * Gets the source tag for the #GSimpleAsyncResult.
 321  *
 322  * Returns: a #gpointer to the source object for the #GSimpleAsyncResult.
 323  **/
 324 gpointer
 325 g_simple_async_result_get_source_tag (GSimpleAsyncResult *simple)
 326 {
 327   g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple), NULL);
 328   return simple->source_tag;
 329 }
 330
 331 /**
 332  * g_simple_async_result_propagate_error:
 333  * @simple: a #GSimpleAsyncResult.
 334  * @dest: a location to propegate the error to.
 335  *
 336  * Propagates an error from within the simple asynchronous result to
 337  * a given destination.
 338  *
 339  * Returns: %TRUE if the error was propegated to @dest. %FALSE otherwise.
 340  **/
 341 gboolean
 342 g_simple_async_result_propagate_error (GSimpleAsyncResult  *simple,
 343                                        GError             **dest)
 344 {
 345   g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple), FALSE);
 346
 347   if (simple->failed)
 348     {
 349       g_propagate_error (dest, simple->error);
 350       simple->error = NULL;
 351       return TRUE;
 352     }
 353
 354   return FALSE;
 355 }
 356
 357 /**
 358  * g_simple_async_result_set_op_res_gpointer:
 359  * @simple: a #GSimpleAsyncResult.
 360  * @op_res: a pointer result from an asynchronous function.
 361  * @destroy_op_res: a #GDestroyNotify function.
 362  *
 363  * Sets the operation result within the asynchronous result to a pointer.
 364  **/
 365 void
 366 g_simple_async_result_set_op_res_gpointer (GSimpleAsyncResult *simple,
 367                                            gpointer            op_res,
 368                                            GDestroyNotify      destroy_op_res)
 369 {
 370   g_return_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple));
 371
 372   simple->op_res.v_pointer = op_res;
 373   simple->destroy_op_res = destroy_op_res;
 374 }
 375
 376 /**
 377  * g_simple_async_result_get_op_res_gpointer:
 378  * @simple: a #GSimpleAsyncResult.
 379  *
 380  * Gets a pointer result as returned by the asynchronous function.
 381  *
 382  * Returns: a pointer from the result.
 383  **/
 384 gpointer
 385 g_simple_async_result_get_op_res_gpointer (GSimpleAsyncResult *simple)
 386 {
 387   g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple), NULL);
 388   return simple->op_res.v_pointer;
 389 }
 390
 391 /**
 392  * g_simple_async_result_set_op_res_gssize:
 393  * @simple: a #GSimpleAsyncResult.
 394  * @op_res: a #gssize.
 395  *
 396  * Sets the operation result within the asynchronous result to
 397  * the given @op_res.
 398  **/
 399 void
 400 g_simple_async_result_set_op_res_gssize (GSimpleAsyncResult *simple,
 401                                          gssize              op_res)
 402 {
 403   g_return_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple));
 404   simple->op_res.v_ssize = op_res;
 405 }
 406
 407 /**
 408  * g_simple_async_result_get_op_res_gssize:
 409  * @simple: a #GSimpleAsyncResult.
 410  *
 411  * Gets a gssize from the asynchronous result.
 412  *
 413  * Returns: a gssize returned from the asynchronous function.
 414  **/
 415 gssize
 416 g_simple_async_result_get_op_res_gssize (GSimpleAsyncResult *simple)
 417 {
 418   g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple), 0);
 419   return simple->op_res.v_ssize;
 420 }
 421
 422 /**
 423  * g_simple_async_result_set_op_res_gboolean:
 424  * @simple: a #GSimpleAsyncResult.
 425  * @op_res: a #gboolean.
 426  *
 427  * Sets the operation result to a boolean within the asynchronous result.
 428  **/
 429 void
 430 g_simple_async_result_set_op_res_gboolean (GSimpleAsyncResult *simple,
 431                                            gboolean            op_res)
 432 {
 433   g_return_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple));
 434   simple->op_res.v_boolean = !!op_res;
 435 }
 436
 437 /**
 438  * g_simple_async_result_get_op_res_gboolean:
 439  * @simple: a #GSimpleAsyncResult.
 440  *
 441  * Gets the operation result boolean from within the asynchronous result.
 442  *
 443  * Returns: %TRUE if the operation's result was %TRUE, %FALSE
 444  *     if the operation's result was %FALSE.
 445  **/
 446 gboolean
 447 g_simple_async_result_get_op_res_gboolean (GSimpleAsyncResult *simple)
 448 {
 449   g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple), FALSE);
 450   return simple->op_res.v_boolean;
 451 }
 452
 453 /**
 454  * g_simple_async_result_set_from_error:
 455  * @simple: a #GSimpleAsyncResult.
 456  * @error: #GError.
 457  *
 458  * Sets the result from a #GError.
 459  **/
 460 void
 461 g_simple_async_result_set_from_error (GSimpleAsyncResult *simple,
 462                                       GError             *error)
 463 {
 464   g_return_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple));
 465   g_return_if_fail (error != NULL);
 466
 467   simple->error = g_error_copy (error);
 468   simple->failed = TRUE;
 469 }
 470
 471 static GError*
 472 _g_error_new_valist (GQuark     domain,
 473                     gint        code,
 474                     const char *format,
 475                     va_list     args)
 476 {
 477   GError *error;
 478   char *message;
 479
 480   message = g_strdup_vprintf (format, args);
 481
 482   error = g_error_new_literal (domain, code, message);
 483   g_free (message);
 484
 485   return error;
 486 }
 487
 488 /**
 489  * g_simple_async_result_set_error_va:
 490  * @simple: a #GSimpleAsyncResult.
 491  * @domain: a #GQuark (usually #G_IO_ERROR).
 492  * @code: an error code.
 493  * @format: a formatted error reporting string.
 494  * @args: va_list of arguments.
 495  *
 496  * Sets an error within the asynchronous result without a #GError.
 497  * Unless writing a binding, see g_simple_async_result_set_error().
 498  **/
 499 void
 500 g_simple_async_result_set_error_va (GSimpleAsyncResult *simple,
 501                                     GQuark              domain,
 502                                     gint                code,
 503                                     const char         *format,
 504                                     va_list             args)
 505 {
 506   g_return_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple));
 507   g_return_if_fail (domain != 0);
 508   g_return_if_fail (format != NULL);
 509
 510   simple->error = _g_error_new_valist (domain, code, format, args);
 511   simple->failed = TRUE;
 512 }
 513
 514 /**
 515  * g_simple_async_result_set_error:
 516  * @simple: a #GSimpleAsyncResult.
 517  * @domain: a #GQuark (usually #G_IO_ERROR).
 518  * @code: an error code.
 519  * @format: a formatted error reporting string.
 520  * @...: a list of variables to fill in @format.
 521  *
 522  * Sets an error within the asynchronous result without a #GError.
 523  **/
 524 void
 525 g_simple_async_result_set_error (GSimpleAsyncResult *simple,
 526                                  GQuark              domain,
 527                                  gint                code,
 528                                  const char         *format,
 529                                  ...)
 530 {
 531   va_list args;
 532
 533   g_return_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple));
 534   g_return_if_fail (domain != 0);
 535   g_return_if_fail (format != NULL);
 536
 537   va_start (args, format);
 538   g_simple_async_result_set_error_va (simple, domain, code, format, args);
 539   va_end (args);
 540 }
 541
 542 /**
 543  * g_simple_async_result_complete:
 544  * @simple: a #GSimpleAsyncResult.
 545  *
 546  * Completes an asynchronous I/O job.
 547  **/
 548 void
 549 g_simple_async_result_complete (GSimpleAsyncResult *simple)
 550 {
 551   g_return_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple));
 552
 553   if (simple->callback)
 554     simple->callback (simple->source_object,
 555                       G_ASYNC_RESULT (simple),
 556                       simple->user_data);
 557 }
 558
 559 static gboolean
 560 complete_in_idle_cb (gpointer data)
 561 {
 562   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (data);
 563
 564   g_simple_async_result_complete (simple);
 565
 566   return FALSE;
 567 }
 568
 569 /**
 570  * g_simple_async_result_complete_in_idle:
 571  * @simple: a #GSimpleAsyncResult.
 572  *
 573  * Completes an asynchronous function in the main event loop using
 574  * an idle function.
 575  **/
 576 void
 577 g_simple_async_result_complete_in_idle (GSimpleAsyncResult *simple)
 578 {
 579   GSource *source;
 580   guint id;
 581
 582   g_return_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple));
 583
 584   g_object_ref (simple);
 585
 586   source = g_idle_source_new ();
 587   g_source_set_priority (source, G_PRIORITY_DEFAULT);
 588   g_source_set_callback (source, complete_in_idle_cb, simple, g_object_unref);
 589
 590   id = g_source_attach (source, NULL);
 591   g_source_unref (source);
 592 }
 593
 594 typedef struct {
 595   GSimpleAsyncResult *simple;
 596   GSimpleAsyncThreadFunc func;
 597 } RunInThreadData;
 598
 599 static gboolean
 600 run_in_thread (GIOSchedulerJob *job,
 601                GCancellable    *c,
 602                gpointer         _data)
 603 {
 604   RunInThreadData *data = _data;
 605   GSimpleAsyncResult *simple = data->simple;
 606
 607   if (simple->handle_cancellation &&
 608       g_cancellable_is_cancelled (c))
 609     g_simple_async_result_set_error (simple,
 610                                      G_IO_ERROR,
 611                                      G_IO_ERROR_CANCELLED,
 612                                      _("Operation was cancelled"));
 613   else
 614     data->func (simple,
 615                 simple->source_object,
 616                 c);
 617
 618   g_simple_async_result_complete_in_idle (data->simple);
 619   g_object_unref (data->simple);
 620   g_free (data);
 621
 622   return FALSE;
 623 }
 624
 625 /**
 626  * g_simple_async_result_run_in_thread:
 627  * @simple: a #GSimpleAsyncResult.
 628  * @func: a #GSimpleAsyncThreadFunc.
 629  * @io_priority: the io priority of the request.
 630  * @cancellable: optional #GCancellable object, %NULL to ignore.
 631  *
 632  * Runs the asynchronous job in a separated thread.
 633  **/
 634 void
 635 g_simple_async_result_run_in_thread (GSimpleAsyncResult     *simple,
 636                                      GSimpleAsyncThreadFunc  func,
 637                                      int                     io_priority,
 638                                      GCancellable           *cancellable)
 639 {
 640   RunInThreadData *data;
 641
 642   g_return_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple));
 643   g_return_if_fail (func != NULL);
 644
 645   data = g_new (RunInThreadData, 1);
 646   data->func = func;
 647   data->simple = g_object_ref (simple);
 648   g_io_scheduler_push_job (run_in_thread, data, NULL, io_priority, cancellable);
 649 }
 650
 651 /**
 652  * g_simple_async_report_error_in_idle:
 653  * @object: a #GObject.
 654  * @callback: a #GAsyncReadyCallback.
 655  * @user_data: user data passed to @callback.
 656  * @domain: a #GQuark containing the error domain (usually #G_IO_ERROR).
 657  * @code: a specific error code.
 658  * @format: a formatted error reporting string.
 659  * @...: a list of variables to fill in @format.
 660  *
 661  * Reports an error in an asynchronous function in an idle function by
 662  * directly setting the contents of the #GAsyncResult with the given error
 663  * information.
 664  **/
 665 void
 666 g_simple_async_report_error_in_idle (GObject             *object,
 667                                      GAsyncReadyCallback  callback,
 668                                      gpointer             user_data,
 669                                      GQuark               domain,
 670                                      gint                 code,
 671                                      const char          *format,
 672                                      ...)
 673 {
 674   GSimpleAsyncResult *simple;
 675   va_list args;
 676
 677   g_return_if_fail (G_IS_OBJECT (object));
 678   g_return_if_fail (domain != 0);
 679   g_return_if_fail (format != NULL);
 680
 681   simple = g_simple_async_result_new (object,
 682                                       callback,
 683                                       user_data, NULL);
 684
 685   va_start (args, format);
 686   g_simple_async_result_set_error_va (simple, domain, code, format, args);
 687   va_end (args);
 688   g_simple_async_result_complete_in_idle (simple);
 689   g_object_unref (simple);
 690 }
 691
 692 /**
 693  * g_simple_async_report_gerror_in_idle:
 694  * @object: a #GObject.
 695  * @callback: a #GAsyncReadyCallback.
 696  * @user_data: user data passed to @callback.
 697  * @error: the #GError to report
 698  *
 699  * Reports an error in an idle function. Similar to
 700  * g_simple_async_report_error_in_idle(), but takes a #GError rather
 701  * than building a new one.
 702  **/
 703 void
 704 g_simple_async_report_gerror_in_idle (GObject *object,
 705                                       GAsyncReadyCallback callback,
 706                                       gpointer user_data,
 707                                       GError *error)
 708 {
 709   GSimpleAsyncResult *simple;
 710
 711   g_return_if_fail (G_IS_OBJECT (object));
 712   g_return_if_fail (error != NULL);
 713
 714   simple = g_simple_async_result_new_from_error (object,
 715                                                  callback,
 716                                                  user_data,
 717                                                  error);
 718   g_simple_async_result_complete_in_idle (simple);
 719   g_object_unref (simple);
 720 }
 721
 722 #define __G_SIMPLE_ASYNC_RESULT_C__
 723 #include "gioaliasdef.c"