diff options
| -rw-r--r-- | gobject/gtype.c | 476 | ||||
| -rw-r--r-- | gobject/gtype.h | 4 |
2 files changed, 128 insertions, 352 deletions
diff --git a/gobject/gtype.c b/gobject/gtype.c index 8665db294..ac6a7e96f 100644 --- a/gobject/gtype.c +++ b/gobject/gtype.c @@ -191,10 +191,6 @@ static void type_data_make_W (TypeNode *node, const GTypeInfo *info, const GTypeValueTable *value_table); static inline void type_data_ref_Wm (TypeNode *node); -static inline void type_data_unref_U (TypeNode *node, - gboolean uncached); -static void type_data_last_unref_Wm (TypeNode * node, - gboolean uncached); static inline gpointer type_get_qdata_L (TypeNode *node, GQuark quark); static inline void type_set_qdata_W (TypeNode *node, @@ -230,7 +226,6 @@ typedef enum /* --- structures --- */ struct _TypeNode { - guint ref_count; /* (atomic) */ #ifdef G_ENABLE_DEBUG guint instance_count; /* (atomic) */ #endif @@ -264,7 +259,6 @@ struct _TypeNode #define NODE_PARENT_TYPE(node) (node->supers[1]) #define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) #define NODE_NAME(node) (g_quark_to_string (node->qname)) -#define NODE_REFCOUNT(node) ((guint) g_atomic_int_get ((int *) &(node)->ref_count)) #define NODE_IS_BOXED(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_BOXED) #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) #define CLASSED_NODE_IFACES_ENTRIES(node) (&(node)->_prot.iface_entries) @@ -1237,8 +1231,6 @@ type_data_make_W (TypeNode *node, GPOINTER_TO_UINT (type_get_qdata_L (node, static_quark_type_flags)))); g_assert (node->data->common.value_table != NULL); /* paranoid */ - - g_atomic_int_set ((int *) &node->ref_count, 1); } static inline void @@ -1274,25 +1266,13 @@ type_data_ref_Wm (TypeNode *node) check_value_table_I (NODE_NAME (node), &tmp_value_table) ? &tmp_value_table : NULL); } - else - { - g_assert (NODE_REFCOUNT (node) > 0); - - g_atomic_int_inc ((int *) &node->ref_count); - } } static inline gboolean type_data_ref_U (TypeNode *node) { - guint current; - - do { - current = NODE_REFCOUNT (node); - - if (current < 1) - return FALSE; - } while (!g_atomic_int_compare_and_exchange ((int *) &node->ref_count, current, current + 1)); + if (node->data == NULL) + return FALSE; return TRUE; } @@ -1811,29 +1791,6 @@ type_iface_retrieve_holder_info_Wm (TypeNode *iface, } static void -type_iface_blow_holder_info_Wm (TypeNode *iface, - GType instance_type) -{ - IFaceHolder *iholder = iface_node_get_holders_L (iface); - - g_assert (NODE_IS_IFACE (iface)); - - while (iholder->instance_type != instance_type) - iholder = iholder->next; - - if (iholder->info && iholder->plugin) - { - g_free (iholder->info); - iholder->info = NULL; - - G_WRITE_UNLOCK (&type_rw_lock); - g_type_plugin_unuse (iholder->plugin); - type_data_unref_U (iface, FALSE); - G_WRITE_LOCK (&type_rw_lock); - } -} - -static void maybe_issue_deprecation_warning (GType type) { static GHashTable *already_warned_table; @@ -2205,41 +2162,6 @@ type_iface_vtable_iface_init_Wm (TypeNode *iface, } } -static gboolean -type_iface_vtable_finalize_Wm (TypeNode *iface, - TypeNode *node, - GTypeInterface *vtable) -{ - IFaceEntry *entry = type_lookup_iface_entry_L (node, iface); - IFaceHolder *iholder; - - /* type_iface_retrieve_holder_info_Wm() doesn't modify write lock for returning NULL */ - iholder = type_iface_retrieve_holder_info_Wm (iface, NODE_TYPE (node), FALSE); - if (!iholder) - return FALSE; /* we don't modify write lock upon FALSE */ - - g_assert (entry && entry->vtable == vtable && iholder->info); - - entry->vtable = NULL; - entry->init_state = UNINITIALIZED; - if (iholder->info->interface_finalize || iface->data->iface.vtable_finalize_base) - { - G_WRITE_UNLOCK (&type_rw_lock); - if (iholder->info->interface_finalize) - iholder->info->interface_finalize (vtable, iholder->info->interface_data); - if (iface->data->iface.vtable_finalize_base) - iface->data->iface.vtable_finalize_base (vtable); - G_WRITE_LOCK (&type_rw_lock); - } - vtable->g_type = 0; - vtable->g_instance_type = 0; - g_free (vtable); - - type_iface_blow_holder_info_Wm (iface, NODE_TYPE (node)); - - return TRUE; /* write lock modified */ -} - static void type_class_init_Wm (TypeNode *node, GTypeClass *pclass) @@ -2400,193 +2322,6 @@ type_class_init_Wm (TypeNode *node, g_atomic_int_set (&node->data->class.init_state, INITIALIZED); } -static void -type_data_finalize_class_ifaces_Wm (TypeNode *node) -{ - guint i; - IFaceEntries *entries; - - g_assert (node->is_instantiatable && node->data && node->data->class.class && NODE_REFCOUNT (node) == 0); - - reiterate: - entries = CLASSED_NODE_IFACES_ENTRIES_LOCKED (node); - for (i = 0; entries != NULL && i < IFACE_ENTRIES_N_ENTRIES (entries); i++) - { - IFaceEntry *entry = &entries->entry[i]; - if (entry->vtable) - { - if (type_iface_vtable_finalize_Wm (lookup_type_node_I (entry->iface_type), node, entry->vtable)) - { - /* refetch entries, IFACES_ENTRIES might be modified */ - goto reiterate; - } - else - { - /* type_iface_vtable_finalize_Wm() doesn't modify write lock upon FALSE, - * iface vtable came from parent - */ - entry->vtable = NULL; - entry->init_state = UNINITIALIZED; - } - } - } -} - -static void -type_data_finalize_class_U (TypeNode *node, - ClassData *cdata) -{ - GTypeClass *class = cdata->class; - TypeNode *bnode; - - g_assert (cdata->class && NODE_REFCOUNT (node) == 0); - - if (cdata->class_finalize) - cdata->class_finalize (class, (gpointer) cdata->class_data); - - /* call all base class destruction functions in descending order - */ - if (cdata->class_finalize_base) - cdata->class_finalize_base (class); - for (bnode = lookup_type_node_I (NODE_PARENT_TYPE (node)); bnode; bnode = lookup_type_node_I (NODE_PARENT_TYPE (bnode))) - if (bnode->data->class.class_finalize_base) - bnode->data->class.class_finalize_base (class); - - g_free (cdata->class); -} - -static void -type_data_last_unref_Wm (TypeNode *node, - gboolean uncached) -{ - g_return_if_fail (node != NULL && node->plugin != NULL); - - if (!node->data || NODE_REFCOUNT (node) == 0) - { - g_critical ("cannot drop last reference to unreferenced type '%s'", - NODE_NAME (node)); - return; - } - - /* call class cache hooks */ - if (node->is_classed && node->data && node->data->class.class && static_n_class_cache_funcs && !uncached) - { - guint i; - - G_WRITE_UNLOCK (&type_rw_lock); - G_READ_LOCK (&type_rw_lock); - for (i = 0; i < static_n_class_cache_funcs; i++) - { - GTypeClassCacheFunc cache_func = static_class_cache_funcs[i].cache_func; - gpointer cache_data = static_class_cache_funcs[i].cache_data; - gboolean need_break; - - G_READ_UNLOCK (&type_rw_lock); - need_break = cache_func (cache_data, node->data->class.class); - G_READ_LOCK (&type_rw_lock); - if (!node->data || NODE_REFCOUNT (node) == 0) - INVALID_RECURSION ("GType class cache function ", cache_func, NODE_NAME (node)); - if (need_break) - break; - } - G_READ_UNLOCK (&type_rw_lock); - G_WRITE_LOCK (&type_rw_lock); - } - - /* may have been re-referenced meanwhile */ - if (g_atomic_int_dec_and_test ((int *) &node->ref_count)) - { - GType ptype = NODE_PARENT_TYPE (node); - TypeData *tdata; - - if (node->is_instantiatable) - { - /* destroy node->data->instance.mem_chunk */ - } - - tdata = node->data; - if (node->is_classed && tdata->class.class) - { - if (CLASSED_NODE_IFACES_ENTRIES_LOCKED (node) != NULL) - type_data_finalize_class_ifaces_Wm (node); - node->mutatable_check_cache = FALSE; - node->data = NULL; - G_WRITE_UNLOCK (&type_rw_lock); - type_data_finalize_class_U (node, &tdata->class); - G_WRITE_LOCK (&type_rw_lock); - } - else if (NODE_IS_IFACE (node) && tdata->iface.dflt_vtable) - { - node->mutatable_check_cache = FALSE; - node->data = NULL; - if (tdata->iface.dflt_finalize || tdata->iface.vtable_finalize_base) - { - G_WRITE_UNLOCK (&type_rw_lock); - if (tdata->iface.dflt_finalize) - tdata->iface.dflt_finalize (tdata->iface.dflt_vtable, (gpointer) tdata->iface.dflt_data); - if (tdata->iface.vtable_finalize_base) - tdata->iface.vtable_finalize_base (tdata->iface.dflt_vtable); - G_WRITE_LOCK (&type_rw_lock); - } - g_free (tdata->iface.dflt_vtable); - } - else - { - node->mutatable_check_cache = FALSE; - node->data = NULL; - } - - /* freeing tdata->common.value_table and its contents is taken care of - * by allocating it in one chunk with tdata - */ - g_free (tdata); - - G_WRITE_UNLOCK (&type_rw_lock); - g_type_plugin_unuse (node->plugin); - if (ptype) - type_data_unref_U (lookup_type_node_I (ptype), FALSE); - G_WRITE_LOCK (&type_rw_lock); - } -} - -static inline void -type_data_unref_U (TypeNode *node, - gboolean uncached) -{ - guint current; - - do { - current = NODE_REFCOUNT (node); - - if (current <= 1) - { - if (!node->plugin) - { - g_critical ("static type '%s' unreferenced too often", - NODE_NAME (node)); - return; - } - else - { - /* This is the last reference of a type from a plugin. We are - * experimentally disabling support for unloading type - * plugins, so don't allow the last ref to drop. - */ - return; - } - - g_assert (current > 0); - - g_rec_mutex_lock (&class_init_rec_mutex); /* required locking order: 1) class_init_rec_mutex, 2) type_rw_lock */ - G_WRITE_LOCK (&type_rw_lock); - type_data_last_unref_Wm (node, uncached); - G_WRITE_UNLOCK (&type_rw_lock); - g_rec_mutex_unlock (&class_init_rec_mutex); - return; - } - } while (!g_atomic_int_compare_and_exchange ((int *) &node->ref_count, current, current - 1)); -} - /** * g_type_add_class_cache_func: (skip) * @cache_data: data to be passed to @cache_func @@ -3023,19 +2758,25 @@ g_type_add_interface_dynamic (GType instance_type, /* --- public API functions --- */ + /** - * g_type_class_ref: + * g_type_class_get: * @type: type ID of a classed type * - * Increments the reference count of the class structure belonging to - * @type. This function will demand-create the class if it doesn't - * exist already. + * Retrieves the type class of the given @type. * - * Returns: (type GObject.TypeClass) (transfer none): the #GTypeClass - * structure for the given type ID + * This function will create the class on demand if it does not exist + * already. + * + * If you don't want to create the class, use g_type_class_peek() instead. + * + * Returns: (transfer none) (type GObject.TypeClass): the class structure + * for the type + * + * Since: FIXME */ gpointer -g_type_class_ref (GType type) +g_type_class_get (GType type) { TypeNode *node; GType ptype; @@ -3069,7 +2810,7 @@ g_type_class_ref (GType type) /* we need an initialized parent class for initializing derived classes */ ptype = NODE_PARENT_TYPE (node); - pclass = ptype ? g_type_class_ref (ptype) : NULL; + pclass = ptype ? g_type_class_get (ptype) : NULL; G_WRITE_LOCK (&type_rw_lock); @@ -3090,28 +2831,40 @@ g_type_class_ref (GType type) } /** + * g_type_class_ref: + * @type: type ID of a classed type + * + * Increments the reference count of the class structure belonging to + * @type. + * + * This function will demand-create the class if it doesn't exist already. + * + * Returns: (type GObject.TypeClass) (transfer none): the #GTypeClass + * structure for the given type ID + * + * Deprecated: FIXME: Use g_type_class_get() instead + */ +gpointer +g_type_class_ref (GType type) +{ + return g_type_class_get (type); +} + +/** * g_type_class_unref: * @g_class: (type GObject.TypeClass): a #GTypeClass structure to unref * * Decrements the reference count of the class structure being passed in. + * * Once the last reference count of a class has been released, classes * may be finalized by the type system, so further dereferencing of a * class pointer after g_type_class_unref() are invalid. + * + * Deprecated: FIXME: This function does not do anything. */ void g_type_class_unref (gpointer g_class) { - TypeNode *node; - GTypeClass *class = g_class; - - g_return_if_fail (g_class != NULL); - - node = lookup_type_node_I (class->g_type); - if (node && node->is_classed && NODE_REFCOUNT (node)) - type_data_unref_U (node, FALSE); - else - g_critical ("cannot unreference class of invalid (unclassed) type '%s'", - type_descriptive_name_I (class->g_type)); } /** @@ -3119,39 +2872,35 @@ g_type_class_unref (gpointer g_class) * @g_class: (type GObject.TypeClass): a #GTypeClass structure to unref * * A variant of g_type_class_unref() for use in #GTypeClassCacheFunc - * implementations. It unreferences a class without consulting the chain + * implementations. + * + * It unreferences a class without consulting the chain * of #GTypeClassCacheFuncs, avoiding the recursion which would occur * otherwise. + * + * Deprecated: FIXME: This function does not do anything */ void g_type_class_unref_uncached (gpointer g_class) { - TypeNode *node; - GTypeClass *class = g_class; - - g_return_if_fail (g_class != NULL); - - node = lookup_type_node_I (class->g_type); - if (node && node->is_classed && NODE_REFCOUNT (node)) - type_data_unref_U (node, TRUE); - else - g_critical ("cannot unreference class of invalid (unclassed) type '%s'", - type_descriptive_name_I (class->g_type)); } /** * g_type_class_peek: * @type: type ID of a classed type * + * Retrieves the class for a give type. + * * This function is essentially the same as g_type_class_ref(), - * except that the classes reference count isn't incremented. + * except that the class may have not been instantiated yet. + * * As a consequence, this function may return %NULL if the class * of the type passed in does not currently exist (hasn't been * referenced before). * * Returns: (type GObject.TypeClass) (transfer none): the #GTypeClass - * structure for the given type ID or %NULL if the class does not - * currently exist + * structure for the given type ID or %NULL if the class does not + * currently exist */ gpointer g_type_class_peek (GType type) @@ -3160,9 +2909,9 @@ g_type_class_peek (GType type) gpointer class; node = lookup_type_node_I (type); - if (node && node->is_classed && NODE_REFCOUNT (node) && + if (node && node->is_classed && + node->data && g_atomic_int_get (&node->data->class.init_state) == INITIALIZED) - /* ref_count _may_ be 0 */ class = node->data->class.class; else class = NULL; @@ -3177,9 +2926,9 @@ g_type_class_peek (GType type) * A more efficient version of g_type_class_peek() which works only for * static types. * - * Returns: (type GObject.TypeClass) (transfer none): the #GTypeClass - * structure for the given type ID or %NULL if the class does not - * currently exist or is dynamically loaded + * Returns: (type GObject.TypeClass) (transfer none) (nullable): the + * #GTypeClass structure for the given type ID or %NULL if the class + * does not currently exist or is dynamically loaded * * Since: 2.4 */ @@ -3190,10 +2939,9 @@ g_type_class_peek_static (GType type) gpointer class; node = lookup_type_node_I (type); - if (node && node->is_classed && NODE_REFCOUNT (node) && + if (node && node->is_classed && node->data && /* peek only static types: */ node->plugin == NULL && g_atomic_int_get (&node->data->class.init_state) == INITIALIZED) - /* ref_count _may_ be 0 */ class = node->data->class.class; else class = NULL; @@ -3204,19 +2952,21 @@ g_type_class_peek_static (GType type) /** * g_type_class_peek_parent: * @g_class: (type GObject.TypeClass): the #GTypeClass structure to - * retrieve the parent class for + * retrieve the parent class for + * + * Retrieves the class structure of the immediate parent type of the + * class passed in. * * This is a convenience function often needed in class initializers. - * It returns the class structure of the immediate parent type of the - * class passed in. Since derived classes hold a reference count on - * their parent classes as long as they are instantiated, the returned - * class will always exist. + * + * Since derived classes hold a reference on their parent classes as + * long as they are instantiated, the returned class will always exist. * * This function is essentially equivalent to: * g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class))) * * Returns: (type GObject.TypeClass) (transfer none): the parent class - * of @g_class + * of @g_class */ gpointer g_type_class_peek_parent (gpointer g_class) @@ -3253,9 +3003,9 @@ g_type_class_peek_parent (gpointer g_class) * Returns the #GTypeInterface structure of an interface to which the * passed in class conforms. * - * Returns: (type GObject.TypeInterface) (transfer none): the #GTypeInterface - * structure of @iface_type if implemented by @instance_class, %NULL - * otherwise + * Returns: (type GObject.TypeInterface) (transfer none) (nullable): the #GTypeInterface + * structure of @iface_type if implemented by @instance_class, %NULL + * otherwise */ gpointer g_type_interface_peek (gpointer instance_class, @@ -3283,14 +3033,15 @@ g_type_interface_peek (gpointer instance_class, * @g_iface: (type GObject.TypeInterface): a #GTypeInterface structure * * Returns the corresponding #GTypeInterface structure of the parent type - * of the instance type to which @g_iface belongs. This is useful when - * deriving the implementation of an interface from the parent type and - * then possibly overriding some methods. - * - * Returns: (transfer none) (type GObject.TypeInterface): the - * corresponding #GTypeInterface structure of the parent type of the - * instance type to which @g_iface belongs, or %NULL if the parent - * type doesn't conform to the interface + * of the instance type to which @g_iface belongs. + * + * This is useful when deriving the implementation of an interface from the + * parent type and then possibly overriding some methods. + * + * Returns: (transfer none) (type GObject.TypeInterface) (nullable): the + * corresponding #GTypeInterface structure of the parent type of the + * instance type to which @g_iface belongs, or %NULL if the parent + * type doesn't conform to the interface */ gpointer g_type_interface_peek_parent (gpointer g_iface) @@ -3331,21 +3082,52 @@ g_type_interface_peek_parent (gpointer g_iface) * * Since: 2.4 * + * Deprecated: FIXME: Use g_type_default_interface_get() instead + * * Returns: (type GObject.TypeInterface) (transfer none): the default - * vtable for the interface; call g_type_default_interface_unref() - * when you are done using the interface. + * vtable for the interface; call g_type_default_interface_unref() + * when you are done using the interface. */ gpointer g_type_default_interface_ref (GType g_type) { + return g_type_default_interface_get (g_type); +} + +/** + * g_type_default_interface_get: + * @g_type: an interface type + * + * Returns the default interface vtable for the given @g_type. + * + * If the type is not currently in use, then the default vtable + * for the type will be created and initialized by calling + * the base interface init and default vtable init functions for + * the type (the @base_init and @class_init members of #GTypeInfo). + * + * If you don't want to create the interface vtable, you should use + * g_type_default_interface_peek() instead. + * + * Calling g_type_default_interface_get() is useful when you + * want to make sure that signals and properties for an interface + * have been installed. + * + * Returns: (type GObject.TypeInterface) (transfer none): the default + * vtable for the interface; call g_type_default_interface_unref() + * when you are done using the interface. + * + * Since: FIXME + */ +gpointer +g_type_default_interface_get (GType g_type) +{ TypeNode *node; gpointer dflt_vtable; G_WRITE_LOCK (&type_rw_lock); node = lookup_type_node_I (g_type); - if (!node || !NODE_IS_IFACE (node) || - (node->data && NODE_REFCOUNT (node) == 0)) + if (!node || !NODE_IS_IFACE (node)) { G_WRITE_UNLOCK (&type_rw_lock); g_critical ("cannot retrieve default vtable for invalid or non-interface type '%s'", @@ -3363,8 +3145,6 @@ g_type_default_interface_ref (GType g_type) type_iface_ensure_dflt_vtable_Wm (node); g_rec_mutex_unlock (&class_init_rec_mutex); } - else - type_data_ref_Wm (node); /* ref_count >= 1 already */ dflt_vtable = node->data->iface.dflt_vtable; G_WRITE_UNLOCK (&type_rw_lock); @@ -3382,8 +3162,8 @@ g_type_default_interface_ref (GType g_type) * Since: 2.4 * * Returns: (type GObject.TypeInterface) (transfer none): the default - * vtable for the interface, or %NULL if the type is not currently - * in use + * vtable for the interface, or %NULL if the type is not currently + * in use */ gpointer g_type_default_interface_peek (GType g_type) @@ -3392,7 +3172,7 @@ g_type_default_interface_peek (GType g_type) gpointer vtable; node = lookup_type_node_I (g_type); - if (node && NODE_IS_IFACE (node) && NODE_REFCOUNT (node)) + if (node && NODE_IS_IFACE (node) && node->data) vtable = node->data->iface.dflt_vtable; else vtable = NULL; @@ -3412,21 +3192,12 @@ g_type_default_interface_peek (GType g_type) * vtable (the @class_finalize member of #GTypeInfo) will be called. * * Since: 2.4 + * + * Deprecated: FIXME: This function does not do anything */ void g_type_default_interface_unref (gpointer g_iface) { - TypeNode *node; - GTypeInterface *vtable = g_iface; - - g_return_if_fail (g_iface != NULL); - - node = lookup_type_node_I (vtable->g_type); - if (node && NODE_IS_IFACE (node)) - type_data_unref_U (node, FALSE); - else - g_critical ("cannot unreference invalid interface default vtable for '%s'", - type_descriptive_name_I (vtable->g_type)); } /** @@ -4315,7 +4086,7 @@ type_check_is_value_type_U (GType type) restart_check: if (node) { - if (node->data && NODE_REFCOUNT (node) > 0 && + if (node->data && node->data->common.value_table->value_init) tflags = GPOINTER_TO_UINT (type_get_qdata_L (node, static_quark_type_flags)); else if (NODE_IS_IFACE (node)) @@ -4370,23 +4141,24 @@ g_type_check_value_holds (const GValue *value, * that implements or has internal knowledge of the implementation of * @type. * - * Returns: location of the #GTypeValueTable associated with @type or - * %NULL if there is no #GTypeValueTable associated with @type + * Returns: (nullable) (transfer none): location of the #GTypeValueTable + * associated with @type or %NULL if there is no #GTypeValueTable + * associated with @type */ -GTypeValueTable* +GTypeValueTable * g_type_value_table_peek (GType type) { GTypeValueTable *vtable = NULL; TypeNode *node = lookup_type_node_I (type); gboolean has_refed_data, has_table; - if (node && NODE_REFCOUNT (node) && node->mutatable_check_cache) + if (node && node->mutatable_check_cache) return node->data->common.value_table; G_READ_LOCK (&type_rw_lock); restart_table_peek: - has_refed_data = node && node->data && NODE_REFCOUNT (node) > 0; + has_refed_data = node && node->data; has_table = has_refed_data && node->data->common.value_table->value_init; if (has_refed_data) { @@ -5066,7 +4838,7 @@ g_type_class_get_private (GTypeClass *klass, if (NODE_PARENT_TYPE (private_node)) { parent_node = lookup_type_node_I (NODE_PARENT_TYPE (private_node)); - g_assert (parent_node->data && NODE_REFCOUNT (parent_node) > 0); + g_assert (parent_node->data); if (G_UNLIKELY (private_node->data->class.class_private_size == parent_node->data->class.class_private_size)) { diff --git a/gobject/gtype.h b/gobject/gtype.h index 04e373385..9ed47a347 100644 --- a/gobject/gtype.h +++ b/gobject/gtype.h @@ -749,6 +749,8 @@ gboolean g_type_is_a (GType type, #define g_type_is_a(a,b) ((a) == (b) || (g_type_is_a) ((a), (b))) GOBJECT_AVAILABLE_IN_ALL +gpointer g_type_class_get (GType type); +GOBJECT_AVAILABLE_IN_ALL gpointer g_type_class_ref (GType type); GOBJECT_AVAILABLE_IN_ALL gpointer g_type_class_peek (GType type); @@ -765,6 +767,8 @@ GOBJECT_AVAILABLE_IN_ALL gpointer g_type_interface_peek_parent (gpointer g_iface); GOBJECT_AVAILABLE_IN_ALL +gpointer g_type_default_interface_get (GType g_type); +GOBJECT_AVAILABLE_IN_ALL gpointer g_type_default_interface_ref (GType g_type); GOBJECT_AVAILABLE_IN_ALL gpointer g_type_default_interface_peek (GType g_type); |