* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
+
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "gtypeplugin.h"
+#include "gtypemodule.h"
+
+
/**
* SECTION:gtypemodule
- * @Short_description: Type loading modules
- * @See_also:<variablelist>
- * <varlistentry>
- * <term>#GTypePlugin</term>
- * <listitem><para>The abstract type loader interface.</para></listitem>
- * </varlistentry>
- * <varlistentry>
- * <term>#GModule</term>
- * <listitem><para>Portable mechanism for dynamically loaded modules.</para></listitem>
- * </varlistentry>
- * </variablelist>
- * @Title: GTypeModule
- *
+ * @short_description: Type loading modules
+ * @see_also: #GTypePlugin, #GModule
+ * @title: GTypeModule
+ *
* #GTypeModule provides a simple implementation of the #GTypePlugin
* interface. The model of #GTypeModule 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 g_type_module_register_type() and
- * g_type_module_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 unref can not happen in module
- * code, since that would lead to the caller's code being unloaded before
- * g_object_unref() returns to it.
- *
+ * which implements some number of types and interface implementations.
+ * When the module is loaded, it registers its types and interfaces
+ * using g_type_module_register_type() and g_type_module_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
+ * unref cannot happen in module code, since that would lead to the
+ * caller's code being unloaded before g_object_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
* 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, g_type_module_unuse() is called.
- *
+ *
* #GTypeModule does not actually provide any implementation of module
* loading and unloading. To create a particular module type you must
* derive from #GTypeModule and implement the load and unload functions
* in #GTypeModuleClass.
*/
-#include <stdlib.h>
-
-#include "gtypeplugin.h"
-#include "gtypemodule.h"
-#include "gobjectalias.h"
typedef struct _ModuleTypeInfo ModuleTypeInfo;
typedef struct _ModuleInterfaceInfo ModuleInterfaceInfo;
if (module->type_infos || module->interface_infos)
{
- g_warning (G_STRLOC ": unsolicitated invocation of g_object_dispose() on GTypeModule");
-
+ g_warning (G_STRLOC ": unsolicitated invocation of g_object_run_dispose() on GTypeModule");
+
g_object_ref (object);
}
if (!type_module_type)
{
- static const GTypeInfo type_module_info = {
+ const GTypeInfo type_module_info = {
sizeof (GTypeModuleClass),
NULL, /* base_init */
NULL, /* base_finalize */
0, /* n_preallocs */
NULL, /* instance_init */
};
- static const GInterfaceInfo iface_info = {
+ const GInterfaceInfo iface_info = {
(GInterfaceInitFunc) g_type_module_iface_init,
NULL, /* interface_finalize */
NULL, /* interface_data */
*
* Increases the use count of a #GTypeModule by one. If the
* use count was zero before, the plugin will be loaded.
+ * If loading the plugin fails, the use count is reset to
+ * its prior value.
*
* Returns: %FALSE if the plugin needed to be loaded and
* loading the plugin failed.
ModuleTypeInfo *type_info = tmp_list->data;
if (!type_info->loaded)
{
- g_warning ("plugin '%s' failed to register type '%s'\n",
+ g_warning ("plugin '%s' failed to register type '%s'",
module->name ? module->name : "(unknown)",
g_type_name (type_info->type));
+ module->use_count--;
return FALSE;
}
/**
* g_type_module_unuse:
* @module: a #GTypeModule
- *
+ *
* Decreases the use count of a #GTypeModule by one. If the
* result is zero, the module will be unloaded. (However, the
* #GTypeModule will not be freed, and types associated with the
- * #GTypeModule are not unregistered. Once a #GTypeModule is
+ * #GTypeModule are not unregistered. Once a #GTypeModule is
* initialized, it must exist forever.)
*/
void
if (!g_type_module_use (module))
{
- g_warning ("Fatal error - Could not reload previously loaded plugin '%s'\n",
+ g_warning ("Fatal error - Could not reload previously loaded plugin '%s'",
module->name ? module->name : "(unknown)");
exit (1);
}
/**
* g_type_module_register_type:
- * @module: a #GTypeModule
+ * @module: (nullable): a #GTypeModule
* @parent_type: the type for the parent class
* @type_name: name for the type
* @type_info: type information structure
* @flags: flags field providing details about the type
- *
+ *
* Looks up or registers a type that is implemented with a particular
* type plugin. If a type with name @type_name was previously registered,
* the #GType identifier for the type is returned, otherwise the type
* is newly registered, and the resulting #GType identifier returned.
- *
+ *
* When reregistering a type (typically because a module is unloaded
* then reloaded, and reinitialized), @module and @parent_type must
* be the same as they were previously.
- *
+ *
* As long as any instances of the type exist, the type plugin will
* not be unloaded.
- *
+ *
+ * Since 2.56 if @module is %NULL this will call g_type_register_static()
+ * instead. This can be used when making a static build of the module.
+ *
* Returns: the new or existing type ID
*/
GType
ModuleTypeInfo *module_type_info = NULL;
GType type;
- g_return_val_if_fail (module != NULL, 0);
g_return_val_if_fail (type_name != NULL, 0);
g_return_val_if_fail (type_info != NULL, 0);
+ if (module == NULL)
+ {
+ /* Cannot pass type_info directly to g_type_register_static() here because
+ * it has class_finalize != NULL and that's forbidden for static types */
+ return g_type_register_static_simple (parent_type,
+ type_name,
+ type_info->class_size,
+ type_info->class_init,
+ type_info->instance_size,
+ type_info->instance_init,
+ flags);
+ }
+
type = g_type_from_name (type_name);
if (type)
{
{
const gchar *parent_type_name = g_type_name (parent_type);
- g_warning ("Type '%s' recreated with different parent type.\n"
+ g_warning ("Type '%s' recreated with different parent type."
"(was '%s', now '%s')", type_name,
g_type_name (module_type_info->parent_type),
parent_type_name ? parent_type_name : "(unknown)");
/**
* g_type_module_add_interface:
- * @module: a #GTypeModule
+ * @module: (nullable): a #GTypeModule
* @instance_type: type to which to add the interface.
* @interface_type: interface type to add
* @interface_info: type information structure
- *
- * Registers an additional interface for a type, whose interface
- * lives in the given type plugin. If the interface was already registered
- * for the type in this plugin, nothing will be done.
- *
+ *
+ * Registers an additional interface for a type, whose interface lives
+ * in the given type plugin. If the interface was already registered
+ * for the type in this plugin, nothing will be done.
+ *
* As long as any instances of the type exist, the type plugin will
* not be unloaded.
+ *
+ * Since 2.56 if @module is %NULL this will call g_type_add_interface_static()
+ * instead. This can be used when making a static build of the module.
*/
void
g_type_module_add_interface (GTypeModule *module,
const GInterfaceInfo *interface_info)
{
ModuleInterfaceInfo *module_interface_info = NULL;
-
- g_return_if_fail (module != NULL);
+
g_return_if_fail (interface_info != NULL);
+ if (module == NULL)
+ {
+ g_type_add_interface_static (instance_type, interface_type, interface_info);
+ return;
+ }
+
if (g_type_is_a (instance_type, interface_type))
{
GTypePlugin *old_plugin = g_type_interface_get_plugin (instance_type,
/**
* g_type_module_register_enum:
- * @module: a #GTypeModule
+ * @module: (nullable): a #GTypeModule
* @name: name for the type
- * @const_static_values: an array of #GEnumValue structs for the possible
- * enumeration values. The array is terminated by a struct with all
- * members being 0.
- *
+ * @const_static_values: an array of #GEnumValue structs for the
+ * possible enumeration values. The array is
+ * terminated by a struct with all members being
+ * 0.
+ *
* Looks up or registers an enumeration that is implemented with a particular
* type plugin. If a type with name @type_name was previously registered,
* the #GType identifier for the type is returned, otherwise the type
* is newly registered, and the resulting #GType identifier returned.
- *
+ *
* As long as any instances of the type exist, the type plugin will
* not be unloaded.
- *
+ *
+ * Since 2.56 if @module is %NULL this will call g_type_register_static()
+ * instead. This can be used when making a static build of the module.
+ *
* Since: 2.6
+ *
* Returns: the new or existing type ID
*/
GType
{
GTypeInfo enum_type_info = { 0, };
- g_return_val_if_fail (G_IS_TYPE_MODULE (module), 0);
+ g_return_val_if_fail (module == NULL || G_IS_TYPE_MODULE (module), 0);
g_return_val_if_fail (name != NULL, 0);
g_return_val_if_fail (const_static_values != NULL, 0);
/**
* g_type_module_register_flags:
- * @module: a #GTypeModule
+ * @module: (nullable): a #GTypeModule
* @name: name for the type
- * @const_static_values: an array of #GFlagsValue structs for the possible
- * flags values. The array is terminated by a struct with all
- * members being 0.
- *
+ * @const_static_values: an array of #GFlagsValue structs for the
+ * possible flags values. The array is
+ * terminated by a struct with all members being
+ * 0.
+ *
* Looks up or registers a flags type that is implemented with a particular
* type plugin. If a type with name @type_name was previously registered,
* the #GType identifier for the type is returned, otherwise the type
* is newly registered, and the resulting #GType identifier returned.
- *
+ *
* As long as any instances of the type exist, the type plugin will
* not be unloaded.
- *
+ *
+ * Since 2.56 if @module is %NULL this will call g_type_register_static()
+ * instead. This can be used when making a static build of the module.
+ *
* Since: 2.6
+ *
* Returns: the new or existing type ID
*/
GType
{
GTypeInfo flags_type_info = { 0, };
- g_return_val_if_fail (G_IS_TYPE_MODULE (module), 0);
+ g_return_val_if_fail (module == NULL || G_IS_TYPE_MODULE (module), 0);
g_return_val_if_fail (name != NULL, 0);
g_return_val_if_fail (const_static_values != NULL, 0);
return g_type_module_register_type (G_TYPE_MODULE (module),
G_TYPE_FLAGS, name, &flags_type_info, 0);
}
-
-
-#define __G_TYPE_MODULE_C__
-#include "gobjectaliasdef.c"