自学教程：C++ G_IS_ASYNC_RESULT函数代码示例

/** * g_dbus_address_get_stream_finish: * @res: A #GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_address_get_stream(). * @out_guid: %NULL or return location to store the GUID extracted from @address, if any. * @error: Return location for error or %NULL. * * Finishes an operation started with g_dbus_address_get_stream(). * * Returns: (transfer full): A #GIOStream or %NULL if @error is set. * * Since: 2.26 */GIOStream *g_dbus_address_get_stream_finish (GAsyncResult        *res,                                  gchar              **out_guid,                                  GError             **error){  GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);  GetStreamData *data;  GIOStream *ret;  g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);  g_return_val_if_fail (error == NULL || *error == NULL, NULL);  g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_dbus_address_get_stream);  ret = NULL;  data = g_simple_async_result_get_op_res_gpointer (simple);  if (g_simple_async_result_propagate_error (simple, error))    goto out;  ret = g_object_ref (data->stream);  if (out_guid != NULL)    *out_guid = g_strdup (data->guid); out:  return ret;}

static voidla_handler_service_handle_register_finish (GObject      *object,                                           GAsyncResult *res,                                           gpointer      user_data){  GDBusMethodInvocation *invocation = G_DBUS_METHOD_INVOCATION (user_data);  LAHandlerService      *service;  NSMConsumer           *nsm_consumer = NSM_CONSUMER (object);  GError                *error = NULL;  gint                   error_code;  g_return_if_fail (IS_NSM_CONSUMER (nsm_consumer));  g_return_if_fail (G_IS_ASYNC_RESULT (res));  g_return_if_fail (G_IS_DBUS_METHOD_INVOCATION (invocation));  /* finish registering the shutdown client */  nsm_consumer_call_register_shutdown_client_finish (nsm_consumer, &error_code, res,                                                     &error);  if (error != NULL)    {      DLT_LOG (la_handler_context, DLT_LOG_ERROR,               DLT_STRING ("Failed to register a shutdown consumer:"),               DLT_STRING (error->message));      g_error_free (error);    }  /* retrieve the LAHandlerService from the invocation object */  service = g_object_get_data (G_OBJECT (invocation), "la-handler-service");  /* notify the caller that we have handled the registration request */  la_handler_complete_register (service->interface, invocation);}

static voidupdate_dependencies_cb (GObject      *object,                        GAsyncResult *result,                        gpointer      user_data){  IdeDependencyUpdater *updater = (IdeDependencyUpdater *)object;  g_autoptr(IdeTask) task = user_data;  g_autoptr(GError) error = NULL;  IdePrimaryWorkspace *self;  UpdateDependencies *ud;  IdeContext *context;  g_assert (IDE_IS_DEPENDENCY_UPDATER (updater));  g_assert (G_IS_ASYNC_RESULT (result));  g_assert (IDE_IS_TASK (task));  self = ide_task_get_source_object (task);  context = ide_widget_get_context (GTK_WIDGET (self));  if (!ide_dependency_updater_update_finish (updater, result, &error))    ide_context_warning (context, "%s", error->message);  ide_object_destroy (IDE_OBJECT (updater));  ud = ide_task_get_task_data (task);  ud->n_active--;  if (ud->n_active == 0)    ide_task_return_boolean (task, TRUE);}

/** * news_parser_buffered_fill_cb: * @object: (in): A #GBufferedInputStream. * @result: (in): A #GAsyncResult. * @user_data: (in): A #NewsParser. * * Completes an asynchronous request to fill the buffer of a * #GBufferedInputStream. If the buffer was successfully filled, then * the feed format will be discovered and the stream parsed. * * Returns: None. */static voidnews_parser_buffered_fill_cb (GObject      *object,                              GAsyncResult *result,                              gpointer      user_data){   GBufferedInputStream *buffered = (GBufferedInputStream *)object;   NewsParserPrivate *priv;   NewsParser *parser = user_data;   NewsFormat *format;   guint8 buffer[BUFFER_FILL_SIZE];   gsize length = 0;   GType format_type = G_TYPE_INVALID;   ENTRY;   g_assert(G_IS_BUFFERED_INPUT_STREAM(buffered));   g_assert(G_IS_ASYNC_RESULT(result));   g_assert(NEWS_IS_PARSER(parser));   priv = parser->priv;   length = g_buffered_input_stream_peek(buffered, buffer, 0, sizeof buffer);   if (length <= 0) {      g_simple_async_result_set_error(priv->simple, NEWS_PARSER_ERROR,                                      NEWS_PARSER_ERROR_NO_DATA,                                      _("No data was available to parse."));      g_simple_async_result_complete_in_idle(priv->simple);   } else {      format_type = news_parser_discover_format(parser, buffer, length);      if (format_type) {         format = g_object_new(format_type,                               "adapter", priv->adapter,                          "source", priv->source,                               NULL);         news_format_read_async(format, G_INPUT_STREAM(buffered),                                priv->cancellable,                                news_parser_format_read_cb,                                g_object_ref(parser));         g_object_unref(format);      } else {         g_simple_async_result_set_error(priv->simple, NEWS_PARSER_ERROR,                                         NEWS_PARSER_ERROR_NO_FORMAT,                                         _("Failed to discover format."));         g_simple_async_result_complete_in_idle(priv->simple);#if 0         {            gchar *uri;            g_object_get(priv->source, "uri", &uri, NULL);            g_printerr("%s/n", uri);            g_free(uri);         }#endif      }   }   g_object_unref(parser);   EXIT;}

/** * ide_build_system_get_build_flags_for_files_finish: * @self: an #IdeBuildSystem * @result: a #GAsyncResult * @error: a location for a #GError or %NULL * * Returns: (element-type Ide.File GStrv) (transfer full): a #GHashTable or #GFile to #GStrv * * Since: 3.32 */GHashTable *ide_build_system_get_build_flags_for_files_finish (IdeBuildSystem  *self,                                                   GAsyncResult    *result,                                                   GError         **error){  GHashTable *ret;  IDE_ENTRY;  g_return_val_if_fail (IDE_IS_BUILD_SYSTEM (self), NULL);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);  ret = IDE_BUILD_SYSTEM_GET_IFACE (self)->get_build_flags_for_files_finish (self, result, error);  if (ret != NULL)    {      GHashTableIter iter;      gchar **flags;      g_hash_table_iter_init (&iter, ret);      while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&flags))        ide_build_system_post_process_build_flags (self, flags);    }  IDE_RETURN (ret);}

/** * news_parser_format_read_cb: * @object: (in): A #NewsFormat. * @result: (in): A #GAsyncResult. * @user_data: (in): A #NewsParser. * * Handles the asynchronous completion of a call to news_format_read_async(). * If the reading of the buffer was successful; then the resulting feed * is stored for use by news_parser_parse_finish(). Otherwise, a proper * error is set. * * Returns: None. */static voidnews_parser_format_read_cb (GObject      *object,                            GAsyncResult *result,                            gpointer      user_data){   NewsParserPrivate *priv;   NewsParser *parser = user_data;   NewsFormat *format = (NewsFormat *)object;   GError *error = NULL;   ENTRY;   g_return_if_fail(NEWS_IS_FORMAT(format));   g_return_if_fail(G_IS_ASYNC_RESULT(result));   g_return_if_fail(NEWS_IS_PARSER(parser));   priv = parser->priv;   if (!(priv->feed = news_format_read_finish(format, result, &error))) {      g_simple_async_result_take_error(priv->simple, error);   }   g_simple_async_result_complete_in_idle(priv->simple);   g_object_unref(parser);   EXIT;}

/** * g_tls_interaction_ask_password_finish: * @interaction: a #GTlsInteraction object * @result: the result passed to the callback * @error: an optional location to place an error on failure * * Complete an ask password user interaction request. This should be once * the g_tls_interaction_ask_password_async() completion callback is called. * * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsPassword passed * to g_tls_interaction_ask_password() will have its password filled in. * * If the interaction is cancelled by the cancellation object, or by the * user then %G_TLS_INTERACTION_FAILED will be returned with an error that * contains a %G_IO_ERROR_CANCELLED error code. * * Returns: The status of the ask password interaction. * * Since: 2.30 */GTlsInteractionResultg_tls_interaction_ask_password_finish (GTlsInteraction    *interaction,                                       GAsyncResult       *result,                                       GError            **error){  GTlsInteractionClass *klass;  g_return_val_if_fail (G_IS_TLS_INTERACTION (interaction), G_TLS_INTERACTION_UNHANDLED);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), G_TLS_INTERACTION_UNHANDLED);  /* If it's one of our simple unhandled async results, handle here */  if (g_simple_async_result_is_valid (result, G_OBJECT (interaction),                                      g_tls_interaction_ask_password_async))    {      return G_TLS_INTERACTION_UNHANDLED;    }  /* Invoke finish of derived class */  else    {      klass = G_TLS_INTERACTION_GET_CLASS (interaction);      g_return_val_if_fail (klass->ask_password_finish, G_TLS_INTERACTION_UNHANDLED);      return (klass->ask_password_finish) (interaction, result, error);    }}

static voidide_lsp_formatter_format_call_cb (GObject      *object,                                  GAsyncResult *result,                                  gpointer      user_data){  IdeLspClient *client = (IdeLspClient *)object;  g_autoptr(IdeTask) task = user_data;  g_autoptr(GError) error = NULL;  g_autoptr(GVariant) reply = NULL;  IdeLspFormatter *self;  IdeBuffer *buffer;  g_return_if_fail (IDE_IS_LSP_CLIENT (client));  g_return_if_fail (G_IS_ASYNC_RESULT (result));  if (!ide_lsp_client_call_finish (client, result, &reply, &error))    {      ide_task_return_error (task, g_steal_pointer (&error));      return;    }  self = ide_task_get_source_object (task);  buffer = ide_task_get_task_data (task);  g_assert (IDE_IS_LSP_FORMATTER (self));  g_assert (IDE_IS_BUFFER (buffer));  ide_lsp_formatter_apply_changes (self, buffer, reply);  ide_task_return_boolean (task, TRUE);}

static voidide_lsp_completion_provider_complete_cb (GObject      *object,                                              GAsyncResult *result,                                              gpointer      user_data){  IdeLspCompletionProviderPrivate *priv;  IdeLspCompletionProvider *self;  IdeLspClient *client = (IdeLspClient *)object;  g_autoptr(GVariant) return_value = NULL;  g_autoptr(IdeTask) task = user_data;  g_autoptr(GError) error = NULL;  IdeLspCompletionResults *ret;  IDE_ENTRY;  g_assert (IDE_IS_LSP_CLIENT (client));  g_assert (G_IS_ASYNC_RESULT (result));  if (!ide_lsp_client_call_finish (client, result, &return_value, &error))    {      ide_task_return_error (task, g_steal_pointer (&error));      return;    }  self = ide_task_get_source_object (task);  priv = ide_lsp_completion_provider_get_instance_private (self);  ret = ide_lsp_completion_results_new (return_value);  if (priv->word != NULL && *priv->word != 0)    ide_lsp_completion_results_refilter (ret, priv->word);  ide_task_return_object (task, g_steal_pointer (&ret));  IDE_EXIT;}

static voidload_find_files_cb (GObject      *object,                    GAsyncResult *result,                    gpointer      user_data){  GFile *file = (GFile *)object;  g_autoptr(IdeTask) task = user_data;  g_autoptr(GError) error = NULL;  g_autoptr(GPtrArray) ret = NULL;  g_assert (G_IS_FILE (file));  g_assert (G_IS_ASYNC_RESULT (result));  g_assert (IDE_IS_TASK (task));  ret = ide_g_file_find_finish (file, result, &error);  IDE_PTR_ARRAY_SET_FREE_FUNC (ret, g_object_unref);  if (ret == NULL)    {      ide_task_return_error (task, g_steal_pointer (&error));      return;    }  ide_task_set_task_data (task, g_steal_pointer (&ret), g_ptr_array_unref);  ide_task_run_in_thread (task, gbp_cmake_toolchain_provider_load_worker);}

static voidpkg_channels_page_add_channel_cb (PkConnection    *connection,                                  GAsyncResult    *result,                                  PkgChannelsPage *page){	PkgChannelsPagePrivate *priv;	GError *error = NULL;	gint channel;	g_return_if_fail(PK_IS_CONNECTION(connection));	g_return_if_fail(G_IS_ASYNC_RESULT(result));	g_return_if_fail(PKG_IS_CHANNELS_PAGE(page));	ENTRY;	priv = page->priv;	if (!pk_connection_manager_add_channel_finish(priv->connection, result,	                                              &channel, &error)) {		WARNING(Channels, "Failed to add new channel: %s", error->message);		pkg_util_dialog_warning(gtk_widget_get_toplevel(GTK_WIDGET(page)),		                        "",		                        _("There was an error adding the channel."),		                        error->message,		                        TRUE);		g_error_free(error);		GOTO(fail);	}	DEBUG(Channels, "Added channel %d to system.", channel);  fail:	EXIT;}

static voidide_build_system_get_build_flags_cb (GObject      *object,                                     GAsyncResult *result,                                     gpointer      user_data){  IdeBuildSystem *self = (IdeBuildSystem *)object;  g_autoptr(IdeTask) task = user_data;  g_autoptr(GError) error = NULL;  g_auto(GStrv) flags = NULL;  GetBuildFlagsData *data;  GFile *file;  g_assert (IDE_IS_BUILD_SYSTEM (self));  g_assert (G_IS_ASYNC_RESULT (result));  g_assert (IDE_IS_TASK (task));  data = ide_task_get_task_data (task);  g_assert (data != NULL);  g_assert (data->files != NULL);  g_assert (data->files->len > 0);  g_assert (data->index < data->files->len);  g_assert (data->flags != NULL);  file = g_ptr_array_index (data->files, data->index);  g_assert (G_IS_FILE (file));  data->index++;  flags = ide_build_system_get_build_flags_finish (self, result, &error);  if (error != NULL)    g_debug ("Failed to load build flags for /"%s/": %s",             g_file_peek_path (file),             error->message);  else    g_hash_table_insert (data->flags, g_object_ref (file), g_steal_pointer (&flags));  if (ide_task_return_error_if_cancelled (task))    return;  if (data->index < data->files->len)    {      GCancellable *cancellable = ide_task_get_cancellable (task);      file = g_ptr_array_index (data->files, data->index);      g_assert (G_IS_FILE (file));      ide_build_system_get_build_flags_async (self,                                              file,                                              cancellable,                                              ide_build_system_get_build_flags_cb,                                              g_steal_pointer (&task));      return;    }  ide_task_return_pointer (task,                           g_steal_pointer (&data->flags),                           g_hash_table_unref);}

static voidide_terminal_page_spawn_cb (GObject      *object,                            GAsyncResult *result,                            gpointer      user_data){  IdeTerminalLauncher *launcher = (IdeTerminalLauncher *)object;  g_autoptr(IdeTerminalPage) self = user_data;  g_autoptr(GError) error = NULL;  gint64 now;  g_assert (IDE_IS_TERMINAL_LAUNCHER (launcher));  g_assert (G_IS_ASYNC_RESULT (result));  g_assert (IDE_IS_TERMINAL_PAGE (self));  if (!ide_terminal_launcher_spawn_finish (launcher, result, &error))    {      g_autofree gchar *format = NULL;      format = g_strdup_printf ("%s: %s", _("Subprocess launcher failed"), error->message);      ide_terminal_page_feed (self, format);    }  if (gtk_widget_in_destruction (GTK_WIDGET (self)))    return;  now = g_get_monotonic_time ();  if (ABS (now - self->last_respawn) < FLAPPING_DURATION_USEC)    {      ide_terminal_page_feed (self, _("Subprocess launcher failed too quickly, will not respawn."));      return;    }  if (!self->respawn_on_exit)    {      if (self->close_on_exit)        gdk_threads_add_idle_full (G_PRIORITY_LOW + 1000,                                   (GSourceFunc) destroy_widget_in_idle,                                   g_object_ref (self),                                   g_object_unref);      return;    }  g_clear_object (&self->pty);  vte_terminal_reset (VTE_TERMINAL (self->terminal_top), TRUE, TRUE);  self->pty = vte_pty_new_sync (VTE_PTY_DEFAULT, NULL, NULL);  vte_terminal_set_pty (VTE_TERMINAL (self->terminal_top), self->pty);  /* Spawn our terminal and wait for it to exit */  self->last_respawn = now;  ide_terminal_launcher_spawn_async (self->launcher,                                     self->pty,                                     NULL,                                     ide_terminal_page_spawn_cb,                                     g_object_ref (self));}

gintide_application_tool_run_finish (IdeApplicationTool  *self,                                 GAsyncResult        *result,                                 GError             **error){  g_return_val_if_fail (IDE_IS_APPLICATION_TOOL (self), 0);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), 0);  return IDE_APPLICATION_TOOL_GET_IFACE (self)->run_finish (self, result, error);}

/** * ide_device_provider_load_finish: * @self: an #IdeDeviceProvider * @result: a #GAsyncResult provided to callback * @error: a location for a #GError, or %NULL * * Completes an asynchronous request to load known devices via * ide_device_provider_load_async(). * * Returns: %TRUE if successful; otherwise %FALSE and @error is set. * * Since: 3.32 */gbooleanide_device_provider_load_finish (IdeDeviceProvider  *self,                                 GAsyncResult       *result,                                 GError            **error){  g_return_val_if_fail (IDE_IS_DEVICE_PROVIDER (self), FALSE);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);  return IDE_DEVICE_PROVIDER_GET_CLASS (self)->load_finish (self, result, error);}

/** * ide_build_system_get_build_flags_for_dir_finish: * @self: an #IdeBuildSystem * @result: a #GAsyncResult * @error: a location for a #GError or %NULL * * Returns: (element-type Ide.File GStrv) (transfer full): a #GHashTable of #GFile to #GStrv * * Since: 3.32 */GHashTable *ide_build_system_get_build_flags_for_dir_finish (IdeBuildSystem  *self,                                                 GAsyncResult    *result,                                                 GError         **error){  g_return_val_if_fail (IDE_IS_BUILD_SYSTEM (self), NULL);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);  return ide_task_propagate_pointer (IDE_TASK (result), error);}

/** * ide_search_provider_search_finish: * @self: a #IdeSearchProvider * @result: a #GAsyncResult * @error: a location for a #GError, or %NULL * * Completes a request to a search provider. * * Returns: (transfer full) (element-type IdeSearchResult): a #GPtrArray *    of #IdeSearchResult elements. * * Since: 3.32 */GPtrArray *ide_search_provider_search_finish (IdeSearchProvider  *self,                                   GAsyncResult       *result,                                   GError            **error){  g_return_val_if_fail (IDE_IS_SEARCH_PROVIDER (self), NULL);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);  return IDE_SEARCH_PROVIDER_GET_IFACE (self)->search_finish (self, result, error);}

/** * ide_context_addin_load_project_finish: * @self: an #IdeContextAddin * @result: a #GAsyncResult * @error: a location for a #GError, or %NULL * * Completes a request to load a project with the #IdeContextAddin. * * This function will be called from the callback provided to * ide_context_addin_load_project_async(). * * Returns: %TRUE if successful; otherwise %FALSE and @error is set. * * Since: 3.32 */gbooleanide_context_addin_load_project_finish (IdeContextAddin  *self,                                       GAsyncResult     *result,                                       GError          **error){  g_return_val_if_fail (IDE_IS_CONTEXT_ADDIN (self), FALSE);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);  return IDE_CONTEXT_ADDIN_GET_IFACE (self)->load_project_finish (self, result, error);}

gbooleanphotos_share_point_share_finish (PhotosSharePoint *self, GAsyncResult *res, gchar **out_uri, GError **error){  g_return_val_if_fail (PHOTOS_IS_SHARE_POINT (self), FALSE);  g_return_val_if_fail (G_IS_ASYNC_RESULT (res), FALSE);  g_return_val_if_fail (out_uri == NULL || *out_uri == NULL, FALSE);  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);  return PHOTOS_SHARE_POINT_GET_CLASS (self)->share_finish (self, res, out_uri, error);}

/** * ide_diagnostic_provider_diagnose_finish: * * Completes an asynchronous call to ide_diagnostic_provider_diagnose_async(). * * Returns: (transfer full): #IdeDiagnostics or %NULL and @error is set. */IdeDiagnostics *ide_diagnostic_provider_diagnose_finish (IdeDiagnosticProvider  *self,                                         GAsyncResult           *result,                                         GError                **error){  g_return_val_if_fail (IDE_IS_DIAGNOSTIC_PROVIDER (self), NULL);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);  return IDE_DIAGNOSTIC_PROVIDER_GET_IFACE (self)->diagnose_finish (self, result, error);}

gbooleanide_project_miner_mine_finish (IdeProjectMiner  *self,                               GAsyncResult     *result,                               GError          **error){  g_return_val_if_fail (IDE_IS_PROJECT_MINER (self), FALSE);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);  return IDE_PROJECT_MINER_GET_IFACE (self)->mine_finish (self, result, error);}

gbooleanide_vcs_initializer_initialize_finish (IdeVcsInitializer  *self,                                       GAsyncResult       *result,                                       GError            **error){  g_return_val_if_fail (IDE_IS_VCS_INITIALIZER (self), FALSE);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);  return IDE_VCS_INITIALIZER_GET_IFACE (self)->initialize_finish (self, result, error);}

gbooleanide_runner_addin_posthook_finish (IdeRunnerAddin  *self,                                  GAsyncResult    *result,                                  GError         **error){  g_return_val_if_fail (IDE_IS_RUNNER_ADDIN (self), FALSE);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);  return IDE_RUNNER_ADDIN_GET_IFACE (self)->posthook_finish (self, result, error);}

gbooleanide_frame_agree_to_close_finish (IdeFrame      *self,                                 GAsyncResult  *result,                                 GError       **error){  g_return_val_if_fail (IDE_IS_FRAME (self), FALSE);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);  return IDE_FRAME_GET_CLASS (self)->agree_to_close_finish (self, result, error);}

static voidide_build_system_get_build_flags_for_dir_cb (GObject      *object,                                             GAsyncResult *result,                                             gpointer      user_data){  GFile *dir = (GFile *)object;  g_autoptr(IdeTask) task = user_data;  g_autoptr(GError) error = NULL;  g_autoptr(GPtrArray) infos = NULL;  g_autoptr(GPtrArray) files = NULL;  IdeBuildSystem *self;  GCancellable *cancellable;  IdeContext *context;  IdeVcs *vcs;  g_assert (G_IS_FILE (dir));  g_assert (G_IS_ASYNC_RESULT (result));  g_assert (IDE_IS_TASK (task));  infos = ide_g_file_get_children_finish (dir, result, &error);  IDE_PTR_ARRAY_SET_FREE_FUNC (infos, g_object_unref);  if (infos == NULL)    {      ide_task_return_error (task, g_steal_pointer (&error));      return;    }  self = ide_task_get_source_object (task);  context = ide_object_get_context (IDE_OBJECT (self));  vcs = ide_vcs_from_context (context);  cancellable = ide_task_get_cancellable (task);  files = g_ptr_array_new_with_free_func (g_object_unref);  for (guint i = 0; i < infos->len; i++)    {      GFileInfo *file_info = g_ptr_array_index (infos, i);      GFileType file_type = g_file_info_get_file_type (file_info);      if (file_type == G_FILE_TYPE_REGULAR)        {          const gchar *name = g_file_info_get_name (file_info);          g_autoptr(GFile) child = g_file_get_child (dir, name);          if (!ide_vcs_is_ignored (vcs, child, NULL))            g_ptr_array_add (files, g_steal_pointer (&child));        }    }  ide_build_system_get_build_flags_for_files_async (self,                                                    files,                                                    cancellable,                                                    ide_build_system_get_build_flags_for_dir_cb2,                                                    g_steal_pointer (&task));}

GdkPixbuf*gt_resource_donwloader_download_image_finish(GtResourceDownloader* self,    GAsyncResult* result, GError** error){    RETURN_VAL_IF_FAIL(GT_IS_RESOURCE_DOWNLOADER(self), NULL);    RETURN_VAL_IF_FAIL(G_IS_ASYNC_RESULT(result), NULL);    GdkPixbuf* ret = g_task_propagate_pointer(G_TASK(result), error);    return ret;}

static voidide_debugger_editor_addin_disassemble_cb (GObject      *object,                                          GAsyncResult *result,                                          gpointer      user_data){  IdeDebugger *debugger = (IdeDebugger *)object;  g_autoptr(IdeDebuggerEditorAddin) self = user_data;  g_autoptr(GPtrArray) instructions = NULL;  g_autoptr(GError) error = NULL;  GtkWidget *stack;  IDE_ENTRY;  g_assert (IDE_IS_DEBUGGER (debugger));  g_assert (G_IS_ASYNC_RESULT (result));  g_assert (IDE_IS_DEBUGGER_EDITOR_ADDIN (self));  instructions = ide_debugger_disassemble_finish (debugger, result, &error);  if (instructions == NULL)    {      g_warning ("%s", error->message);      IDE_EXIT;    }  if (self->editor == NULL)    IDE_EXIT;  if (self->disassembly_view == NULL)    {      IdeGrid *grid = ide_editor_surface_get_grid (self->editor);      self->disassembly_view = g_object_new (IDE_TYPE_DEBUGGER_DISASSEMBLY_VIEW,                                             "visible", TRUE,                                             NULL);      g_signal_connect (self->disassembly_view,                        "destroy",                        G_CALLBACK (gtk_widget_destroyed),                        &self->disassembly_view);      gtk_container_add (GTK_CONTAINER (grid), GTK_WIDGET (self->disassembly_view));    }  ide_debugger_disassembly_view_set_instructions (self->disassembly_view, instructions);  /* TODO: Set current instruction */  /* FIXME: It would be nice if we had a nicer API for this */  stack = gtk_widget_get_ancestor (GTK_WIDGET (self->disassembly_view), IDE_TYPE_FRAME);  if (stack != NULL)    ide_frame_set_visible_child (IDE_FRAME (stack),                                        IDE_PAGE (self->disassembly_view));  IDE_EXIT;}

/** * g_async_result_get_source_object: * @res: a #GAsyncResult * * Gets the source object from a #GAsyncResult. * * Returns: (transfer full): a new reference to the source object for the @res, *    or %NULL if there is none. */GObject *g_async_result_get_source_object (GAsyncResult *res){    GAsyncResultIface *iface;    g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);    iface = G_ASYNC_RESULT_GET_IFACE (res);    return (* iface->get_source_object) (res);}