TypePlugin

open class TypePlugin : TypePluginProtocol

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.

The GObject type system supports dynamic loading of types. The GTypePlugin interface is used to handle the lifecycle of dynamically loaded types. It goes as follows:

  1. 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.

  1. The type’s implementation is referenced, e.g. through g_type_class_ref() or through g_type_create_instance() (this is being called by g_object_new()) or through one of the above done on a type derived from new_type_id.

  2. This causes the type system to load the type’s implementation by calling g_type_plugin_use() and g_type_plugin_complete_type_info() on new_type_plugin.

  3. At some point the type’s implementation isn’t required anymore, e.g. after g_type_class_unref() or g_type_free_instance() (called when the reference count of an instance drops to zero).

  4. This causes the type system to throw away the information retrieved from g_type_plugin_complete_type_info() and then it calls g_type_plugin_unuse() on new_type_plugin.

  5. 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.

  • ptr
    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 the TypePlugin instance.

    Declaration

    Swift

    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 the TypePlugin instance.

    Declaration

    Swift

    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

    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

    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

    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

    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

    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

    public 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

    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

    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

    public init(retainingOpaquePointer p: OpaquePointer)

    Parameters

    p

    opaque pointer to the underlying object