TypePlugin

class TypePlugin(*args, **kwargs)

Implementations: TypeModule

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:

   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.

2. The type's implementation is referenced, e.g. through
   [func@GObject.TypeClass.ref] or through [func@GObject.type_create_instance]
   (this is being called by [ctor@GObject.Object.new]) or through one of the above
   done on a type derived from `new_type_id`.

3. This causes the type system to load the type's implementation by calling
   [method@GObject.TypePlugin.use] and [method@GObject.TypePlugin.complete_type_info]
   on `new_type_plugin`.

4. At some point the type's implementation isn't required anymore, e.g. after
   [method@GObject.TypeClass.unref] or [func@GObject.type_free_instance]
   (called when the reference count of an instance drops to zero).

5. This causes the type system to throw away the information retrieved
   from [method@GObject.TypePlugin.complete_type_info] and then it calls
   [method@GObject.TypePlugin.unuse] on `new_type_plugin`.

6. 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
[method@GObject.TypePlugin.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
[method@GObject.TypePlugin.use] and [method@GObject.TypePlugin.complete_type_info]
again when the type is needed again.

[class@GObject.TypeModule] 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.

Methods

class TypePlugin

complete_interface_info(instance_type: GType, interface_type: GType, info: InterfaceInfo) → None

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.

Parameters:

• instance_type – the Type of an instantiatable type to which the interface is added

• interface_type – the Type of the interface whose info is completed

• info – the InterfaceInfo to fill in

complete_type_info(g_type: GType, info: TypeInfo, value_table: TypeValueTable) → None

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.

Parameters:

• g_type – the Type whose info is completed

• info – the TypeInfo struct to fill in

• value_table – the TypeValueTable to fill in

unuse() → None

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.

use() → None

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.