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

static voidon_status_new_returned (GObject *source_object,    GAsyncResult *result,    gpointer user_data){  GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);  g_return_if_fail (TP_IS_YTS_STATUS (source_object));  g_simple_async_result_set_op_res_gpointer (res, g_object_ref (source_object),      g_object_unref);  g_simple_async_result_complete (res);  g_object_unref (res);}

/** * Returns: currently returns 0 (failure) and 1 (success) * possibly later we'll add error-codes */G_GNUC_INTERNALgint spice_win_usb_driver_install_finish(SpiceWinUsbDriver *self,                                          GAsyncResult *res, GError **err){    GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT(res);    g_return_val_if_fail(SPICE_IS_WIN_USB_DRIVER(self), 0);    g_return_val_if_fail(g_simple_async_result_is_valid(res, G_OBJECT(self),                                                        spice_win_usb_driver_op),                         FALSE);    if (g_simple_async_result_propagate_error(result, err))        return 0;    return self->priv->reply.status;}

gbooleanum_user_manager_delete_user_finish (UmUserManager  *manager,                                    GAsyncResult   *result,                                    GError        **error){        GSimpleAsyncResult *res;        res = G_SIMPLE_ASYNC_RESULT (result);        if (g_simple_async_result_propagate_error (res, error)) {                return FALSE;        }        return TRUE;}

static gbooleanhev_iobj_async_initable_init_finish (GAsyncInitable *initable,			GAsyncResult *result, GError **error){	g_debug ("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);	g_return_val_if_fail (g_simple_async_result_is_valid (result,					G_OBJECT (initable), hev_iobj_async_initable_init_async),				FALSE);	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),					error))	  return FALSE;	return TRUE;}

GByteArray * hev_serial_port_queue_command_finish(HevSerialPort *self,			GAsyncResult *res, GError **error){	HevSerialPortPrivate *priv = NULL;	g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);	g_return_val_if_fail(HEV_IS_SERIAL_PORT(self), NULL);	priv = HEV_SERIAL_PORT_GET_PRIVATE(self);	/* Pop tail */	g_queue_pop_tail(priv->queue);	if(!g_queue_is_empty(priv->queue))	  hev_serial_port_queue_command_handler(self);	g_return_val_if_fail(g_simple_async_result_is_valid(res,					G_OBJECT(self), hev_serial_port_queue_command_async),				NULL);	if(g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(res),					error))	  return NULL;	return g_simple_async_result_get_op_res_gpointer(G_SIMPLE_ASYNC_RESULT(res));}

gbooleangoa_http_client_check_finish (GoaHttpClient *self, GAsyncResult *res, GError **error){  GSimpleAsyncResult *simple;  g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (self), goa_http_client_check), FALSE);  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);  simple = G_SIMPLE_ASYNC_RESULT (res);  if (g_simple_async_result_propagate_error (simple, error))    return FALSE;  return g_simple_async_result_get_op_res_gboolean (simple);}

gbooleangclue_locator_stop_finish (GClueLocator  *locator,                            GAsyncResult  *res,                            GError       **error){        GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);        g_return_val_if_fail (GCLUE_IS_LOCATOR (locator), FALSE);        g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == gclue_locator_stop);        if (g_simple_async_result_propagate_error (simple, error))                return FALSE;        return TRUE;}

static voidset_contact_alias_cb (TpConnection *conn,    const GError *error,    gpointer user_data,    GObject *weak_object){  GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data);  if (error != NULL)    {      g_simple_async_result_set_from_error (simple, error);    }  g_simple_async_result_complete (simple);}

static GList *lookup_by_name_finish (GResolver     *resolver,                       GAsyncResult  *result,                       GError       **error){  GSimpleAsyncResult *simple;  GWin32ResolverRequest *req;  g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (resolver), lookup_by_name_async), NULL);  simple = G_SIMPLE_ASYNC_RESULT (result);  req = g_simple_async_result_get_op_res_gpointer (simple);  return _g_resolver_addresses_from_addrinfo (req->u.name.name, req->u.name.res,                                              req->u.name.retval, error);}

static GInputStream *g_vfs_icon_load_finish (GLoadableIcon  *icon,                         GAsyncResult   *res,                         char          **type,                         GError        **error){  GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);  gpointer op;  op = g_simple_async_result_get_op_res_gpointer (simple);  if (op)    return g_object_ref (op);  return NULL;}

static voidon_status_advertise_status_returned (TpYtsStatus *self,    const GError *error,    gpointer user_data,    GObject *weak_object){  GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);  if (error != NULL)    {      DEBUG ("Status.AdvertiseStatus failed: %s", error->message);      g_simple_async_result_set_from_error (res, error);    }  g_simple_async_result_complete_in_idle (res);}

static gbooleantf_call_channel_init_finish (GAsyncInitable *initable,    GAsyncResult *res,    GError **error){  GSimpleAsyncResult *simple_res;  g_return_val_if_fail (g_simple_async_result_is_valid (res,          G_OBJECT (initable), tf_call_channel_init_async), FALSE);  simple_res = G_SIMPLE_ASYNC_RESULT (res);  if (g_simple_async_result_propagate_error (simple_res, error))    return FALSE;  return g_simple_async_result_get_op_res_gboolean (simple_res);}

gbooleane_mail_store_go_online_finish (CamelStore *store,                               GAsyncResult *result,                               GError **error){	GSimpleAsyncResult *simple;	g_return_val_if_fail (		g_simple_async_result_is_valid (		result, G_OBJECT (store), e_mail_store_go_online), FALSE);	simple = G_SIMPLE_ASYNC_RESULT (result);	/* Assume success unless a GError is set. */	return !g_simple_async_result_propagate_error (simple, error);}

static gbooleanmail_config_page_submit_finish (EMailConfigPage *page,                                GAsyncResult *result,                                GError **error){	GSimpleAsyncResult *simple;	g_return_val_if_fail (		g_simple_async_result_is_valid (		result, G_OBJECT (page), mail_config_page_submit), FALSE);	simple = G_SIMPLE_ASYNC_RESULT (result);	/* Assume success unless a GError is set. */	return !g_simple_async_result_propagate_error (simple, error);}

gbooleanempathy_connection_managers_prepare_finish (    EmpathyConnectionManagers *self,    GAsyncResult *result,    GError **error){  GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);  g_return_val_if_fail (g_simple_async_result_is_valid (result,          G_OBJECT (self), empathy_connection_managers_prepare_finish), FALSE);  if (g_simple_async_result_propagate_error (simple, error))    return FALSE;  return TRUE;}

/** * pk_package_sack_merge_generic_finish: * @sack: a valid #PkPackageSack instance * @res: the #GAsyncResult * @error: A #GError or %NULL * * Gets the result from the asynchronous function. * * Return value: %TRUE for success * * Since: 0.5.2 **/gbooleanpk_package_sack_merge_generic_finish (PkPackageSack *sack, GAsyncResult *res, GError **error){	GSimpleAsyncResult *simple;	g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), FALSE);	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);	simple = G_SIMPLE_ASYNC_RESULT (res);	if (g_simple_async_result_propagate_error (simple, error))		return FALSE;	return g_simple_async_result_get_op_res_gboolean (simple);}

gbooleanpp_maintenance_command_execute_finish (PpMaintenanceCommand  *command,                                       GAsyncResult          *res,                                       GError               **error){  GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);  g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == pp_maintenance_command_execute_async);  if (g_simple_async_result_propagate_error (simple, error))    {      return FALSE;    }  return g_simple_async_result_get_op_res_gboolean (simple);}

static GList *lookup_service_finish (GResolver     *resolver,                       GAsyncResult  *result,		       GError       **error){  GSimpleAsyncResult *simple;  GWin32ResolverRequest *req;  g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (resolver), lookup_service_async), NULL);  simple = G_SIMPLE_ASYNC_RESULT (result);  req = g_simple_async_result_get_op_res_gpointer (simple);  return _g_resolver_targets_from_DnsQuery (req->u.service.rrname,                                            req->u.service.retval,                                            req->u.service.results, error);}

/** * tp_yts_client_request_channel_finish: * @self: A client object * @result: The operation result * @error: If not %NULL, then raise an error here when returning %NULL. * * Get the result of an operation to create a new Ytstenut channel. * * Returns: A newly created Ytstenut channel, or %NULL if failed. The caller *      is responsible to close and release the channel. */TpYtsChannel *tp_yts_client_request_channel_finish (TpYtsClient *self,    GAsyncResult *result,    GError **error){  GSimpleAsyncResult *res;  g_return_val_if_fail (TP_IS_YTS_CLIENT (self), NULL);  g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),      tp_yts_client_request_channel_async), NULL);  res = G_SIMPLE_ASYNC_RESULT (result);  if (g_simple_async_result_propagate_error (res, error))    return NULL;  return g_object_ref (g_simple_async_result_get_op_res_gpointer (res));}

gbooleane_mail_session_send_to_finish (EMailSession *session,                               GAsyncResult *result,                               GError **error){	GSimpleAsyncResult *simple;	g_return_val_if_fail (		g_simple_async_result_is_valid (		result, G_OBJECT (session),		e_mail_session_send_to), FALSE);	simple = G_SIMPLE_ASYNC_RESULT (result);	/* Assume success unless a GError is set. */	return !g_simple_async_result_propagate_error (simple, error);}

/** * soup_input_stream_send_finish: * @stream: a #SoupInputStream * @result: a #GAsyncResult. * @error: a #GError location to store the error occuring, or %NULL to  * ignore. * * Finishes a soup_input_stream_send_async() operation. * * Return value: %TRUE if the message was sent successfully and * received a successful status code, %FALSE if not. **/gbooleansoup_input_stream_send_finish (GInputStream  *stream,			       GAsyncResult  *result,			       GError       **error){  GSimpleAsyncResult *simple;  g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);  simple = G_SIMPLE_ASYNC_RESULT (result);  g_return_val_if_fail (g_simple_async_result_get_source_tag (simple) == soup_input_stream_send_async, FALSE);  if (g_simple_async_result_propagate_error (simple, error))    return FALSE;  return g_simple_async_result_get_op_res_gboolean (simple);}

static voidon_service_open_session_aes (GObject *source,                             GAsyncResult *result,                             gpointer user_data){	GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);	OpenSessionClosure * closure = g_simple_async_result_get_op_res_gpointer (res);	SecretService *service = SECRET_SERVICE (source);	GError *error = NULL;	GVariant *response;	response =  g_dbus_proxy_call_finish (G_DBUS_PROXY (service), result, &error);	/* A successful response, decode it */	if (response != NULL) {		if (response_open_session_aes (closure->session, response)) {			_secret_service_take_session (service, closure->session);			closure->session = NULL;		} else {			g_simple_async_result_set_error (res, SECRET_ERROR, SECRET_ERROR_PROTOCOL,			                                 _("Couldn’t communicate with the secret storage"));		}		g_simple_async_result_complete (res);		g_variant_unref (response);	} else {		/* AES session not supported, request a plain session */		if (g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED)) {			g_dbus_proxy_call (G_DBUS_PROXY (source), "OpenSession",			                   request_open_session_plain (closure->session),			                   G_DBUS_CALL_FLAGS_NONE, -1,			                   closure->cancellable, on_service_open_session_plain,			                   g_object_ref (res));			g_error_free (error);		/* Other errors result in a failure */		} else {			g_simple_async_result_take_error (res, error);			g_simple_async_result_complete (res);		}	}	g_object_unref (res);}

static voidon_login_done (CockpitPipe *pipe,               const gchar *problem,               gpointer user_data){  GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (user_data);  if (problem)    {      g_warning ("cockpit session failed during auth: %s", problem);      g_simple_async_result_set_error (result, COCKPIT_ERROR, COCKPIT_ERROR_FAILED,                                       "Internal error in session process");    }  g_simple_async_result_complete (result);  g_object_unref (result);}

static voidon_prompt_cancelled (GCancellable *cancellable,                     gpointer user_data){	GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);	PerformClosure *closure = g_simple_async_result_get_op_res_gpointer (res);	SecretPrompt *self = SECRET_PROMPT (g_async_result_get_source_object (user_data));	/* Instead of cancelling our dbus calls, we cancel the prompt itself via this dbus call */	g_dbus_proxy_call (G_DBUS_PROXY (self), "Dismiss", g_variant_new ("()"),	                   G_DBUS_CALL_FLAGS_NO_AUTO_START, -1,	                   closure->call_cancellable,	                   on_prompt_dismissed, g_object_ref (res));	g_object_unref (self);}

gbooleane_composer_save_snapshot_finish (EMsgComposer *composer,                                 GAsyncResult *result,                                 GError **error){	GSimpleAsyncResult *simple;	g_return_val_if_fail (		g_simple_async_result_is_valid (			result, G_OBJECT (composer),			e_composer_save_snapshot), FALSE);	simple = G_SIMPLE_ASYNC_RESULT (result);	/* Success is assumed unless a GError is set. */	return !g_simple_async_result_propagate_error (simple, error);}

static GTlsInteractionResult_gcr_pkcs11_import_interaction_supplement_finish (GcrImportInteraction *interaction,                                                  GAsyncResult *result,                                                  GError **error){	GcrPkcs11ImportInteraction *self = GCR_PKCS11_IMPORT_INTERACTION (interaction);	g_return_val_if_fail (self->dialog != NULL, G_TLS_INTERACTION_UNHANDLED);	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (interaction),	                      _gcr_pkcs11_import_interaction_supplement_async), G_TLS_INTERACTION_UNHANDLED);	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))		return G_TLS_INTERACTION_FAILED;	return G_TLS_INTERACTION_HANDLED;}

static gbooleandata_wrapper_construct_from_stream_finish (CamelDataWrapper *data_wrapper,                                           GAsyncResult *result,                                           GError **error){	GSimpleAsyncResult *simple;	g_return_val_if_fail (		g_simple_async_result_is_valid (		result, G_OBJECT (data_wrapper),		data_wrapper_construct_from_stream), FALSE);	simple = G_SIMPLE_ASYNC_RESULT (result);	/* Assume success unless a GError is set. */	return !g_simple_async_result_propagate_error (simple, error);}