class: Initable

[29:7] extends: object

GInitable is implemented by objects that can fail during initialization. If an object implements this interface then it must be initialized as the first thing after construction, either via [method@Gio.Initable.init] or [method@Gio.AsyncInitable.init_async] (the latter is only available if it also implements [iface@Gio.AsyncInitable]). 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 [func@GLib.critical] or [func@GLib.warning], but this must not be relied on. 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.Initable.new] directly, or indirectly via a foo_thing_new() wrapper. This will call [method@Gio.Initable.init] under the cover, returning NULL and setting a GError on failure (at which point the instance is unreferenced). For bindings in languages where the native constructor supports exceptions the binding could check for objects implementing GInitable during normal construction and automatically initialize them, throwing an exception on failure.

Members

• handleObj
• lib
• retainedCallbacks
• signalHandlerNames
• signalSetterHandlers

Methods

• Initable (Handle = null)

  Creates a new Initable by wrapping a native handle or another wrapper.

  • @p Handle is the native handle or another wrapper whose handle to adopt.

• toNativeHandle (Source)

  Normalizes a constructor argument into a raw pointer carrier. Accepts a raw NativeHandle, a raw NativeBuffer returned from fn.call(...), another generated wrapper exposing handle(), or null. Returns null when the argument carries no pointer.

  • @p Source is the raw handle, raw buffer, wrapper, or null.
  • @r A raw pointer carrier or null when no pointer is present.

• getLib ()

  Returns the opened native library for this generated wrapper.

  • @r The opened native library.

• handle ()

  Returns the wrapped NativeHandle.

  • @r The wrapped NativeHandle.

• isNull ()

  Returns true when the wrapped handle is null.

  • @r A bool.

• describe ()

  Returns a small string for debugging generated wrappers.

  • @r A string.

• init (object cancellable)

  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 [description][iface@Gio.Initable#description] 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.

  • @p cancellable is optional #GCancellable object, %NULL to ignore..