AsyncInitable
GAsyncInitable is an interface for asynchronously initializable objects.
This is the asynchronous version of iface@Gio.Initable; 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 func@Gio.AsyncInitable.new_async directly, or indirectly via a foo_thing_new_async() wrapper. This will call method@Gio.AsyncInitable.init_async under the covers, calling back with NULL and a set GError on failure.
A typical implementation might look something like this:
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);
g_task_set_name (task, G_STRFUNC);
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;
}Skipped during bindings generation
function
new_async: Varargs parameter is not supportedparameter
var_args: va_list type is not supported
Since
2.22
Inheritors
Types
The AsyncInitableImpl type represents a native instance of the AsyncInitable interface.
Functions
Given @connection to communicate with a proxy (eg, a #GSocketConnection that is connected to the proxy server), this does the necessary handshake to connect to @proxy_address, and if required, wraps the #GIOStream to handle proxy payload.
Asynchronous version of g_proxy_connect().
See g_proxy_connect().
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.
Finishes asynchronous initialization and returns the result. See g_async_initable_init_async().
Finishes the async construction for the various g_async_initable_new calls, returning the created object or null on error.
Some proxy protocols expect to be passed a hostname, which they will resolve to an IP address themselves. Others, like SOCKS4, do not allow this. This function will return false if @proxy is implementing such a protocol. When false is returned, the caller should resolve the destination hostname first, and then pass a #GProxyAddress containing the stringified IP address to g_proxy_connect() or g_proxy_connect_async().