static void
catch_resource_group_fetch_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
CatchResourceGroupPrivate *priv;
CatchResourceGroup *group;
GSimpleAsyncResult *simple = user_data;
gboolean ret = FALSE;
GError *error = NULL;
ENTRY;
g_return_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple));
group = CATCH_RESOURCE_GROUP(g_async_result_get_source_object(user_data));
g_return_if_fail(CATCH_IS_RESOURCE_GROUP(group));
priv = group->priv;
if (priv->group) {
ret = gom_resource_group_fetch_finish(GOM_RESOURCE_GROUP(object), result, &error);
} else {
g_assert_not_reached();
}
if (!ret) {
g_simple_async_result_take_error(simple, error);
}
g_simple_async_result_set_op_res_gboolean(simple, ret);
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
EXIT;
}
/**
* news_parser_parse_finish:
* @parser: (in): A #NewsParser.
*
* Completes an asynchronous request to parse a #NewsFeed from a
* #GInputStream. If the feed was successfully parsed, then a
* #NewsFeed will be returned; othrewise %NULL and @error is set.
*
* Returns: None.
*/
NewsFeed *
news_parser_parse_finish (NewsParser *parser,
GAsyncResult *result,
GError **error)
{
NewsParserPrivate *priv;
NewsFeed *feed = NULL;
ENTRY;
g_return_val_if_fail(NEWS_IS_PARSER(parser), NULL);
g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(result), NULL);
priv = parser->priv;
if (!priv->feed) {
g_simple_async_result_propagate_error(priv->simple, error);
} else {
feed = g_object_ref(priv->feed);
}
g_clear_object(&priv->simple);
RETURN(feed);
}
static void
mongo_cursor_foreach_query_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
MongoConnection *connection = (MongoConnection *)object;
MongoMessageReply *reply;
GError *error = NULL;
ENTRY;
g_assert(MONGO_IS_CONNECTION(connection));
g_assert(G_IS_SIMPLE_ASYNC_RESULT(simple));
if (!(reply = mongo_connection_query_finish(connection, result, &error))) {
g_simple_async_result_take_error(simple, error);
mongo_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
EXIT;
}
mongo_cursor_foreach_dispatch(connection, reply, simple);
g_object_unref(reply);
EXIT;
}
/* Return a ref on the GdkPixbuf */
GdkPixbuf *
empathy_pixbuf_avatar_from_individual_scaled_finish (
FolksIndividual *individual,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
gboolean result_valid;
GdkPixbuf *pixbuf;
g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple), NULL);
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
result_valid = g_simple_async_result_is_valid (result,
G_OBJECT (individual),
empathy_pixbuf_avatar_from_individual_scaled_async);
g_return_val_if_fail (result_valid, NULL);
pixbuf = g_simple_async_result_get_op_res_gpointer (simple);
return pixbuf != NULL ? g_object_ref (pixbuf) : NULL;
}
static void
gom_repository_find_one_fetch_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
GomResourceGroup *group = (GomResourceGroup *)object;
GomResource *resource;
GError *error = NULL;
g_return_if_fail(GOM_IS_RESOURCE_GROUP(group));
g_return_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple));
if (!gom_resource_group_fetch_finish(group, result, &error)) {
g_simple_async_result_take_error(simple, error);
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
return;
}
resource = gom_resource_group_get_index(group, 0);
g_simple_async_result_set_op_res_gpointer(simple,
g_object_ref(resource),
g_object_unref);
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
}
static void
gom_resource_save_cb (GomAdapter *adapter,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
GomResource *resource;
gboolean ret;
GError *error = NULL;
GAsyncQueue *queue;
g_return_if_fail(GOM_IS_ADAPTER(adapter));
g_return_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple));
resource = GOM_RESOURCE(g_async_result_get_source_object(G_ASYNC_RESULT(simple)));
g_assert(GOM_IS_RESOURCE(resource));
queue = g_object_get_data(G_OBJECT(simple), "queue");
if (!(ret = gom_resource_do_save(resource, adapter, &error))) {
g_simple_async_result_take_error(simple, error);
}
g_simple_async_result_set_op_res_gboolean(simple, ret);
if (!queue)
g_simple_async_result_complete_in_idle(simple);
else
g_async_queue_push(queue, GINT_TO_POINTER(TRUE));
g_object_unref(resource);
}
static void
news_sync_task_save_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
NewsSyncTaskPrivate *priv;
GSimpleAsyncResult *simple = user_data;
NewsSyncTask *task;
GomResource *resource = (GomResource *)object;
GError *error = NULL;
g_assert(NEWS_IS_FEED(resource));
g_assert(G_IS_SIMPLE_ASYNC_RESULT(simple));
task = (NewsSyncTask *)g_async_result_get_source_object(G_ASYNC_RESULT(simple));
g_assert(NEWS_IS_SYNC_TASK(task));
priv = task->priv;
if (!gom_resource_save_finish(resource, result, &error)) {
g_simple_async_result_take_error(simple, error);
gom_adapter_sqlite_rollback(GOM_ADAPTER_SQLITE(priv->adapter));
} else if (!gom_adapter_sqlite_commit(GOM_ADAPTER_SQLITE(priv->adapter),
&error)) {
g_simple_async_result_take_error(simple, error);
gom_adapter_sqlite_rollback(GOM_ADAPTER_SQLITE(priv->adapter));
}
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
}
static void
gom_repository_find_one_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
GomResourceGroup *group;
GomRepository *repository = (GomRepository *)object;
GError *error = NULL;
g_return_if_fail(GOM_IS_REPOSITORY(repository));
g_return_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple));
if (!(group = gom_repository_find_finish(repository, result, &error))) {
g_simple_async_result_take_error(simple, error);
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
return;
}
if (!gom_resource_group_get_count(group)) {
g_simple_async_result_set_error(simple, GOM_ERROR,
GOM_ERROR_REPOSITORY_EMPTY_RESULT,
_("No resources were found."));
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
g_object_unref(group);
return;
}
gom_resource_group_fetch_async(group, 0, 1,
gom_repository_find_one_fetch_cb,
simple);
g_object_unref(group);
}
static void
catch_space_get_objects_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GomResource *resource = (GomResource *)object;
GSimpleAsyncResult *simple = user_data;
GomResourceGroup *group;
GError *error = NULL;
ENTRY;
g_return_if_fail(GOM_IS_RESOURCE(resource));
g_return_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple));
if (!(group = gom_resource_fetch_m2m_finish(resource, result, &error))) {
g_simple_async_result_take_error(simple, error);
} else {
g_simple_async_result_set_op_res_gpointer(simple, group, g_object_unref);
}
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
EXIT;
}
GSocketConnection *
_client_create_tube_finish (GAsyncResult *result,
TpChannel **channel,
GError **error)
{
GSimpleAsyncResult *simple;
CreateTubeData *data;
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL);
simple = G_SIMPLE_ASYNC_RESULT (result);
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
g_return_val_if_fail (g_simple_async_result_is_valid (result, NULL,
_client_create_tube_finish), NULL);
data = g_simple_async_result_get_op_res_gpointer (
G_SIMPLE_ASYNC_RESULT (result));
if (channel != NULL)
*channel = g_object_ref (data->channel);
return g_object_ref (data->connection);
}
gboolean
gom_repository_automatic_migrate_finish (GomRepository *repository,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail(GOM_IS_REPOSITORY(repository), FALSE);
g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(result), FALSE);
g_object_set_data(G_OBJECT(repository), "object-types", NULL);
return gom_repository_migrate_finish(repository, result, error);
}
static gssize
soup_input_stream_read_finish (GInputStream *stream,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple;
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), -1);
simple = G_SIMPLE_ASYNC_RESULT (result);
g_return_val_if_fail (g_simple_async_result_get_source_tag (simple) == soup_input_stream_read_async, -1);
return g_simple_async_result_get_op_res_gssize (simple);
}
/**
* 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
**/
gboolean
pk_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);
}
static void
news_sync_task_fetch_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
NewsSyncTaskPrivate *priv;
GSimpleAsyncResult *simple = (GSimpleAsyncResult *)user_data;
GInputStream *stream;
NewsSyncTask *task;
NewsSource *source = (NewsSource *)object;
NewsParser *parser;
GError *error = NULL;
g_assert(NEWS_IS_SOURCE(source));
g_assert(G_IS_SIMPLE_ASYNC_RESULT(simple));
task = (NewsSyncTask *)g_async_result_get_source_object(G_ASYNC_RESULT(simple));
g_assert(NEWS_IS_SYNC_TASK(task));
priv = task->priv;
priv->fraction = 0.333;
g_object_notify_by_pspec(G_OBJECT(task), gParamSpecs[PROP_FRACTION]);
if (!(stream = news_source_fetch_finish(source, result, &error))) {
g_simple_async_result_take_error(simple, error);
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
return;
}
if (g_cancellable_is_cancelled(priv->cancellable)) {
g_simple_async_result_set_error(simple, NEWS_SYNC_TASK_ERROR,
NEWS_SYNC_TASK_ERROR_CANCELLED,
_("The task was cancelled."));
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
return;
}
parser = g_object_new(NEWS_TYPE_PARSER,
"adapter", priv->adapter,
"source", priv->source,
NULL);
news_parser_parse_async(parser, stream, priv->cancellable,
news_sync_task_parse_cb, simple);
g_object_unref(parser);
}
/**
* gom_resource_fetch_m2m_finish:
* @resource: (in): A #GomResource.
* @result: (in): A #GAsyncResult.
* @error: (out): A location for a #GError, or %NULL.
*
* Completes the asynchronous request to fetch a group of resources that
* are related to the resource through a many-to-many table.
*
* Returns: (transfer full): A #GomResourceGroup.
*/
GomResourceGroup *
gom_resource_fetch_m2m_finish (GomResource *resource,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result;
GomResourceGroup *group;
g_return_val_if_fail(GOM_IS_RESOURCE(resource), NULL);
g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(result), NULL);
if (!(group = g_simple_async_result_get_op_res_gpointer(simple))) {
g_simple_async_result_propagate_error(simple, error);
}
return group ? g_object_ref(group) : NULL;
}
static GTlsCertificateFlags
g_tls_database_real_verify_chain_finish (GTlsDatabase *self,
GAsyncResult *result,
GError **error)
{
AsyncVerifyChain *args;
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), G_TLS_CERTIFICATE_GENERIC_ERROR);
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
g_tls_database_real_verify_chain_async), FALSE);
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
return G_TLS_CERTIFICATE_GENERIC_ERROR;
args = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
return args->verify_result;
}
/**
* gom_repository_find_one_finish:
* @repository: (in): A #GomRepository.
* @result: (in): A #GAsyncResult.
* @error: (out): A location for a #GError, or %NULL.
*
* Completes an asynchronous request to find a single resource in the
* repository. See gom_repository_find_one_async() for more info.
*
* Returns: (transfer full): A #GomResource if successful, otherwise %NULL.
*/
GomResource *
gom_repository_find_one_finish (GomRepository *repository,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result;
GomResource *ret;
g_return_val_if_fail(GOM_IS_REPOSITORY(repository), NULL);
g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple), NULL);
if (!(ret = g_simple_async_result_get_op_res_gpointer(simple))) {
g_simple_async_result_propagate_error(simple, error);
}
return ret ? g_object_ref(ret) : NULL;
}
/**
* 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.
**/
gboolean
soup_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 GFile *
_g_find_file_insensitive_finish (GFile *parent,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple;
GFile *file;
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL);
simple = G_SIMPLE_ASYNC_RESULT (result);
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
file = G_FILE (g_simple_async_result_get_op_res_gpointer (simple));
return g_object_ref (file);
}
gboolean
gom_repository_migrate_finish (GomRepository *repository,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result;
gboolean ret;
g_return_val_if_fail(GOM_IS_REPOSITORY(repository), FALSE);
g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(result), FALSE);
if (!(ret = g_simple_async_result_get_op_res_gboolean(simple))) {
g_simple_async_result_propagate_error(simple, error);
}
g_object_unref(simple);
return ret;
}
gboolean
cd_sensor_unlock_finish (CdSensor *sensor, GAsyncResult *res, GError **error)
{
GSimpleAsyncResult *simple;
gboolean ret = TRUE;
g_return_val_if_fail (CD_IS_SENSOR (sensor), 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)) {
ret = FALSE;
goto out;
}
out:
return ret;
}
static GbProject *
gb_project_format_real_open_finish (GbProjectFormat *format,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result;
GbProject *ret = NULL;
ENTRY;
g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple), NULL);
if (!(ret = g_simple_async_result_get_op_res_gpointer(simple))) {
g_simple_async_result_propagate_error(simple, error);
}
RETURN(ret ? g_object_ref(ret) : NULL);
}
/**
* g_async_result_legacy_propagate_error:
* @res: a #GAsyncResult
* @error: (out): a location to propagate the error to.
*
* If @res is a #GSimpleAsyncResult, this is equivalent to
* g_simple_async_result_propagate_error(). Otherwise it returns
* %FALSE.
*
* This can be used for legacy error handling in async
* <literal>_finish ()</literal> wrapper functions that traditionally
* handled #GSimpleAsyncResult error returns themselves rather than
* calling into the virtual method. This should not be used in new
* code; #GAsyncResult errors that are set by virtual methods should
* also be extracted by virtual methods, to enable subclasses to chain
* up correctly.
*
* Returns: %TRUE if @error is has been filled in with an error from
* @res, %FALSE if not.
*
* Since: 2.34
**/
gboolean
g_async_result_legacy_propagate_error (GAsyncResult *res,
GError **error)
{
/* This doesn't use a vmethod, because it's only for code that used
* to use GSimpleAsyncResult. (But it's a GAsyncResult method so
* that callers don't need to worry about GSimpleAsyncResult
* deprecation warnings in the future.)
*/
if (G_IS_SIMPLE_ASYNC_RESULT (res))
{
return g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res),
error);
}
else
return FALSE;
}
gboolean
gom_resource_delete_finish (GomResource *resource,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result;
gboolean ret;
g_return_val_if_fail(GOM_IS_RESOURCE(resource), FALSE);
g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple), FALSE);
if (!(ret = g_simple_async_result_get_op_res_gboolean(simple))) {
g_simple_async_result_propagate_error(simple, error);
}
g_object_unref(simple);
return ret;
}
/**
* catch_space_get_objects_finish:
* @space: (in): A #CatchSpace.
* @result: (in): A #GAsyncResult.
* @error: (out): A location for a #GError, or %NULL.
*
* Completes an asynchronous request to fetch a group of objects.
*
* Returns: (transfer full): A #GomResourceGroup.
*/
GomResourceGroup *
catch_space_get_objects_finish (CatchSpace *space,
GAsyncResult *result,
GError **error)
{
GomResourceGroup *group;
GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result;
ENTRY;
g_return_val_if_fail(CATCH_IS_SPACE(space), NULL);
g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple), NULL);
if (!(group = g_simple_async_result_get_op_res_gpointer(simple))) {
g_simple_async_result_propagate_error(simple, error);
}
RETURN(group ? g_object_ref(group) : NULL);
}
/**
* tp_yts_status_advertise_status_finish:
* @self: The status proxy
* @result: The result object passed to the callback
* @error: If an error occurred, this will be set
*
* Complete an asynchronous operation advertise Ytstenut service status.
*
* Returns: %TRUE if the operation succeeded.
*/
gboolean
tp_yts_status_advertise_status_finish (TpYtsStatus *self,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *res;
g_return_val_if_fail (TP_IS_YTS_STATUS (self), FALSE);
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
res = G_SIMPLE_ASYNC_RESULT (result);
g_return_val_if_fail (g_simple_async_result_is_valid (result,
G_OBJECT (self), tp_yts_status_advertise_status_async), FALSE);
if (g_simple_async_result_propagate_error (res, error))
return FALSE;
return TRUE;
}
/**
* catch_resource_group_fetch_finish:
* @group: (in): A #CatchResourceGroup.
* @result: (in): A #GAsyncResult.
* @error: (out): A locationf or a #GError, or %NULL.
*
* Completes an asynchronous request to catch_resource_group_fetch_async().
* %TRUE is returned if the resources were loaded, otherwise %FALSE and
* @error is set.
*
* Returns: %TRUE if successful; otherwise %FALSE and @error is set.
*/
gboolean
catch_resource_group_fetch_finish (CatchResourceGroup *group,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result;
gboolean ret;
ENTRY;
g_return_val_if_fail(CATCH_IS_RESOURCE_GROUP(group), FALSE);
g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple), FALSE);
if (!(ret = g_simple_async_result_get_op_res_gboolean(simple))) {
g_simple_async_result_propagate_error(simple, error);
}
RETURN(ret);
}
static void
news_sync_task_parse_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
NewsSyncTaskPrivate *priv;
GSimpleAsyncResult *simple = user_data;
NewsSyncTask *task;
NewsParser *parser = (NewsParser *)object;
GError *error = NULL;
g_assert(NEWS_IS_PARSER(parser));
g_assert(G_IS_SIMPLE_ASYNC_RESULT(simple));
task = (NewsSyncTask *)g_async_result_get_source_object(G_ASYNC_RESULT(simple));
g_assert(NEWS_IS_SYNC_TASK(task));
priv = task->priv;
priv->fraction = 0.666;
g_object_notify_by_pspec(G_OBJECT(task), gParamSpecs[PROP_FRACTION]);
if (!(priv->feed = news_parser_parse_finish(parser, result, &error))) {
g_simple_async_result_take_error(simple, error);
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
return;
}
if (g_cancellable_is_cancelled(priv->cancellable)) {
g_simple_async_result_set_error(simple, NEWS_SYNC_TASK_ERROR,
NEWS_SYNC_TASK_ERROR_CANCELLED,
_("The task was cancelled."));
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
return;
}
news_sync_task_prepare_save(task);
gom_adapter_sqlite_begin(GOM_ADAPTER_SQLITE(priv->adapter));
gom_resource_save_async(GOM_RESOURCE(priv->feed), priv->cancellable,
news_sync_task_save_cb, simple);
}
gboolean
push_gcm_client_deliver_finish (PushGcmClient *client,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result;
gboolean ret;
ENTRY;
g_return_val_if_fail(PUSH_IS_GCM_CLIENT(client), FALSE);
g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple), FALSE);
if (!(ret = g_simple_async_result_get_op_res_gboolean(simple))) {
g_simple_async_result_propagate_error(simple, error);
}
RETURN(ret);
}
/**
* tp_yts_status_ensure_finish:
* @account: The Ytstenut enabled account
* @result: The result object passed to the callback
* @error: If an error occurred, this will be set
*
* Complete an asynchronous operation to create a #TpYtsStatus object.
*
* Returns: A new #TpYtsStatus proxy, which you can use to access
* the Ytstenut Status service. If the operation failed, %NULL will be returned.
*/
TpYtsStatus *
tp_yts_status_ensure_finish (TpAccount *account,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *res;
g_return_val_if_fail (TP_IS_ACCOUNT (account), NULL);
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL);
res = G_SIMPLE_ASYNC_RESULT (result);
g_return_val_if_fail (g_simple_async_result_is_valid (result,
G_OBJECT (account), tp_yts_status_ensure_async), NULL);
if (g_simple_async_result_propagate_error (res, error))
return NULL;
return g_object_ref (g_simple_async_result_get_op_res_gpointer (res));
}
