AsyncInitableIF

This is the asynchronous version of #GInitable; it behaves the same in all ways except that initialization is asynchronous. For more details see the descriptions on #GInitable.

A class may implement both the #GInitable and #GAsyncInitable interfaces.

Users of objects implementing this are not intended to use the interface method directly; instead it will be used automatically in various ways. For C applications you generally just call g_async_initable_new_async() directly, or indirectly via a foo_thing_new_async() wrapper. This will call g_async_initable_init_async() under the cover, calling back with %NULL and a set %GError on failure.

A typical implementation might look something like this:

|[<!-- language="C" --> enum { NOT_INITIALIZED, INITIALIZING, INITIALIZED };

static void _foo_ready_cb (Foo *self) { GList *l;

self->priv->state = INITIALIZED;

for (l = self->priv->init_results; l != NULL; l = l->next) { GTask *task = l->data;

if (self->priv->success) g_task_return_boolean (task, TRUE); else g_task_return_new_error (task, ...); g_object_unref (task); }

g_list_free (self->priv->init_results); self->priv->init_results = NULL; }

static void foo_init_async (GAsyncInitable *initable, int io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { Foo *self = FOO (initable); GTask *task;

task = g_task_new (initable, cancellable, callback, user_data);

switch (self->priv->state) { case NOT_INITIALIZED: _foo_get_ready (self); self->priv->init_results = g_list_append (self->priv->init_results, task); self->priv->state = INITIALIZING; break; case INITIALIZING: self->priv->init_results = g_list_append (self->priv->init_results, task); break; case INITIALIZED: if (!self->priv->success) g_task_return_new_error (task, ...); else g_task_return_boolean (task, TRUE); g_object_unref (task); break; } }

static gboolean foo_init_finish (GAsyncInitable *initable, GAsyncResult *result, GError **error) { g_return_val_if_fail (g_task_is_valid (result, initable), FALSE);

return g_task_propagate_boolean (G_TASK (result), error); }

static void foo_async_initable_iface_init (gpointer g_iface, gpointer data) { GAsyncInitableIface *iface = g_iface;

iface->init_async = foo_init_async; iface->init_finish = foo_init_finish; } ]|

Members

Functions

getAsyncInitableStruct
GAsyncInitable* getAsyncInitableStruct()

Get the main Gtk struct

getStruct
void* getStruct()

the main Gtk struct as a void*

initAsync
void initAsync(int ioPriority, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)

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.

initFinish
bool initFinish(AsyncResultIF res)

Finishes asynchronous initialization and returns the result. See g_async_initable_init_async().

newFinish
ObjectG newFinish(AsyncResultIF res)

Finishes the async construction for the various g_async_initable_new calls, returning the created object or %NULL on error.

Static functions

newValistAsync
void newValistAsync(GType objectType, string firstPropertyName, void* varArgs, int ioPriority, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)

Helper function for constructing #GAsyncInitable object. This is similar to g_object_new_valist() but also initializes the object asynchronously.

newvAsync
void newvAsync(GType objectType, uint nParameters, GParameter* parameters, int ioPriority, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)

Helper function for constructing #GAsyncInitable object. This is similar to g_object_newv() but also initializes the object asynchronously.

Meta

Since

2.22