/**
* g_async_initable_init_async:
* @initable: a #GAsyncInitable.
* @io_priority: the <link linkend="io-priority">I/O priority</link>
* of the operation.
* @cancellable: optional #GCancellable object, %NULL to ignore.
* @callback: a #GAsyncReadyCallback to call when the request is satisfied
* @user_data: the data to pass to callback function
*
* Starts asynchronous initialization of the object implementing the
* interface. This must be done before any real use of the object after
* initial construction. If the object also implements #GInitable you can
* optionally call g_initable_init() instead.
*
* When the initialization is finished, @callback will be called. You can
* then call g_async_initable_init_finish() to get the result of the
* initialization.
*
* Implementations may also support cancellation. If @cancellable is not
* %NULL, then initialization can be cancelled by triggering the cancellable
* object from another thread. If the operation was cancelled, the error
* %G_IO_ERROR_CANCELLED will be returned. If @cancellable is not %NULL, and
* the object doesn't support cancellable initialization, the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
* As with #GInitable, if the object is not initialized, or initialization
* returns with an error, then all operations on the object except
* g_object_ref() and g_object_unref() are considered to be invalid, and
* have undefined behaviour. They will often fail with g_critical() or
* g_warning(), but this must not be relied on.
*
* Implementations of this method must be idempotent: i.e. multiple calls
* to this function with the same argument should return the same results.
* Only the first call initializes the object; further calls return the result
* of the first call. This is so that it's safe to implement the singleton
* pattern in the GObject constructor function.
*
* For classes that also support the #GInitable interface, the default
* implementation of this method will run the g_initable_init() function
* in a thread, so if you want to support asynchronous initialization via
* threads, just implement the #GAsyncInitable interface without overriding
* any interface methods.
*
* Since: 2.22
*/
void
g_async_initable_init_async (GAsyncInitable *initable,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GAsyncInitableIface *iface;
g_return_if_fail (G_IS_ASYNC_INITABLE (initable));
iface = G_ASYNC_INITABLE_GET_IFACE (initable);
(* iface->init_async) (initable, io_priority, cancellable, callback, user_data);
}
/**
* g_async_initable_init_finish:
* @initable: a #GAsyncInitable.
* @res: a #GAsyncResult.
* @error: a #GError location to store the error occurring, or %NULL to
* ignore.
*
* Finishes asynchronous initialization and returns the result.
* See g_async_initable_init_async().
*
* Returns: %TRUE if successful. If an error has occurred, this function
* will return %FALSE and set @error appropriately if present.
*
* Since: 2.22
*/
gboolean
g_async_initable_init_finish (GAsyncInitable *initable,
GAsyncResult *res,
GError **error)
{
GAsyncInitableIface *iface;
g_return_val_if_fail (G_IS_ASYNC_INITABLE (initable), FALSE);
g_return_val_if_fail (G_IS_ASYNC_RESULT (res), FALSE);
if (g_async_result_legacy_propagate_error (res, error))
return FALSE;
iface = G_ASYNC_INITABLE_GET_IFACE (initable);
return (* iface->init_finish) (initable, res, error);
}
static void
ide_file_settings__init_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(IdeFileSettings) self = user_data;
IdeFileSettingsPrivate *priv = ide_file_settings_get_instance_private (self);
GAsyncInitable *initable = (GAsyncInitable *)object;
g_autoptr(GError) error = NULL;
g_assert (IDE_IS_FILE_SETTINGS (self));
g_assert (G_IS_ASYNC_INITABLE (initable));
if (!g_async_initable_init_finish (initable, result, &error))
g_warning ("%s", error->message);
if (--priv->unsettled_count == 0)
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_SETTLED]);
}
static void
ide_script_init_async (GAsyncInitable *initable,
gint io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
g_return_if_fail (G_IS_ASYNC_INITABLE (initable));
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
task = g_task_new (initable, cancellable, callback, user_data);
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_NOT_SUPPORTED,
_("%s has not implemented GAsyncInitable."),
g_type_name (G_TYPE_FROM_INSTANCE (initable)));
}
IdeFileSettings *
ide_file_settings_new (IdeObject *parent,
GFile *file,
const gchar *language)
{
IdeFileSettingsPrivate *priv;
GIOExtensionPoint *extension_point;
IdeFileSettings *ret;
GList *list;
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (IDE_IS_OBJECT (parent), NULL);
ret = g_object_new (IDE_TYPE_FILE_SETTINGS,
"file", file,
"language", language,
NULL);
priv = ide_file_settings_get_instance_private (ret);
ide_object_append (parent, IDE_OBJECT (ret));
extension_point = g_io_extension_point_lookup (IDE_FILE_SETTINGS_EXTENSION_POINT);
list = g_io_extension_point_get_extensions (extension_point);
/*
* Don't allow our unsettled count to hit zero until we are finished.
*/
priv->unsettled_count++;
for (; list; list = list->next)
{
GIOExtension *extension = list->data;
g_autoptr(IdeFileSettings) child = NULL;
GType gtype;
gtype = g_io_extension_get_type (extension);
if (!g_type_is_a (gtype, IDE_TYPE_FILE_SETTINGS))
{
g_warning ("%s is not an IdeFileSettings", g_type_name (gtype));
continue;
}
child = g_object_new (gtype,
"file", file,
"language", language,
NULL);
ide_object_append (IDE_OBJECT (ret), IDE_OBJECT (child));
if (G_IS_INITABLE (child))
{
g_autoptr(GError) error = NULL;
if (!g_initable_init (G_INITABLE (child), NULL, &error))
{
if (!ide_error_ignore (error))
g_warning ("%s", error->message);
}
}
else if (G_IS_ASYNC_INITABLE (child))
{
priv->unsettled_count++;
g_async_initable_init_async (G_ASYNC_INITABLE (child),
G_PRIORITY_DEFAULT,
NULL,
ide_file_settings__init_cb,
g_object_ref (ret));
}
_ide_file_settings_append (ret, child);
}
priv->unsettled_count--;
return ret;
}