/* GObject - GLib Type, Object, Parameter and Signal Library

 * Copyright (C) 1998-1999, 2000-2001 Tim Janik and Red Hat, Inc.

 *

 * 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.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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * 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, see <http://www.gnu.org/licenses/>.

 */

#ifndef __G_TYPE_H__

#define __G_TYPE_H__

#if !defined (__GLIB_GOBJECT_H_INSIDE__) && !defined (GOBJECT_COMPILATION)

#error "Only <glib-object.h> can be included directly."

#endif

#include        <glib.h>

G_BEGIN_DECLS

/* Basic Type Macros

 */

/**

 * G_TYPE_FUNDAMENTAL:

 * @type: A #GType value.

 * 

 * The fundamental type which is the ancestor of @type.

 * Fundamental types are types that serve as ultimate bases for the derived types, 

 * thus they are the roots of distinct inheritance hierarchies.

 */

#define G_TYPE_FUNDAMENTAL(type)	(g_type_fundamental (type))

/**

 * G_TYPE_FUNDAMENTAL_MAX:

 * 

 * An integer constant that represents the number of identifiers reserved

 * for types that are assigned at compile-time.

 */

#define	G_TYPE_FUNDAMENTAL_MAX		(255 << G_TYPE_FUNDAMENTAL_SHIFT)

/* Constant fundamental types,

 */

/**

 * G_TYPE_INVALID:

 * 

 * An invalid #GType used as error return value in some functions which return

 * a #GType. 

 */

#define G_TYPE_INVALID			G_TYPE_MAKE_FUNDAMENTAL (0)

/**

 * G_TYPE_NONE:

 * 

 * A fundamental type which is used as a replacement for the C

 * void return type.

 */

#define G_TYPE_NONE			G_TYPE_MAKE_FUNDAMENTAL (1)

/**

 * G_TYPE_INTERFACE:

 * 

 * The fundamental type from which all interfaces are derived.

 */

#define G_TYPE_INTERFACE		G_TYPE_MAKE_FUNDAMENTAL (2)

/**

 * G_TYPE_CHAR:

 * 

 * The fundamental type corresponding to #gchar.

 * The type designated by G_TYPE_CHAR is unconditionally an 8-bit signed integer.

 * This may or may not be the same type a the C type "gchar".

 */

#define G_TYPE_CHAR			G_TYPE_MAKE_FUNDAMENTAL (3)

/**

 * G_TYPE_UCHAR:

 * 

 * The fundamental type corresponding to #guchar.

 */

#define G_TYPE_UCHAR			G_TYPE_MAKE_FUNDAMENTAL (4)

/**

 * G_TYPE_BOOLEAN:

 * 

 * The fundamental type corresponding to #gboolean.

 */

#define G_TYPE_BOOLEAN			G_TYPE_MAKE_FUNDAMENTAL (5)

/**

 * G_TYPE_INT:

 * 

 * The fundamental type corresponding to #gint.

 */

#define G_TYPE_INT			G_TYPE_MAKE_FUNDAMENTAL (6)

/**

 * G_TYPE_UINT:

 * 

 * The fundamental type corresponding to #guint.

 */

#define G_TYPE_UINT			G_TYPE_MAKE_FUNDAMENTAL (7)

/**

 * G_TYPE_LONG:

 * 

 * The fundamental type corresponding to #glong.

 */

#define G_TYPE_LONG			G_TYPE_MAKE_FUNDAMENTAL (8)

/**

 * G_TYPE_ULONG:

 * 

 * The fundamental type corresponding to #gulong.

 */

#define G_TYPE_ULONG			G_TYPE_MAKE_FUNDAMENTAL (9)

/**

 * G_TYPE_INT64:

 * 

 * The fundamental type corresponding to #gint64.

 */

#define G_TYPE_INT64			G_TYPE_MAKE_FUNDAMENTAL (10)

/**

 * G_TYPE_UINT64:

 * 

 * The fundamental type corresponding to #guint64.

 */

#define G_TYPE_UINT64			G_TYPE_MAKE_FUNDAMENTAL (11)

/**

 * G_TYPE_ENUM:

 * 

 * The fundamental type from which all enumeration types are derived.

 */

#define G_TYPE_ENUM			G_TYPE_MAKE_FUNDAMENTAL (12)

/**

 * G_TYPE_FLAGS:

 * 

 * The fundamental type from which all flags types are derived.

 */

#define G_TYPE_FLAGS			G_TYPE_MAKE_FUNDAMENTAL (13)

/**

 * G_TYPE_FLOAT:

 * 

 * The fundamental type corresponding to #gfloat.

 */

#define G_TYPE_FLOAT			G_TYPE_MAKE_FUNDAMENTAL (14)

/**

 * G_TYPE_DOUBLE:

 * 

 * The fundamental type corresponding to #gdouble.

 */

#define G_TYPE_DOUBLE			G_TYPE_MAKE_FUNDAMENTAL (15)

/**

 * G_TYPE_STRING:

 * 

 * The fundamental type corresponding to nul-terminated C strings.

 */

#define G_TYPE_STRING			G_TYPE_MAKE_FUNDAMENTAL (16)

/**

 * G_TYPE_POINTER:

 * 

 * The fundamental type corresponding to #gpointer.

 */

#define G_TYPE_POINTER			G_TYPE_MAKE_FUNDAMENTAL (17)

/**

 * G_TYPE_BOXED:

 * 

 * The fundamental type from which all boxed types are derived.

 */

#define G_TYPE_BOXED			G_TYPE_MAKE_FUNDAMENTAL (18)

/**

 * G_TYPE_PARAM:

 * 

 * The fundamental type from which all #GParamSpec types are derived.

 */

#define G_TYPE_PARAM			G_TYPE_MAKE_FUNDAMENTAL (19)

/**

 * G_TYPE_OBJECT:

 * 

 * The fundamental type for #GObject.

 */

#define G_TYPE_OBJECT			G_TYPE_MAKE_FUNDAMENTAL (20)

/**

 * G_TYPE_VARIANT:

 *

 * The fundamental type corresponding to #GVariant.

 *

 * All floating #GVariant instances passed through the #GType system are

 * consumed.

 * 

 * Note that callbacks in closures, and signal handlers

 * for signals of return type %G_TYPE_VARIANT, must never return floating

 * variants.

 *

 * Note: GLib 2.24 did include a boxed type with this name. It was replaced

 * with this fundamental type in 2.26.

 *

 * Since: 2.26

 */

#define	G_TYPE_VARIANT                  G_TYPE_MAKE_FUNDAMENTAL (21)

/* Reserved fundamental type numbers to create new fundamental

 * type IDs with G_TYPE_MAKE_FUNDAMENTAL().

 * Send email to gtk-devel-list@gnome.org for reservations.

 */

/**

 * G_TYPE_FUNDAMENTAL_SHIFT:

 *

 * Shift value used in converting numbers to type IDs.

 */

#define	G_TYPE_FUNDAMENTAL_SHIFT	(2)

/**

 * G_TYPE_MAKE_FUNDAMENTAL:

 * @x: the fundamental type number.

 * 

 * Get the type ID for the fundamental type number @x.

 * Use g_type_fundamental_next() instead of this macro to create new fundamental 

 * types.

 *

 * Returns: the GType

 */

#define	G_TYPE_MAKE_FUNDAMENTAL(x)	((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT))

/**

 * G_TYPE_RESERVED_GLIB_FIRST:

 * 

 * First fundamental type number to create a new fundamental type id with

 * G_TYPE_MAKE_FUNDAMENTAL() reserved for GLib.

 */

#define G_TYPE_RESERVED_GLIB_FIRST	(22)

/**

 * G_TYPE_RESERVED_GLIB_LAST:

 * 

 * Last fundamental type number reserved for GLib.

 */

#define G_TYPE_RESERVED_GLIB_LAST	(31)

/**

 * G_TYPE_RESERVED_BSE_FIRST:

 * 

 * First fundamental type number to create a new fundamental type id with

 * G_TYPE_MAKE_FUNDAMENTAL() reserved for BSE.

 */

#define G_TYPE_RESERVED_BSE_FIRST	(32)

/**

 * G_TYPE_RESERVED_BSE_LAST:

 * 

 * Last fundamental type number reserved for BSE.

 */

#define G_TYPE_RESERVED_BSE_LAST	(48)

/**

 * G_TYPE_RESERVED_USER_FIRST:

 * 

 * First available fundamental type number to create new fundamental 

 * type id with G_TYPE_MAKE_FUNDAMENTAL().

 */

#define G_TYPE_RESERVED_USER_FIRST	(49)

/* Type Checking Macros

 */

/**

 * G_TYPE_IS_FUNDAMENTAL:

 * @type: A #GType value

 * 

 * Checks if @type is a fundamental type.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_IS_FUNDAMENTAL(type)             ((type) <= G_TYPE_FUNDAMENTAL_MAX)

/**

 * G_TYPE_IS_DERIVED:

 * @type: A #GType value

 * 

 * Checks if @type is derived (or in object-oriented terminology:

 * inherited) from another type (this holds true for all non-fundamental

 * types).

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_IS_DERIVED(type)                 ((type) > G_TYPE_FUNDAMENTAL_MAX)

/**

 * G_TYPE_IS_INTERFACE:

 * @type: A #GType value

 * 

 * Checks if @type is an interface type.

 * An interface type provides a pure API, the implementation

 * of which is provided by another type (which is then said to conform

 * to the interface).  GLib interfaces are somewhat analogous to Java

 * interfaces and C++ classes containing only pure virtual functions, 

 * with the difference that GType interfaces are not derivable (but see

 * g_type_interface_add_prerequisite() for an alternative).

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_IS_INTERFACE(type)               (G_TYPE_FUNDAMENTAL (type) == G_TYPE_INTERFACE)

/**

 * G_TYPE_IS_CLASSED:

 * @type: A #GType value

 * 

 * Checks if @type is a classed type.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_IS_CLASSED(type)                 (g_type_test_flags ((type), G_TYPE_FLAG_CLASSED))

/**

 * G_TYPE_IS_INSTANTIATABLE:

 * @type: A #GType value

 * 

 * Checks if @type can be instantiated.  Instantiation is the

 * process of creating an instance (object) of this type.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_IS_INSTANTIATABLE(type)          (g_type_test_flags ((type), G_TYPE_FLAG_INSTANTIATABLE))

/**

 * G_TYPE_IS_DERIVABLE:

 * @type: A #GType value

 * 

 * Checks if @type is a derivable type.  A derivable type can

 * be used as the base class of a flat (single-level) class hierarchy.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_IS_DERIVABLE(type)               (g_type_test_flags ((type), G_TYPE_FLAG_DERIVABLE))

/**

 * G_TYPE_IS_DEEP_DERIVABLE:

 * @type: A #GType value

 * 

 * Checks if @type is a deep derivable type.  A deep derivable type

 * can be used as the base class of a deep (multi-level) class hierarchy.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_IS_DEEP_DERIVABLE(type)          (g_type_test_flags ((type), G_TYPE_FLAG_DEEP_DERIVABLE))

/**

 * G_TYPE_IS_ABSTRACT:

 * @type: A #GType value

 * 

 * Checks if @type is an abstract type.  An abstract type cannot be

 * instantiated and is normally used as an abstract base class for

 * derived classes.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_IS_ABSTRACT(type)                (g_type_test_flags ((type), G_TYPE_FLAG_ABSTRACT))

/**

 * G_TYPE_IS_VALUE_ABSTRACT:

 * @type: A #GType value

 * 

 * Checks if @type is an abstract value type.  An abstract value type introduces

 * a value table, but can't be used for g_value_init() and is normally used as

 * an abstract base type for derived value types.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_IS_VALUE_ABSTRACT(type)          (g_type_test_flags ((type), G_TYPE_FLAG_VALUE_ABSTRACT))

/**

 * G_TYPE_IS_VALUE_TYPE:

 * @type: A #GType value

 * 

 * Checks if @type is a value type and can be used with g_value_init(). 

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_IS_VALUE_TYPE(type)              (g_type_check_is_value_type (type))

/**

 * G_TYPE_HAS_VALUE_TABLE:

 * @type: A #GType value

 * 

 * Checks if @type has a #GTypeValueTable.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_HAS_VALUE_TABLE(type)            (g_type_value_table_peek (type) != NULL)

/* Typedefs

 */

/**

 * GType:

 * 

 * A numerical value which represents the unique identifier of a registered

 * type.

 */

#if     GLIB_SIZEOF_SIZE_T != GLIB_SIZEOF_LONG || !defined __cplusplus

typedef gsize                           GType;

#else   /* for historic reasons, C++ links against gulong GTypes */

typedef gulong                          GType;

#endif

typedef struct _GValue                  GValue;

typedef union  _GTypeCValue             GTypeCValue;

typedef struct _GTypePlugin             GTypePlugin;

typedef struct _GTypeClass              GTypeClass;

typedef struct _GTypeInterface          GTypeInterface;

typedef struct _GTypeInstance           GTypeInstance;

typedef struct _GTypeInfo               GTypeInfo;

typedef struct _GTypeFundamentalInfo    GTypeFundamentalInfo;

typedef struct _GInterfaceInfo          GInterfaceInfo;

typedef struct _GTypeValueTable         GTypeValueTable;

typedef struct _GTypeQuery		GTypeQuery;

/* Basic Type Structures

 */

/**

 * GTypeClass:

 * 

 * An opaque structure used as the base of all classes.

 */

struct _GTypeClass

{

  /*< private >*/

  GType g_type;

};

/**

 * GTypeInstance:

 * 

 * An opaque structure used as the base of all type instances.

 */

struct _GTypeInstance

{

  /*< private >*/

  GTypeClass *g_class;

};

/**

 * GTypeInterface:

 * 

 * An opaque structure used as the base of all interface types.

 */

struct _GTypeInterface

{

  /*< private >*/

  GType g_type;         /* iface type */

  GType g_instance_type;

};

/**

 * GTypeQuery:

 * @type: the #GType value of the type

 * @type_name: the name of the type

 * @class_size: the size of the class structure

 * @instance_size: the size of the instance structure

 * 

 * A structure holding information for a specific type.

 * It is filled in by the g_type_query() function.

 */

struct _GTypeQuery

{

  GType		type;

  const gchar  *type_name;

  guint		class_size;

  guint		instance_size;

};

/* Casts, checks and accessors for structured types

 * usage of these macros is reserved to type implementations only

 */

/*< protected >*/

/**

 * G_TYPE_CHECK_INSTANCE:

 * @instance: Location of a #GTypeInstance structure

 * 

 * Checks if @instance is a valid #GTypeInstance structure,

 * otherwise issues a warning and returns %FALSE. %NULL is not a valid

 * #GTypeInstance.

 * 

 * This macro should only be used in type implementations.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_CHECK_INSTANCE(instance)				(_G_TYPE_CHI ((GTypeInstance*) (instance)))

/**

 * G_TYPE_CHECK_INSTANCE_CAST:

 * @instance: (nullable): Location of a #GTypeInstance structure

 * @g_type: The type to be returned

 * @c_type: The corresponding C type of @g_type

 * 

 * Checks that @instance is an instance of the type identified by @g_type

 * and issues a warning if this is not the case. Returns @instance casted 

 * to a pointer to @c_type.

 *

 * No warning will be issued if @instance is %NULL, and %NULL will be returned.

 * 

 * This macro should only be used in type implementations.

 */

#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type)    (_G_TYPE_CIC ((instance), (g_type), c_type))

/**

 * G_TYPE_CHECK_INSTANCE_TYPE:

 * @instance: (nullable): Location of a #GTypeInstance structure.

 * @g_type: The type to be checked

 * 

 * Checks if @instance is an instance of the type identified by @g_type. If

 * @instance is %NULL, %FALSE will be returned.

 * 

 * This macro should only be used in type implementations.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_CHECK_INSTANCE_TYPE(instance, g_type)            (_G_TYPE_CIT ((instance), (g_type)))

/**

 * G_TYPE_CHECK_INSTANCE_FUNDAMENTAL_TYPE:

 * @instance: (nullable): Location of a #GTypeInstance structure.

 * @g_type: The fundamental type to be checked

 *

 * Checks if @instance is an instance of the fundamental type identified by @g_type.

 * If @instance is %NULL, %FALSE will be returned.

 *

 * This macro should only be used in type implementations.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_CHECK_INSTANCE_FUNDAMENTAL_TYPE(instance, g_type)            (_G_TYPE_CIFT ((instance), (g_type)))

/**

 * G_TYPE_INSTANCE_GET_CLASS:

 * @instance: Location of the #GTypeInstance structure

 * @g_type: The #GType of the class to be returned

 * @c_type: The C type of the class structure

 * 

 * Get the class structure of a given @instance, casted

 * to a specified ancestor type @g_type of the instance.

 * 

 * Note that while calling a GInstanceInitFunc(), the class pointer

 * gets modified, so it might not always return the expected pointer.

 * 

 * This macro should only be used in type implementations.

 *

 * Returns: a pointer to the class structure

 */

#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type)     (_G_TYPE_IGC ((instance), (g_type), c_type))

/**

 * G_TYPE_INSTANCE_GET_INTERFACE:

 * @instance: Location of the #GTypeInstance structure

 * @g_type: The #GType of the interface to be returned

 * @c_type: The C type of the interface structure

 * 

 * Get the interface structure for interface @g_type of a given @instance.

 * 

 * This macro should only be used in type implementations.

 *

 * Returns: a pointer to the interface structure

 */

#define G_TYPE_INSTANCE_GET_INTERFACE(instance, g_type, c_type) (_G_TYPE_IGI ((instance), (g_type), c_type))

/**

 * G_TYPE_CHECK_CLASS_CAST:

 * @g_class: Location of a #GTypeClass structure

 * @g_type: The type to be returned

 * @c_type: The corresponding C type of class structure of @g_type

 * 

 * Checks that @g_class is a class structure of the type identified by @g_type

 * and issues a warning if this is not the case. Returns @g_class casted 

 * to a pointer to @c_type. %NULL is not a valid class structure.

 * 

 * This macro should only be used in type implementations.

 */

#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type)        (_G_TYPE_CCC ((g_class), (g_type), c_type))

/**

 * G_TYPE_CHECK_CLASS_TYPE:

 * @g_class: (nullable): Location of a #GTypeClass structure

 * @g_type: The type to be checked

 * 

 * Checks if @g_class is a class structure of the type identified by 

 * @g_type. If @g_class is %NULL, %FALSE will be returned.

 * 

 * This macro should only be used in type implementations.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_CHECK_CLASS_TYPE(g_class, g_type)                (_G_TYPE_CCT ((g_class), (g_type)))

/**

 * G_TYPE_CHECK_VALUE:

 * @value: a #GValue

 * 

 * Checks if @value has been initialized to hold values

 * of a value type.

 * 

 * This macro should only be used in type implementations.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_CHECK_VALUE(value)				(_G_TYPE_CHV ((value)))

/**

 * G_TYPE_CHECK_VALUE_TYPE:

 * @value: a #GValue

 * @g_type: The type to be checked

 * 

 * Checks if @value has been initialized to hold values

 * of type @g_type. 

 * 

 * This macro should only be used in type implementations.

 *

 * Returns: %TRUE on success

 */

#define G_TYPE_CHECK_VALUE_TYPE(value, g_type)			(_G_TYPE_CVH ((value), (g_type)))

/**

 * G_TYPE_FROM_INSTANCE:

 * @instance: Location of a valid #GTypeInstance structure

 * 

 * Get the type identifier from a given @instance structure. 

 * 

 * This macro should only be used in type implementations.

 *

 * Returns: the #GType

 */

#define G_TYPE_FROM_INSTANCE(instance)                          (G_TYPE_FROM_CLASS (((GTypeInstance*) (instance))->g_class))

/**

 * G_TYPE_FROM_CLASS:

 * @g_class: Location of a valid #GTypeClass structure

 * 

 * Get the type identifier from a given @class structure.

 * 

 * This macro should only be used in type implementations.

 *

 * Returns: the #GType

 */

#define G_TYPE_FROM_CLASS(g_class)                              (((GTypeClass*) (g_class))->g_type)

/**

 * G_TYPE_FROM_INTERFACE:

 * @g_iface: Location of a valid #GTypeInterface structure

 * 

 * Get the type identifier from a given @interface structure.

 * 

 * This macro should only be used in type implementations.

 *

 * Returns: the #GType

 */

#define G_TYPE_FROM_INTERFACE(g_iface)                          (((GTypeInterface*) (g_iface))->g_type)

/**

 * G_TYPE_INSTANCE_GET_PRIVATE:

 * @instance: the instance of a type deriving from @private_type

 * @g_type: the type identifying which private data to retrieve

 * @c_type: The C type for the private structure

 * 

 * Gets the private structure for a particular type.

 * The private structure must have been registered in the

 * class_init function with g_type_class_add_private().

 * 

 * This macro should only be used in type implementations.

 * 

 * Since: 2.4

 * Returns: (not nullable): a pointer to the private data structure

 */

#define G_TYPE_INSTANCE_GET_PRIVATE(instance, g_type, c_type)   ((c_type*) g_type_instance_get_private ((GTypeInstance*) (instance), (g_type)))

/**

 * G_TYPE_CLASS_GET_PRIVATE:

 * @klass: the class of a type deriving from @private_type

 * @g_type: the type identifying which private data to retrieve

 * @c_type: The C type for the private structure

 * 

 * Gets the private class structure for a particular type.

 * The private structure must have been registered in the

 * get_type() function with g_type_add_class_private().

 * 

 * This macro should only be used in type implementations.

 * 

 * Since: 2.24

 * Returns: (not nullable): a pointer to the private data structure

 */

#define G_TYPE_CLASS_GET_PRIVATE(klass, g_type, c_type)   ((c_type*) g_type_class_get_private ((GTypeClass*) (klass), (g_type)))

/**

 * GTypeDebugFlags:

 * @G_TYPE_DEBUG_NONE: Print no messages

 * @G_TYPE_DEBUG_OBJECTS: Print messages about object bookkeeping

 * @G_TYPE_DEBUG_SIGNALS: Print messages about signal emissions

 * @G_TYPE_DEBUG_MASK: Mask covering all debug flags

 * @G_TYPE_DEBUG_INSTANCE_COUNT: Keep a count of instances of each type

 *

 * These flags used to be passed to g_type_init_with_debug_flags() which

 * is now deprecated.

 *

 * If you need to enable debugging features, use the GOBJECT_DEBUG

 * environment variable.

 *

 * Deprecated: 2.36: g_type_init() is now done automatically

 */

typedef enum	/*< skip >*/

{

  G_TYPE_DEBUG_NONE	= 0,

  G_TYPE_DEBUG_OBJECTS	= 1 << 0,

  G_TYPE_DEBUG_SIGNALS	= 1 << 1,

  G_TYPE_DEBUG_INSTANCE_COUNT = 1 << 2,

  G_TYPE_DEBUG_MASK	= 0x07

} GTypeDebugFlags;

/* --- prototypes --- */

GLIB_DEPRECATED_IN_2_36

void                  g_type_init                    (void);

GLIB_DEPRECATED_IN_2_36

void                  g_type_init_with_debug_flags   (GTypeDebugFlags  debug_flags);

GLIB_AVAILABLE_IN_ALL

const gchar *         g_type_name                    (GType            type);

GLIB_AVAILABLE_IN_ALL

GQuark                g_type_qname                   (GType            type);

GLIB_AVAILABLE_IN_ALL

GType                 g_type_from_name               (const gchar     *name);

GLIB_AVAILABLE_IN_ALL

GType                 g_type_parent                  (GType            type);

GLIB_AVAILABLE_IN_ALL

guint                 g_type_depth                   (GType            type);

GLIB_AVAILABLE_IN_ALL

GType                 g_type_next_base               (GType            leaf_type,

						      GType            root_type);

GLIB_AVAILABLE_IN_ALL

gboolean              g_type_is_a                    (GType            type,

						      GType            is_a_type);

GLIB_AVAILABLE_IN_ALL

gpointer              g_type_class_ref               (GType            type);

GLIB_AVAILABLE_IN_ALL

gpointer              g_type_class_peek              (GType            type);

GLIB_AVAILABLE_IN_ALL

gpointer              g_type_class_peek_static       (GType            type);

GLIB_AVAILABLE_IN_ALL

void                  g_type_class_unref             (gpointer         g_class);

GLIB_AVAILABLE_IN_ALL

gpointer              g_type_class_peek_parent       (gpointer         g_class);

GLIB_AVAILABLE_IN_ALL

gpointer              g_type_interface_peek          (gpointer         instance_class,

						      GType            iface_type);

GLIB_AVAILABLE_IN_ALL

gpointer              g_type_interface_peek_parent   (gpointer         g_iface);

GLIB_AVAILABLE_IN_ALL

gpointer              g_type_default_interface_ref   (GType            g_type);

GLIB_AVAILABLE_IN_ALL

gpointer              g_type_default_interface_peek  (GType            g_type);

GLIB_AVAILABLE_IN_ALL

void                  g_type_default_interface_unref (gpointer         g_iface);

/* g_free() the returned arrays */

GLIB_AVAILABLE_IN_ALL

GType*                g_type_children                (GType            type,

						      guint           *n_children);

GLIB_AVAILABLE_IN_ALL

GType*                g_type_interfaces              (GType            type,

						      guint           *n_interfaces);

/* per-type _static_ data */

GLIB_AVAILABLE_IN_ALL

void                  g_type_set_qdata               (GType            type,

						      GQuark           quark,

						      gpointer         data);

GLIB_AVAILABLE_IN_ALL

gpointer              g_type_get_qdata               (GType            type,

						      GQuark           quark);

GLIB_AVAILABLE_IN_ALL

void		      g_type_query		     (GType	       type,

						      GTypeQuery      *query);

GLIB_AVAILABLE_IN_2_44

int                   g_type_get_instance_count      (GType            type);

/* --- type registration --- */

/**

 * GBaseInitFunc:

 * @g_class: (type GObject.TypeClass): The #GTypeClass structure to initialize

 * 

 * A callback function used by the type system to do base initialization

 * of the class structures of derived types. It is called as part of the

 * initialization process of all derived classes and should reallocate

 * or reset all dynamic class members copied over from the parent class.

 * For example, class members (such as strings) that are not sufficiently

 * handled by a plain memory copy of the parent class into the derived class

 * have to be altered. See GClassInitFunc() for a discussion of the class

 * initialization process.

 */

typedef void   (*GBaseInitFunc)              (gpointer         g_class);

/**

 * GBaseFinalizeFunc:

 * @g_class: (type GObject.TypeClass): The #GTypeClass structure to finalize

 * 

 * A callback function used by the type system to finalize those portions

 * of a derived types class structure that were setup from the corresponding

 * GBaseInitFunc() function. Class finalization basically works the inverse

 * way in which class initialization is performed.

 * See GClassInitFunc() for a discussion of the class initialization process.

 */

typedef void   (*GBaseFinalizeFunc)          (gpointer         g_class);

/**

 * GClassInitFunc:

 * @g_class: (type GObject.TypeClass): The #GTypeClass structure to initialize.

 * @class_data: The @class_data member supplied via the #GTypeInfo structure.

 * 

 * A callback function used by the type system to initialize the class

 * of a specific type. This function should initialize all static class

 * members.

 *

 * The initialization process of a class involves:

 * 

 * - Copying common members from the parent class over to the

 *   derived class structure.

 * - Zero initialization of the remaining members not copied

 *   over from the parent class.

 * - Invocation of the GBaseInitFunc() initializers of all parent

 *   types and the class' type.

 * - Invocation of the class' GClassInitFunc() initializer.

 *

 * Since derived classes are partially initialized through a memory copy

 * of the parent class, the general rule is that GBaseInitFunc() and

 * GBaseFinalizeFunc() should take care of necessary reinitialization

 * and release of those class members that were introduced by the type

 * that specified these GBaseInitFunc()/GBaseFinalizeFunc().

 * GClassInitFunc() should only care about initializing static

 * class members, while dynamic class members (such as allocated strings

 * or reference counted resources) are better handled by a GBaseInitFunc()

 * for this type, so proper initialization of the dynamic class members

 * is performed for class initialization of derived types as well.

 *

 * An example may help to correspond the intend of the different class

 * initializers:

 * 

 * |[

 * typedef struct {

 *   GObjectClass parent_class;

 *   gint         static_integer;

 *   gchar       *dynamic_string;

 * } TypeAClass;

 * static void

 * type_a_base_class_init (TypeAClass *class)

 * {

 *   class->dynamic_string = g_strdup ("some string");

 * }

 * static void

 * type_a_base_class_finalize (TypeAClass *class)

 * {

 *   g_free (class->dynamic_string);

 * }

 * static void

 * type_a_class_init (TypeAClass *class)

 * {

 *   class->static_integer = 42;

 * }

 * 

 * typedef struct {

 *   TypeAClass   parent_class;

 *   gfloat       static_float;

 *   GString     *dynamic_gstring;

 * } TypeBClass;

 * static void

 * type_b_base_class_init (TypeBClass *class)

 * {

 *   class->dynamic_gstring = g_string_new ("some other string");

 * }

 * static void

 * type_b_base_class_finalize (TypeBClass *class)

 * {

 *   g_string_free (class->dynamic_gstring);

 * }

 * static void

 * type_b_class_init (TypeBClass *class)

 * {

 *   class->static_float = 3.14159265358979323846;

 * }

 * ]|

 * Initialization of TypeBClass will first cause initialization of

 * TypeAClass (derived classes reference their parent classes, see

 * g_type_class_ref() on this).

 *

 * Initialization of TypeAClass roughly involves zero-initializing its fields,

 * then calling its GBaseInitFunc() type_a_base_class_init() to allocate

 * its dynamic members (dynamic_string), and finally calling its GClassInitFunc()

 * type_a_class_init() to initialize its static members (static_integer).

 * The first step in the initialization process of TypeBClass is then

 * a plain memory copy of the contents of TypeAClass into TypeBClass and 

 * zero-initialization of the remaining fields in TypeBClass.

 * The dynamic members of TypeAClass within TypeBClass now need

 * reinitialization which is performed by calling type_a_base_class_init()

 * with an argument of TypeBClass.

 *

 * After that, the GBaseInitFunc() of TypeBClass, type_b_base_class_init()

 * is called to allocate the dynamic members of TypeBClass (dynamic_gstring),

 * and finally the GClassInitFunc() of TypeBClass, type_b_class_init(),

 * is called to complete the initialization process with the static members

 * (static_float).

 *

 * Corresponding finalization counter parts to the GBaseInitFunc() functions

 * have to be provided to release allocated resources at class finalization

 * time.

 */

typedef void   (*GClassInitFunc)             (gpointer         g_class,

					      gpointer         class_data);

/**