TypeModule

TypeModule provides a simple implementation of the TypePlugin interface.

The model of TypeModule is a dynamically loaded module which implements some number of types and interface implementations.

When the module is loaded, it registers its types and interfaces using register_type and add_interface. As long as any instances of these types and interface implementations are in use, the module is kept loaded. When the types and interfaces are gone, the module may be unloaded. If the types and interfaces become used again, the module will be reloaded. Note that the last reference cannot be released from within the module code, since that would lead to the caller's code being unloaded before unref returns to it.

Keeping track of whether the module should be loaded or not is done by using a use count - it starts at zero, and whenever it is greater than zero, the module is loaded. The use count is maintained internally by the type system, but also can be explicitly controlled by use and unuse. Typically, when loading a module for the first type, use will be used to load it so that it can initialize its types. At some later point, when the module no longer needs to be loaded except for the type implementations it contains, unuse is called.

TypeModule does not actually provide any implementation of module loading and unloading. To create a particular module type you must derive from TypeModule and implement the load and unload functions in TypeModule.

Example: Plugin sample:

public class MyClass : Object {
	static construct {
		message("MyClass init");
	}
	
	static ~MyClass() {
		message("MyClass deinit");
	}
}

[ModuleInit]
public static Type plugin_init(GLib.TypeModule type_modul) {
	return typeof(MyClass);
}

valac -o libplugin.so --library plugin -X -fPIC -X -shared GLib.TypeModule.0.vala

class MyModule : TypeModule {
	[CCode (has_target = false)]
	private delegate Type PluginInitFunc (TypeModule module);
	private GLib.Module module = null;
	private string name = null;
	
	public MyModule (string name) {
		this.name = name;
	}
	
	public override bool load () {
		string path = Module.build_path (null, name);
		module = Module.open (path, GLib.ModuleFlags.BIND_LAZY);
		if (null == module) {
			error ("Module not found");
		}
	
		void* plugin_init = null;
		if (!module.symbol ("plugin_init", out plugin_init)) {
			error ("No such symbol");
		}
		
		((PluginInitFunc) plugin_init) (this);
		
		return true;
	}
	
	public override void unload () {
		module = null;
		
		message ("Library unloaded");
	}
}

// Never unref instances of GLib.TypeModule
static TypeModule module = null;

public int main (string[] args) {
	module = new MyModule ("plugin");
	module.load ();
	
	var o = GLib.Object.new (Type.from_name ("MyClass"));
	// free last instance, plugin unload
	o = null;	
	return 0;
}

valac -o loader GLib.TypeModule.1.vala --pkg=gmodule-2.0