TypePlugin
open class TypePlugin : TypePluginProtocol
An interface that handles the lifecycle of dynamically loaded types.
The GObject type system supports dynamic loading of types. It goes as follows:
- The type is initially introduced (usually upon loading the module the first time, or by your main application that knows what modules introduces what types), like this:
(C Language Example):
new_type_id = g_type_register_dynamic (parent_type_id,
"TypeName",
new_type_plugin,
type_flags);
where new_type_plugin
is an implementation of the
GTypePlugin
interface.
The type’s implementation is referenced, e.g. through
g_type_class_ref()
or throughg_type_create_instance()
(this is being called byg_object_new()
) or through one of the above done on a type derived fromnew_type_id
.This causes the type system to load the type’s implementation by calling
g_type_plugin_use()
andg_type_plugin_complete_type_info()
onnew_type_plugin
.At some point the type’s implementation isn’t required anymore, e.g. after
g_type_class_unref()
org_type_free_instance()
(called when the reference count of an instance drops to zero).This causes the type system to throw away the information retrieved from
g_type_plugin_complete_type_info()
and then it callsg_type_plugin_unuse()
onnew_type_plugin
.Things may repeat from the second step.
So basically, you need to implement a GTypePlugin
type that
carries a use_count, once use_count goes from zero to one, you need
to load the implementation to successfully handle the upcoming
g_type_plugin_complete_type_info()
call. Later, maybe after
succeeding use/unuse calls, once use_count drops to zero, you can
unload the implementation again. The type system makes sure to call
g_type_plugin_use()
and g_type_plugin_complete_type_info()
again
when the type is needed again.
GTypeModule
is an implementation of GTypePlugin
that already
implements most of this except for the actual module loading and
unloading. It even handles multiple registered types per module.
The TypePlugin
type acts as an owner of an underlying GTypePlugin
instance.
It provides the methods that can operate on this data type through TypePluginProtocol
conformance.
Use TypePlugin
as a strong reference or owner of a GTypePlugin
instance.
-
Untyped pointer to the underlying `GTypePlugin` instance.
For type-safe access, use the generated, typed pointer
type_plugin_ptr
property instead.Declaration
Swift
public let ptr: UnsafeMutableRawPointer!
-
Designated initialiser from the underlying
C
data type. This creates an instance without performing an unbalanced retain i.e., ownership is transferred to theTypePlugin
instance.Declaration
Swift
@inlinable public init(_ op: UnsafeMutablePointer<GTypePlugin>)
Parameters
op
pointer to the underlying object
-
Designated initialiser from a constant pointer to the underlying
C
data type. This creates an instance without performing an unbalanced retain i.e., ownership is transferred to theTypePlugin
instance.Declaration
Swift
@inlinable public init(_ op: UnsafePointer<GTypePlugin>)
Parameters
op
pointer to the underlying object
-
Optional initialiser from a non-mutating
gpointer
to the underlyingC
data type. This creates an instance without performing an unbalanced retain i.e., ownership is transferred to theTypePlugin
instance.Declaration
Swift
@inlinable public init!(gpointer op: gpointer?)
Parameters
op
gpointer to the underlying object
-
Optional initialiser from a non-mutating
gconstpointer
to the underlyingC
data type. This creates an instance without performing an unbalanced retain i.e., ownership is transferred to theTypePlugin
instance.Declaration
Swift
@inlinable public init!(gconstpointer op: gconstpointer?)
Parameters
op
pointer to the underlying object
-
Optional initialiser from a constant pointer to the underlying
C
data type. This creates an instance without performing an unbalanced retain i.e., ownership is transferred to theTypePlugin
instance.Declaration
Swift
@inlinable public init!(_ op: UnsafePointer<GTypePlugin>?)
Parameters
op
pointer to the underlying object
-
Optional initialiser from the underlying
C
data type. This creates an instance without performing an unbalanced retain i.e., ownership is transferred to theTypePlugin
instance.Declaration
Swift
@inlinable public init!(_ op: UnsafeMutablePointer<GTypePlugin>?)
Parameters
op
pointer to the underlying object
-
Designated initialiser from the underlying
C
data type.GTypePlugin
does not allow reference counting, so despite the name no actual retaining will occur. i.e., ownership is transferred to theTypePlugin
instance.Declaration
Swift
@inlinable public init(retaining op: UnsafeMutablePointer<GTypePlugin>)
Parameters
op
pointer to the underlying object
-
Reference intialiser for a related type that implements
TypePluginProtocol
GTypePlugin
does not allow reference counting.Declaration
Swift
@inlinable public init<T>(_ other: T) where T : TypePluginProtocol
Parameters
other
an instance of a related type that implements
TypePluginProtocol
-
Unsafe typed initialiser. Do not use unless you know the underlying data type the pointer points to conforms to
TypePluginProtocol
.Declaration
Swift
@inlinable public init<T>(cPointer p: UnsafeMutablePointer<T>)
Parameters
cPointer
pointer to the underlying object
-
Unsafe typed, retaining initialiser. Do not use unless you know the underlying data type the pointer points to conforms to
TypePluginProtocol
.Declaration
Swift
@inlinable public init<T>(retainingCPointer cPointer: UnsafeMutablePointer<T>)
Parameters
cPointer
pointer to the underlying object
-
Unsafe untyped initialiser. Do not use unless you know the underlying data type the pointer points to conforms to
TypePluginProtocol
.Declaration
Swift
@inlinable public init(raw p: UnsafeRawPointer)
Parameters
p
raw pointer to the underlying object
-
Unsafe untyped, retaining initialiser. Do not use unless you know the underlying data type the pointer points to conforms to
TypePluginProtocol
.Declaration
Swift
@inlinable public init(retainingRaw raw: UnsafeRawPointer)
-
Unsafe untyped initialiser. Do not use unless you know the underlying data type the pointer points to conforms to
TypePluginProtocol
.Declaration
Swift
@inlinable public required init(raw p: UnsafeMutableRawPointer)
Parameters
p
mutable raw pointer to the underlying object
-
Unsafe untyped, retaining initialiser. Do not use unless you know the underlying data type the pointer points to conforms to
TypePluginProtocol
.Declaration
Swift
@inlinable public init(retainingRaw raw: UnsafeMutableRawPointer)
Parameters
raw
mutable raw pointer to the underlying object
-
Unsafe untyped initialiser. Do not use unless you know the underlying data type the pointer points to conforms to
TypePluginProtocol
.Declaration
Swift
@inlinable public init(opaquePointer p: OpaquePointer)
Parameters
p
opaque pointer to the underlying object
-
Unsafe untyped, retaining initialiser. Do not use unless you know the underlying data type the pointer points to conforms to
TypePluginProtocol
.Declaration
Swift
@inlinable public init(retainingOpaquePointer p: OpaquePointer)
Parameters
p
opaque pointer to the underlying object