:right-sidebar: True

TypePlugin
===================================================================

.. currentmodule:: gi.repository.GObject





.. class:: TypePlugin(*args, **kwargs)
   :no-contents-entry:





Implementations: :class:`~gi.repository.GObject.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:



.. code-block:: c
    :dedent:

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

.. rst-class:: interim-class

.. class:: TypePlugin
   :no-index:


   .. method:: complete_interface_info(instance_type: ~gobject.GType, interface_type: ~gobject.GType, info: ~gi.repository.GObject.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.






      :param instance_type: the :obj:`~gi.repository.GObject.Type` of an instantiatable type to which the interface
          is added

      :param interface_type: the :obj:`~gi.repository.GObject.Type` of the interface whose info is completed

      :param info: the :obj:`~gi.repository.GObject.InterfaceInfo` to fill in




   .. method:: complete_type_info(g_type: ~gobject.GType, info: ~gi.repository.GObject.TypeInfo, value_table: ~gi.repository.GObject.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.






      :param g_type: the :obj:`~gi.repository.GObject.Type` whose info is completed

      :param info: the :obj:`~gi.repository.GObject.TypeInfo` struct to fill in

      :param value_table: the :obj:`~gi.repository.GObject.TypeValueTable` to fill in




   .. method:: 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.









   .. method:: 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.