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:
2. The type's implementation is referenced, e.g. through
gobject.type_class.TypeClass.ref_ or through func@GObject.type_create_instance
(this is being called by gobject.object.ObjectG.new_) or through one of the above
done on a type derived from new_type_id.
4. At some point the type's implementation isn't required anymore, e.g. after
gobject.type_class.TypeClass.unref or func@GObject.type_free_instance
(called when the reference count of an instance drops to zero).
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 gobject.type_plugin.TypePlugin interface.
2. The type's implementation is referenced, e.g. through gobject.type_class.TypeClass.ref_ or through func@GObject.type_create_instance (this is being called by gobject.object.ObjectG.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 gobject.type_plugin.TypePlugin.use and gobject.type_plugin.TypePlugin.completeTypeInfo on new_type_plugin.
4. At some point the type's implementation isn't required anymore, e.g. after gobject.type_class.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 gobject.type_plugin.TypePlugin.completeTypeInfo and then it calls gobject.type_plugin.TypePlugin.unuse on new_type_plugin.
6. Things may repeat from the second step.
So basically, you need to implement a gobject.type_plugin.TypePlugin 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 gobject.type_plugin.TypePlugin.completeTypeInfo 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 gobject.type_plugin.TypePlugin.use and gobject.type_plugin.TypePlugin.completeTypeInfo again when the type is needed again.
gobject.type_module.TypeModule is an implementation of gobject.type_plugin.TypePlugin that already implements most of this except for the actual module loading and unloading. It even handles multiple registered types per module.