Skip to content

GObject.TypePlugin

interface

An interface that handles the lifecycle of dynamically loaded types.

The GObject type system supports dynamic loading of 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: 

    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 TypeClass.ref or through GObject.type_create_instance (this is being called by 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 TypePlugin.use and TypePlugin.complete_type_info on new_type_plugin.

  4. At some point the type's implementation isn't required anymore, e.g. after TypeClass.unref or 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 TypePlugin.complete_type_info and then it calls 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 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 TypePlugin.use and TypePlugin.complete_type_info again when the type is needed again.

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

complete_interface_info

def complete_interface_info(self, instance_type: type | Type, interface_type: type | Type, info: InterfaceInfo) -> None

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

Parameters:

  • instance_type — the GType of an instantiatable type to which the interface is added
  • interface_type — the GType of the interface whose info is completed
  • info — the InterfaceInfo to fill in

complete_type_info

def complete_type_info(self, g_type: type | Type, info: TypeInfo, value_table: TypeValueTable) -> None

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

Parameters:

  • g_type — the GType whose info is completed
  • info — the TypeInfo struct to fill in
  • value_table — the TypeValueTable to fill in

unuse

def unuse(self) -> None

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

use

def use(self) -> None

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