Trait gio::prelude::InitableExt

source ·

pub trait InitableExt: 'static {
    // Required method
    unsafe fn init(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>
    ) -> Result<(), Error>;
}

Expand description

Trait containing all Initable methods.

Implementors

CharsetConverter, DBusConnection, DBusProxy, DBusServer, DebugControllerDBus, DebugController, InetAddressMask, Initable, MemoryMonitor, NetworkMonitor, PowerProfileMonitor, Socket, Subprocess

Required Methods§

source

unsafe fn init( &self, cancellable: Option<&impl IsA<Cancellable>> ) -> Result<(), Error>

Initializes the object implementing the interface.

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

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

Implementations may also support cancellation. If cancellable is not None, then initialization can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error IOErrorEnum::Cancelled will be returned. If cancellable is not None and the object doesn’t support cancellable initialization the error IOErrorEnum::NotSupported 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][ginitable] for more details.

Callers should not assume that a class which implements Initable 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 Initable 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 init() on the result of glib::Object::new(), regardless of whether it is in fact a new instance.

`cancellable`

optional Cancellable object, None to ignore.

Returns

true if successful. If an error has occurred, this function will return false and set error appropriately if present.

Implementors§

source §