g_initable_init ()

gboolean
g_initable_init (GInitable *initable,
                 GCancellable *cancellable,
                 GError **error);

Initializes the object implementing the interface.

This method is intended for language bindings. If writing in C, g_initable_new() should typically be used instead.

The object must be initialized before any real use after initial construction, either with this function or g_async_initable_init_async().

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.

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. See the introduction for more details.

Callers should not assume that a class which implements GInitable can be initialized multiple times, unless the class explicitly documents itself as supporting this. Generally, a class’ implementation of init() can assume (and assert) that it will only be called once. Previously, this documentation recommended all GInitable implementations should be idempotent; that recommendation was relaxed in GLib 2.54.

If a class explicitly supports being initialized multiple times, it is recommended that the method is idempotent: multiple calls with the same arguments should return the same results. Only the first call initializes the object; further calls return the result of the first call.

One reason why a class might need to support idempotent initialization is if it is designed to be used via the singleton pattern, with a GObjectClass.constructor that sometimes returns an existing instance. In this pattern, a caller would expect to be able to call g_initable_init() on the result of g_object_new(), regardless of whether it is in fact a new instance.

Since: 2.22

g_initable_new ()

gpointer
g_initable_new (GType object_type,
                GCancellable *cancellable,
                GError **error,
                const gchar *first_property_name,
                ...);

Helper function for constructing GInitable object. This is similar to g_object_new() but also initializes the object and returns NULL, setting an error on failure.

Since: 2.22

g_initable_new_valist ()

GObject *
g_initable_new_valist (GType object_type,
                       const gchar *first_property_name,
                       va_list var_args,
                       GCancellable *cancellable,
                       GError **error);

Helper function for constructing GInitable object. This is similar to g_object_new_valist() but also initializes the object and returns NULL, setting an error on failure.

Since: 2.22

g_initable_newv ()

gpointer
g_initable_newv (GType object_type,
                 guint n_parameters,
                 GParameter *parameters,
                 GCancellable *cancellable,
                 GError **error);

Helper function for constructing GInitable object. This is similar to g_object_newv() but also initializes the object and returns NULL, setting an error on failure.

Since: 2.22

GInitable

typedef struct _GInitable GInitable;

Interface for initializable objects.

Since: 2.22

struct GInitableIface

struct GInitableIface {
  GTypeInterface g_iface;

  /* Virtual Table */

  gboolean    (* init) (GInitable    *initable,
			GCancellable *cancellable,
			GError      **error);
};

Provides an interface for initializing object such that initialization may fail.

Since: 2.22