pub trait InitableExt:
IsA<Initable>
+ Sealed
+ 'static {
// Provided 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
Provided Methods§
Sourceunsafe fn init(
&self,
cancellable: Option<&impl IsA<Cancellable>>,
) -> Result<(), Error>
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, 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 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 #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.
§cancellable
optional #GCancellable object, None to ignore.
§Returns
true if successful. If an error has occurred, this function will
return false and set @error appropriately if present.
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.