TypePluginProtocol

public protocol TypePluginProtocol

The TypePluginProtocol protocol exposes the methods and properties of an underlying GTypePlugin instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see TypePlugin. Alternatively, use TypePluginRef as a lighweight, unowned reference if you already have an instance you just want to use.

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.

    Declaration

    Swift

    var ptr: UnsafeMutableRawPointer { get }
  • type_plugin_ptr Default implementation

    Typed pointer to the underlying GTypePlugin instance.

    Default Implementation

    Return the stored, untyped pointer as a typed pointer to the GTypePlugin instance.

    Declaration

    Swift

    var type_plugin_ptr: UnsafeMutablePointer<GTypePlugin> { get }

TypePlugin Interface: TypePluginProtocol extension (methods and fields)

  • Calls the complete_interface_info function from the GTypePluginClass of plugin. There should be no need to use this function outside of the GObject type system itself.

    Declaration

    Swift

    func completeInterfaceInfo(instanceType instance_type: GType, interfaceType interface_type: GType, info: InterfaceInfoProtocol)
  • Calls the complete_type_info function from the GTypePluginClass of plugin. There should be no need to use this function outside of the GObject type system itself.

    Declaration

    Swift

    func completeTypeInfo(gType g_type: GType, info: TypeInfoProtocol, valueTable value_table: TypeValueTableProtocol)
  • unuse() Extension method

    Calls the unuse_plugin function from the GTypePluginClass of plugin. There should be no need to use this function outside of the GObject type system itself.

    Declaration

    Swift

    func unuse()
  • use() Extension method

    Calls the use_plugin function from the GTypePluginClass of plugin. There should be no need to use this function outside of the GObject type system itself.

    Declaration

    Swift

    func use()
  • Adds interface_type to the dynamic instantiable_type. The information contained in the GTypePlugin structure pointed to by plugin is used to manage the relationship.

    Declaration

    Swift

    func typeAddInterfaceDynamic(instanceType instance_type: GType, interfaceType interface_type: GType)
  • Registers type_name as the name of a new dynamic type derived from parent_type. The type system uses the information contained in the GTypePlugin structure pointed to by plugin to manage the type and its instances (if not abstract). The value of flags determines the nature (e.g. abstract or not) of the type.

    Declaration

    Swift

    func typeRegisterDynamic(parentType parent_type: GType, typeName type_name: UnsafePointer<gchar>, flags: TypeFlags) -> GType