|
|
|
GIO Reference Manual | |
|---|---|---|---|---|
| Top | Description | Object Hierarchy | Implemented Interfaces | ||||
#include <gio/gio.h>
GIOModule;
GIOModule * g_io_module_new (const gchar *filename);
GList * g_io_modules_load_all_in_directory (const gchar *dirname);
void g_io_modules_scan_all_in_directory (const char *dirname);
void g_io_module_load (GIOModule *module);
void g_io_module_unload (GIOModule *module);
char ** g_io_module_query (void);
Provides an interface and default functions for loading and unloading modules. This is used internally to make GIO extensible, but can also be used by others to implement module loading.
GIOModule * g_io_module_new (const gchar *filename);
Creates a new GIOModule that will load the specific shared library when in use.
GList * g_io_modules_load_all_in_directory (const gchar *dirname);
Loads all the modules in the specified directory.
If don't require all modules to be initialized (and thus registering
all gtypes) then you can use g_io_modules_scan_all_in_directory()
which allows delayed/lazy loading of modules.
|
pathname for a directory containing modules to load. |
Returns : |
a list of GIOModules loaded
from the directory,
All the modules are loaded into memory, if you want to
unload them (enabling on-demand loading) you must call
g_type_module_unuse() on all the modules. Free the list
with g_list_free(). [element-type GIOModule][transfer full]
|
void g_io_modules_scan_all_in_directory (const char *dirname);
Scans all the modules in the specified directory, ensuring that any extension point implemented by a module is registered.
This may not actually load and initialize all the types in each
module, some modules may be lazily loaded and initialized when
an extension point it implementes is used with e.g.
g_io_extension_point_get_extensions() or
g_io_extension_point_get_extension_by_name().
If you need to guarantee that all types are loaded in all the modules,
use g_io_modules_load_all_in_directory().
|
pathname for a directory containing modules to scan. |
Since 2.24
void g_io_module_load (GIOModule *module);
Required API for GIO modules to implement. This function is ran after the module has been loaded into GIO, to initialize the module.
|
a GIOModule. |
void g_io_module_unload (GIOModule *module);
Required API for GIO modules to implement. This function is ran when the module is being unloaded from GIO, to finalize the module.
|
a GIOModule. |
char ** g_io_module_query (void);
Optional API for GIO modules to implement.
Should return a list of all the extension points that may be implemented in this module.
This method will not be called in normal use, however it may be called when probing existing modules and recording which extension points that this modle is used for. This means we won't have to load and initialze this module unless its needed.
If this function is not implemented by the module the module will always be loaded, initialized and then unloaded on application startup so that it can register its extension points during init.
Note that a module need not actually implement all the extension points
that g_io_module_query returns, since the exact list of extension may
depend on runtime issues. However all extension points actually implemented
must be returned by g_io_module_query() (if defined).
When installing a module that implements g_io_module_query you must run gio-querymodules in order to build the cache files required for lazy loading.
Returns : |
A NULL-terminated array of strings, listing the supported
extension points of the module. The array must be suitable for
freeing with g_strfreev(). [transfer full]
|
Since 2.24