luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-09-20 01:06:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Migrating docs.

Browse Source 
* docs/reference/gobject/tmpl/gtype.sgml:
	* gobject/gtype.c:
	* gobject/gtype.h:
	* gobject/gvaluetypes.h:
	  Migrating docs.


svn path=/trunk/; revision=7075
This commit is contained in:
Stefan Kost 2008-06-21 16:14:18 +00:00
parent 4b109856d0
commit 005be9980a
5 changed files with 1636 additions and 1867 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ChangeLog
View File

@ -1,3 +1,11 @@
2008-06-21 Stefan Kost <ensonic@users.sf.net>
* docs/reference/gobject/tmpl/gtype.sgml:
* gobject/gtype.c:
* gobject/gtype.h:
* gobject/gvaluetypes.h:
Migrating docs.
2008-06-21 Stefan Kost <ensonic@users.sf.net>
* gobject/gclosure.h:

1844
docs/reference/gobject/tmpl/gtype.sgml
View File

File diff suppressed because it is too large Load Diff

602
gobject/gtype.c
View File

@ -16,6 +16,42 @@
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*/
/**
* SECTION:gtype
* @Short_description: The GLib Runtime type identification and management system
* @Title:Type Information
*
* The GType API is the foundation of the GObject system. It provides the
* facilities for registering and managing all fundamental data types,
* user-defined object and interface types. Before using any GType
* or GObject functions, g_type_init() must be called to initialize the
* type system.
*
* For type creation and registration purposes, all types fall into one of
* two categories: static or dynamic. Static types are never loaded or
* unloaded at run-time as dynamic types may be. Static types are created
* with g_type_register_static() that gets type specific information passed
* in via a #GTypeInfo structure.
* Dynamic types are created with g_type_register_dynamic() which takes a
* #GTypePlugin structure instead. The remaining type information (the
* #GTypeInfo structure) is retrieved during runtime through #GTypePlugin
* and the g_type_plugin_*() API.
* These registration functions are usually called only once from a
* function whose only purpose is to return the type identifier for a
* specific class. Once the type (or class or interface) is registered,
* it may be instantiated, inherited, or implemented depending on exactly
* what sort of type it is.
* There is also a third registration function for registering fundamental
* types called g_type_register_fundamental() which requires both a #GTypeInfo
* structure and a #GTypeFundamentalInfo structure but it is seldom used
* since most fundamental types are predefined rather than user-defined.
*
* A final word about type names.
* Such an identifier needs to be at least three characters long. There is no
* upper length limit. The first character needs to be a letter (a-z or A-Z)
* or an underscore '_'. Subsequent characters can be letters, numbers or
* any of '-_+'.
*/
#include <config.h>
#include "gtype.h"
@ -1255,6 +1291,17 @@ type_iface_add_prerequisite_W (TypeNode *iface,
type_iface_add_prerequisite_W (lookup_type_node_I (dependants[i]), prerequisite_node);
}
/**
* g_type_interface_add_prerequisite:
* @interface_type: #GType value of an interface type.
* @prerequisite_type: #GType value of an interface or instantiatable type.
*
* Adds @prerequisite_type to the list of prerequisites of @interface_type.
* This means that any type implementing @interface_type must also implement
* @prerequisite_type. Prerequisites can be thought of as an alternative to
* interface derivation (which GType doesn't support). An interface can have
* at most one instantiatable prerequisite type.
*/
void
g_type_interface_add_prerequisite (GType interface_type,
GType prerequisite_type)
@ -1330,7 +1377,18 @@ g_type_interface_add_prerequisite (GType interface_type,
}
}
GType* /* free result */
/**
* g_type_interface_prerequisites:
* @interface_type: an interface type
* @n_prerequisites: location to return the number of prerequisites, or %NULL
*
* Returns the prerequisites of an interfaces type.
*
* Since: 2.2
* Returns: a newly-allocated zero-terminated array of #GType containing
* the prerequisites of @interface_type
*/
GType*
g_type_interface_prerequisites (GType interface_type,
guint *n_prerequisites)
{
@ -1526,6 +1584,26 @@ instance_real_class_get (gpointer instance)
return class;
}
/**
* g_type_create_instance:
* @type: An instantiatable type to create an instance for.
*
* Creates and initializes an instance of @type if @type is valid and can
* be instantiated. The type system only performs basic allocation and
* structure setups for instances: actual instance creation should happen
* through functions supplied by the type's fundamental type implementation.
* So use of g_type_create_instance() is reserved for implementators of
* fundamental types only. E.g. instances of the #GObject hierarchy
* should be created via g_object_new() and <emphasis>never</emphasis>
* directly through g_type_create_instance() which doesn't handle
* things like singleton objects or object construction.
* Note: Do <emphasis>not</emphasis> use this function, unless you're
* implementing a fundamental type. Also language bindings should <emphasis>not</emphasis>
* use this function but g_object_new() instead.
*
* Returns: An allocated and initialized instance, subject to further
* treatment by the fundamental type implementation.
*/
GTypeInstance*
g_type_create_instance (GType type)
{
@ -1577,6 +1655,16 @@ g_type_create_instance (GType type)
return instance;
}
/**
* g_type_free_instance:
* @instance: an instance of a type.
*
* Frees an instance of a type, returning it to the instance pool for the type,
* if there is one.
*
* Like g_type_create_instance(), this function is reserved for implementors of
* fundamental types.
*/
void
g_type_free_instance (GTypeInstance *instance)
{
@ -2067,6 +2155,19 @@ type_data_last_unref_Wm (GType type,
}
}
/**
* g_type_add_class_cache_func:
* @cache_data: data to be passed to @cache_func
* @cache_func: a #GTypeClassCacheFunc
*
* Adds a #GTypeClassCacheFunc to be called before the reference count of a
* class goes from one to zero. This can be used to prevent premature class
* destruction. All installed #GTypeClassCacheFunc functions will be chained
* until one of them returns %TRUE. The functions have to check the class id
* passed in to figure whether they actually want to cache the class of this
* type, since all classes are routed through the same #GTypeClassCacheFunc
* chain.
*/
void
g_type_add_class_cache_func (gpointer cache_data,
GTypeClassCacheFunc cache_func)
@ -2083,6 +2184,15 @@ g_type_add_class_cache_func (gpointer cache_data,
G_WRITE_UNLOCK (&type_rw_lock);
}
/**
* g_type_remove_class_cache_func:
* @cache_data: data that was given when adding @cache_func
* @cache_func: a #GTypeClassCacheFunc
*
* Removes a previously installed #GTypeClassCacheFunc. The cache maintained
* by @cache_func has to be empty when calling g_type_remove_class_cache_func()
* to avoid leaks.
*/
void
g_type_remove_class_cache_func (gpointer cache_data,
GTypeClassCacheFunc cache_func)
@ -2113,6 +2223,24 @@ g_type_remove_class_cache_func (gpointer cache_data,
}
/**
* g_type_add_interface_check:
* @check_data: data to pass to @check_func
* @check_func: function to be called after each interface
* is initialized.
*
* Adds a function to be called after an interface vtable is
* initialized for any class (i.e. after the @interface_init
* member of #GInterfaceInfo has been called).
*
* This function is useful when you want to check an invariant
* that depends on the interfaces of a class. For instance,
* the implementation of #GObject uses this facility to check
* that an object implements all of the properties that are
* defined on its interfaces.
*
* Since: 2.4
*/
void
g_type_add_interface_check (gpointer check_data,
GTypeInterfaceCheckFunc check_func)
@ -2129,6 +2257,16 @@ g_type_add_interface_check (gpointer check_data,
G_WRITE_UNLOCK (&type_rw_lock);
}
/**
* g_type_remove_interface_check:
* @check_data: callback data passed to g_type_add_interface_check()
* @check_func: callback function passed to g_type_add_interface_check()
*
* Removes an interface check function added with
* g_type_add_interface_check().
*
* Since: 2.4
*/
void
g_type_remove_interface_check (gpointer check_data,
GTypeInterfaceCheckFunc check_func)
@ -2159,6 +2297,23 @@ g_type_remove_interface_check (gpointer check_data,
}
/* --- type registration --- */
/**
* g_type_register_fundamental:
* @type_id: A predefined type identifier.
* @type_name: 0-terminated string used as the name of the new type.
* @info: The #GTypeInfo structure for this type.
* @finfo: The #GTypeFundamentalInfo structure for this type.
* @flags: Bitwise combination of #GTypeFlags values.
*
* Registers @type_id as the predefined identifier and @type_name as the
* name of a fundamental type. The type system uses the information
* contained in the #GTypeInfo structure pointed to by @info and the
* #GTypeFundamentalInfo structure pointed to by @finfo to manage the
* type and its instances. The value of @flags determines additional
* characteristics of the fundamental type.
*
* Returns: The predefined type identifier.
*/
GType
g_type_register_fundamental (GType type_id,
const gchar *type_name,
@ -2211,6 +2366,24 @@ g_type_register_fundamental (GType type_id,
return NODE_TYPE (node);
}
/**
* g_type_register_static_simple:
* @parent_type: Type from which this type will be derived.
* @type_name: 0-terminated string used as the name of the new type.
* @class_size: Size of the class structure (see #GTypeInfo)
* @class_init: Location of the class initialization function (see #GTypeInfo)
* @instance_size: Size of the instance structure (see #GTypeInfo)
* @instance_init: Location of the instance initialization function (see #GTypeInfo)
* @flags: Bitwise combination of #GTypeFlags values.
*
* Registers @type_name as the name of a new static type derived from
* @parent_type. The value of @flags determines the nature (e.g.
* abstract or not) of the type. It works by filling a #GTypeInfo
* struct and calling g_type_register_static().
*
* Since: 2.12
* Returns: The new type identifier.
*/
GType
g_type_register_static_simple (GType parent_type,
const gchar *type_name,
@ -2236,6 +2409,21 @@ g_type_register_static_simple (GType parent_type,
return g_type_register_static (parent_type, type_name, &info, flags);
}
/**
* g_type_register_static:
* @parent_type: Type from which this type will be derived.
* @type_name: 0-terminated string used as the name of the new type.
* @info: The #GTypeInfo structure for this type.
* @flags: Bitwise combination of #GTypeFlags values.
*
* Registers @type_name as the name of a new static type derived from
* @parent_type. The type system uses the information contained in the
* #GTypeInfo structure pointed to by @info to manage the type and its
* instances (if not abstract). The value of @flags determines the nature
* (e.g. abstract or not) of the type.
*
* Returns: The new type identifier.
*/
GType
g_type_register_static (GType parent_type,
const gchar *type_name,
@ -2276,6 +2464,21 @@ g_type_register_static (GType parent_type,
return type;
}
/**
* g_type_register_dynamic:
* @parent_type: Type from which this type will be derived.
* @type_name: 0-terminated string used as the name of the new type.
* @plugin: The #GTypePlugin structure to retrieve the #GTypeInfo from.
* @flags: Bitwise combination of #GTypeFlags values.
*
* Registers @type_name as the name of a new dynamic type derived from
* @parent_type. The type system uses the information contained in the
* #GTypePlugin structure pointed to by @plugin to manage the type and its
* instances (if not abstract). The value of @flags determines the nature
* (e.g. abstract or not) of the type.
*
* Returns: The new type identifier or #G_TYPE_INVALID if registration failed.
*/
GType
g_type_register_dynamic (GType parent_type,
const gchar *type_name,
@ -2305,6 +2508,17 @@ g_type_register_dynamic (GType parent_type,
return type;
}
/**
* g_type_add_interface_static:
* @instance_type: #GType value of an instantiable type.
* @interface_type: #GType value of an interface type.
* @info: The #GInterfaceInfo structure for this
* (@instance_type, @interface_type) combination.
*
* Adds the static @interface_type to @instantiable_type. The information
* contained in the #GTypeInterfaceInfo structure pointed to by @info
* is used to manage the relationship.
*/
void
g_type_add_interface_static (GType instance_type,
GType interface_type,
@ -2331,6 +2545,16 @@ g_type_add_interface_static (GType instance_type,
g_static_rec_mutex_unlock (&class_init_rec_mutex);
}
/**
* g_type_add_interface_dynamic:
* @instance_type: the #GType value of an instantiable type.
* @interface_type: the #GType value of an interface type.
* @plugin: the #GTypePlugin structure to retrieve the #GInterfaceInfo from.
*
* Adds the dynamic @interface_type to @instantiable_type. The information
* contained in the #GTypePlugin structure pointed to by @plugin
* is used to manage the relationship.
*/
void
g_type_add_interface_dynamic (GType instance_type,
GType interface_type,
@ -2359,6 +2583,16 @@ g_type_add_interface_dynamic (GType instance_type,
/* --- public API functions --- */
/**
* 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: The #GTypeClass structure for the given type ID.
*/
gpointer
g_type_class_ref (GType type)
{
@ -2409,6 +2643,15 @@ g_type_class_ref (GType type)
return node->data->class.class;
}
/**
* g_type_class_unref:
* @g_class: The #GTypeClass structure to unreference.
*
* 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.
*/
void
g_type_class_unref (gpointer g_class)
{
@ -2428,6 +2671,15 @@ g_type_class_unref (gpointer g_class)
G_WRITE_UNLOCK (&type_rw_lock);
}
/**
* g_type_class_unref_uncached:
* @g_class: The #GTypeClass structure to unreference.
*
* A variant of g_type_class_unref() for use in #GTypeClassCacheFunc
* implementations. It unreferences a class without consulting the chain
* of #GTypeClassCacheFunc<!-- -->s, avoiding the recursion which would occur
* otherwise.
*/
void
g_type_class_unref_uncached (gpointer g_class)
{
@ -2447,6 +2699,18 @@ g_type_class_unref_uncached (gpointer g_class)
G_WRITE_UNLOCK (&type_rw_lock);
}
/**
* g_type_class_peek:
* @type: Type ID of a classed type.
*
* This function is essentially the same as g_type_class_ref(), except that
* the classes reference count isn't incremented. 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: The #GTypeClass structure for the given type ID or %NULL
* if the class does not currently exist.
*/
gpointer
g_type_class_peek (GType type)
{
@ -2464,6 +2728,17 @@ g_type_class_peek (GType type)
return class;
}
/**
* g_type_class_peek_static:
* @type: Type ID of a classed type.
*
* A more efficient version of g_type_class_peek() which works only for
* static types.
*
* Since: 2.4
* Returns: The #GTypeClass structure for the given type ID or %NULL
* if the class does not currently exist or is dynamically loaded.
*/
gpointer
g_type_class_peek_static (GType type)
{
@ -2483,6 +2758,23 @@ g_type_class_peek_static (GType type)
return class;
}
/**
* g_type_class_peek_parent:
* @g_class: The #GTypeClass structure to retrieve the parent class for.
*
* 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. This function is essentially
* equivalent to:
*
* <programlisting>
* g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class)));
* </programlisting>
*
* Returns: The parent class of @g_class.
*/
gpointer
g_type_class_peek_parent (gpointer g_class)
{
@ -2507,6 +2799,17 @@ g_type_class_peek_parent (gpointer g_class)
return class;
}
/**
* g_type_interface_peek:
* @instance_class: A #GTypeClass structure.
* @iface_type: An interface ID which this class conforms to.
*
* Returns the #GTypeInterface structure of an interface to which the passed in
* class conforms.
*
* Returns: The GTypeInterface structure of iface_type if implemented
* by @instance_class, %NULL otherwise
*/
gpointer
g_type_interface_peek (gpointer instance_class,
GType iface_type)
@ -2538,6 +2841,19 @@ g_type_interface_peek (gpointer instance_class,
return vtable;
}
/**
* g_type_interface_peek_parent:
* @g_iface: 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: 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)
{
@ -2570,6 +2886,27 @@ g_type_interface_peek_parent (gpointer g_iface)
return vtable;
}
/**
* g_type_default_interface_ref:
* @g_type: an interface type
*
* Increments the reference count for the interface type @g_type,
* and returns the default interface vtable for the type.
*
* If the type is not currently in use, then the default vtable
* for the type will be created and initalized by calling
* the base interface init and default vtable init functions for
* the type (the @<structfield>base_init</structfield>
* and <structfield>class_init</structfield> members of #GTypeInfo).
* Calling g_type_default_interface_ref() is useful when you
* want to make sure that signals and properties for an interface
* have been installed.
*
* Since: 2.4
* Returns: the default 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)
{
@ -2607,6 +2944,17 @@ g_type_default_interface_ref (GType g_type)
return dflt_vtable;
}
/**
* g_type_default_interface_peek:
* @g_type: an interface type
*
* If the interface type @g_type is currently in use, returns
* its default interface vtable.
*
* Since: 2.4
* Returns: the default vtable for the interface, or %NULL
* if the type is not currently in use.
*/
gpointer
g_type_default_interface_peek (GType g_type)
{
@ -2624,6 +2972,20 @@ g_type_default_interface_peek (GType g_type)
return vtable;
}
/**
* g_type_default_interface_unref:
* @g_iface: the default vtable structure for a interface, as
* returned by g_type_default_interface_ref()
*
* Decrements the reference count for the type corresponding to the
* interface default vtable @g_iface. If the type is dynamic, then
* when no one is using the interface and all references have
* been released, the finalize function for the interface's default
* vtable (the <structfield>class_finalize</structfield> member of
* #GTypeInfo) will be called.
*
* Since: 2.4
*/
void
g_type_default_interface_unref (gpointer g_iface)
{
@ -2644,6 +3006,18 @@ g_type_default_interface_unref (gpointer g_iface)
G_WRITE_UNLOCK (&type_rw_lock);
}
/**
* g_type_name:
* @type: Type to return name for.
*
* Get the unique name that is assigned to a type ID.
* Note that this function (like all other GType API) cannot cope with invalid
* type IDs. %G_TYPE_INVALID may be passed to this function, as may be any other
* validly registered type ID, but randomized type IDs should not be passed in and
* will most likely lead to a crash.
*
* Returns: Static type name or %NULL.
*/
G_CONST_RETURN gchar*
g_type_name (GType type)
{
@ -2656,6 +3030,14 @@ g_type_name (GType type)
return node ? NODE_NAME (node) : NULL;
}
/**
* g_type_qname:
* @type: Type to return quark of type name for.
*
* Get the corresponding quark of the type IDs name.
*
* Returns: The type names quark or 0.
*/
GQuark
g_type_qname (GType type)
{
@ -2666,6 +3048,15 @@ g_type_qname (GType type)
return node ? node->qname : 0;
}
/**
* g_type_from_name:
* @name: Type name to lookup.
*
* Lookup the type ID from a given type name, returning 0 if no type has been registered under this name
* (this is the preferred method to find out by name whether a specific type has been registered yet).
*
* Returns: Corresponding type ID or 0.
*/
GType
g_type_from_name (const gchar *name)
{
@ -2685,6 +3076,15 @@ g_type_from_name (const gchar *name)
return type;
}
/**
* g_type_parent:
* @type: The derived type.
*
* Return the direct parent type of the passed in type.
* If the passed in type has no parent, i.e. is a fundamental type, 0 is returned.
*
* Returns: The parent type.
*/
GType
g_type_parent (GType type)
{
@ -2695,6 +3095,15 @@ g_type_parent (GType type)
return node ? NODE_PARENT_TYPE (node) : 0;
}
/**
* g_type_depth:
* @type: A #GType value.
*
* Returns the length of the ancestry of the passed in type. This includes the
* type itself, so that e.g. a fundamental type has depth 1.
*
* Returns: The depth of @type.
*/
guint
g_type_depth (GType type)
{
@ -2705,6 +3114,20 @@ g_type_depth (GType type)
return node ? node->n_supers + 1 : 0;
}
/**
* g_type_next_base:
* @leaf_type: Descendant of @root_type and the type to be returned.
* @root_type: Immediate parent of the returned type.
*
* Given a @leaf_type and a @root_type which is contained in its anchestry, return
* the type that @root_type is the immediate parent of.
* In other words, this function determines the type that is derived directly from
* @root_type which is also a base class of @leaf_type. Given a root type and a
* leaf type, this function can be used to determine the types and order in which
* the leaf type is descended from the root type.
*
* Returns: Immediate child of @root_type and anchestor of @leaf_type.
*/
GType
g_type_next_base (GType type,
GType base_type)
@ -2776,6 +3199,16 @@ type_node_conforms_to_U (TypeNode *node,
return type_node_check_conformities_UorL (node, iface_node, support_interfaces, support_prerequisites, FALSE);
}
/**
* g_type_is_a:
* @type: Type to check anchestry for.
* @is_a_type: Possible anchestor of @type or interface @type could conform to.
*
* If @is_a_type is a derivable type, check whether @type is a descendant of @is_a_type.
* If @is_a_type is an interface, check whether @type conforms to it.
*
* Returns: %TRUE if @type is_a @is_a_type holds true.
*/
gboolean
g_type_is_a (GType type,
GType iface_type)
@ -2790,7 +3223,17 @@ g_type_is_a (GType type,
return is_a;
}
GType* /* free result */
/**
* g_type_children:
* @type: The parent type.
* @n_children: Optional #guint pointer to contain the number of child types.
*
* Return a newly allocated and 0-terminated array of type IDs, listing the
* child types of @type. The return value has to be g_free()ed after use.
*
* Returns: Newly allocated and 0-terminated array of child types.
*/
GType*
g_type_children (GType type,
guint *n_children)
{
@ -2821,7 +3264,18 @@ g_type_children (GType type,
}
}
GType* /* free result */
/**
* g_type_interfaces:
* @type: The type to list interface types for.
* @n_interfaces: Optional #guint pointer to contain the number of interface types.
*
* Return a newly allocated and 0-terminated array of type IDs, listing the
* interface types that @type conforms to. The return value has to be
* g_free()ed after use.
*
* Returns: Newly allocated and 0-terminated array of interface types.
*/
GType*
g_type_interfaces (GType type,
guint *n_interfaces)
{
@ -2899,6 +3353,16 @@ type_get_qdata_L (TypeNode *node,
return NULL;
}
/**
* g_type_get_qdata:
* @type: a #GType
* @quark: a #GQuark id to identify the data
*
* Obtains data which has previously been attached to @type
* with g_type_set_qdata().
*
* Returns: the data, or %NULL if no data was found
*/
gpointer
g_type_get_qdata (GType type,
GQuark quark)
@ -2956,6 +3420,14 @@ type_set_qdata_W (TypeNode *node,
qdata[i].data = data;
}
/**
* g_type_set_qdata:
* @type: a #GType
* @quark: a #GQuark id to identify the data
* @data: the data
*
* Attaches arbitrary data to a type.
*/
void
g_type_set_qdata (GType type,
GQuark quark,
@ -2992,6 +3464,18 @@ type_add_flags_W (TypeNode *node,
type_set_qdata_W (node, static_quark_type_flags, GUINT_TO_POINTER (dflags));
}
/**
* g_type_query:
* @type: the #GType value of a static, classed type.
* @query: A user provided structure that is filled in with constant values
* upon success.
*
* Queries the type system for information about a specific type.
* This function will fill in a user-provided structure to hold type-specific
* information. If an invalid #GType is passed in, the @type member of the
* #GTypeQuery is 0. All members filled into the #GTypeQuery structure should
* be considered constant and have to be left untouched.
*/
void
g_type_query (GType type,
GTypeQuery *query)
@ -3057,6 +3541,16 @@ g_type_test_flags (GType type,
return result;
}
/**
* g_type_get_plugin:
* @type: The #GType to retrieve the plugin for.
*
* Returns the #GTypePlugin structure for @type or
* %NULL if @type does not have a #GTypePlugin structure.
*
* Returns: The corresponding plugin if @type is a dynamic type,
* %NULL otherwise.
*/
GTypePlugin*
g_type_get_plugin (GType type)
{
@ -3067,6 +3561,19 @@ g_type_get_plugin (GType type)
return node ? node->plugin : NULL;
}
/**
* g_type_interface_get_plugin:
* @instance_type: the #GType value of an instantiatable type.
* @interface_type: the #GType value of an interface type.
*
* Returns the #GTypePlugin structure for the dynamic interface
* @interface_type which has been added to @instance_type, or
* %NULL if @interface_type has not been added to @instance_type or does
* not have a #GTypePlugin structure. See g_type_add_interface_dynamic().
*
* Returns: the #GTypePlugin for the dynamic interface @interface_type
* of @instance_type.
*/
GTypePlugin*
g_type_interface_get_plugin (GType instance_type,
GType interface_type)
@ -3103,6 +3610,17 @@ g_type_interface_get_plugin (GType instance_type,
return NULL;
}
/**
* g_type_fundamental_next:
*
* Returns the next free fundamental type id which can be used to
* register a new fundamental type with g_type_register_fundamental().
* The returned type ID represents the highest currently registered
* fundamental type identifier.
*
* Returns: The nextmost fundamental type ID to be registered,
* or 0 if the type system ran out of fundamental type IDs.
*/
GType
g_type_fundamental_next (void)
{
@ -3115,6 +3633,15 @@ g_type_fundamental_next (void)
return type <= G_TYPE_FUNDAMENTAL_MAX ? type : 0;
}
/**
* g_type_fundamental:
* @type_id: valid type ID
*
* Internal function, used to extract the fundamental type ID portion.
* use G_TYPE_FUNDAMENTAL() instead.
*
* Returns: fundamental type ID
*/
GType
g_type_fundamental (GType type_id)
{
@ -3310,6 +3837,18 @@ g_type_check_value_holds (GValue *value,
return value && type_check_is_value_type_U (value->g_type) && g_type_is_a (value->g_type, type);
}
/**
* g_type_value_table_peek:
* @type: A #GType value.
*
* Returns the location of the #GTypeValueTable associated with @type.
* <emphasis>Note that this function should only be used from source code
* that implements or has internal knowledge of the implementation of
* @type.</emphasis>
*
* Returns: Location of the #GTypeValueTable associated with @type or
* %NULL if there is no #GTypeValueTable associated with @type.
*/
GTypeValueTable*
g_type_value_table_peek (GType type)
{
@ -3387,6 +3926,12 @@ g_type_name_from_class (GTypeClass *g_class)
/* --- initialization --- */
/**
* g_type_init_with_debug_flags:
* @debug_flags: Bitwise combination of #GTypeDebugFlags values for debugging purposes.
*
* Similar to g_type_init(), but additionally sets debug flags.
*/
void
g_type_init_with_debug_flags (GTypeDebugFlags debug_flags)
{
@ -3492,12 +4037,63 @@ g_type_init_with_debug_flags (GTypeDebugFlags debug_flags)
G_UNLOCK (type_init_lock);
}
/**
* g_type_init:
*
* Prior to any use of the type system, g_type_init() has to be called to initialize
* the type system and assorted other code portions (such as the various fundamental
* type implementations or the signal system).
*/
void
g_type_init (void)
{
g_type_init_with_debug_flags (0);
}
/**
* g_type_class_add_private:
* @g_class: class structure for an instantiatable type
* @private_size: size of private structure.
*
* Registers a private structure for an instantiatable type;
* when an object is allocated, the private structures for
* the type and all of its parent types are allocated
* sequentially in the same memory block as the public
* structures. This function should be called in the
* type's class_init() function. The private structure can
* be retrieved using the G_TYPE_INSTANCE_GET_PRIVATE() macro.
* The following example shows attaching a private structure
* <structname>MyObjectPrivate</structname> to an object
* <structname>MyObject</structname> defined in the standard GObject
* fashion.
*
* |[
* typedef struct _MyObjectPrivate MyObjectPrivate;
*
* struct _MyObjectPrivate {
* int some_field;
* };
*
* #define MY_OBJECT_GET_PRIVATE(o) \
* (G_TYPE_INSTANCE_GET_PRIVATE ((o), MY_TYPE_OBJECT, MyObjectPrivate))
*
* static void
* my_object_class_init (MyObjectClass *klass)
* {
* g_type_class_add_private (klass, sizeof (MyObjectPrivate));
* }
*
* static int
* my_object_get_some_field (MyObject *my_object)
* {
* MyObjectPrivate *priv = MY_OBJECT_GET_PRIVATE (my_object);
*
* return priv->some_field;
* }
* ]|
*
* Since: 2.4
*/
void
g_type_class_add_private (gpointer g_class,
gsize private_size)

1044
gobject/gtype.h
View File

File diff suppressed because it is too large Load Diff

5
gobject/gvaluetypes.h
View File

@ -43,6 +43,11 @@ G_BEGIN_DECLS
#define G_VALUE_HOLDS_DOUBLE(value) (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_DOUBLE))
#define G_VALUE_HOLDS_STRING(value) (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_STRING))
#define G_VALUE_HOLDS_POINTER(value) (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_POINTER))
/**
* G_TYPE_GTYPE:
*
* The type for #GType.
*/
#define G_TYPE_GTYPE (g_gtype_get_type())
#define G_VALUE_HOLDS_GTYPE(value) (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_GTYPE))