GType

Числовое значение которое представляет уникальный идентификатор зарегистрированного типа.

G_TYPE_FUNDAMENTAL()

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

Возвращает базовый тип который наследует type. Базовые типы являются типами которые служат основой для производных типов, таким образом они являются корнями отдельных иерархий наследования.

G_TYPE_FUNDAMENTAL_MAX

#define	G_TYPE_FUNDAMENTAL_MAX		(255 << G_TYPE_FUNDAMENTAL_SHIFT)

Целочисленная константа представляющая количество идентификаторов, зарезервированных для типов обозначенных во время компиляции.

G_TYPE_MAKE_FUNDAMENTAL()

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

Возвращает ID для базового типа с номером x. Используйте g_type_fundamental_next() вместо этого макроса для создания нового базового типа.

G_TYPE_IS_ABSTRACT()

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

Возвращает TRUE если type является абстрактным. Абстрактный тип может не инициироваться и используется обычно как абстрактный основной класс для наследования классов.

G_TYPE_IS_DERIVED()

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

Возвращает TRUE если type унаследован из другого типа (возвращает TRUE для всех не базовых типов).

G_TYPE_IS_FUNDAMENTAL()

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

Возвращает TRUE если type является базовым типом.

G_TYPE_IS_VALUE_TYPE()

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

Возвращает TRUE если type является типовым значением и может использоваться с помощью g_value_init().

G_TYPE_HAS_VALUE_TABLE()

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

Возвращает TRUE если type имеет GTypeValueTable.

G_TYPE_IS_CLASSED()

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

Возвращает TRUE если type является классовым типом.

G_TYPE_IS_INSTANTIATABLE()

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

Возвращает TRUE если type может быть инстанциирован. Инстанциация - это процесс создания экземпляра объекта данного типа.

G_TYPE_IS_DERIVABLE()

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

Возвращает TRUE если type является наследником. Наследуемый тип может использоваться как основной класс плоской (одноуровневой) иерархии класса.

G_TYPE_IS_DEEP_DERIVABLE()

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

Возвращает TRUE если type глубоко наследуемыйй тип. Глубоко наследуемыйй тип может использоваться как основной класс глубокой (многоуровневой) иерархии класса.

G_TYPE_IS_INTERFACE()

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

Возвращает TRUE если type является интерфейсным типом. Интерфейсные типы обеспечивают чистый API, реализация которого обеспечивается другим типом (который, как говорится в таких случаях, соответствует интерфейсу). GLib интерфейсы являются в некотором роде аналогами интерфейсов Java и C++ классов содержащие только чистые виртуальные функции, различие в том, что GType интерфейсы не наследуемый (но можно посмотреть альтернативу g_type_interface_add_prerequisite()).

GTypeInterface

typedef struct {
} GTypeInterface;

Непрозрачная структура используемая как основа всех интерфейсных типов.

GTypeInstance

typedef struct {
} GTypeInstance;

Непрозрачная структура используемая как основа всех инстанциируемых типов.

GTypeClass

typedef struct {
} GTypeClass;

Непрозрачная структура используемая как основа всех классов.

GTypeInfo

typedef struct {
  /* interface types, classed types, instantiated types */
  guint16                class_size;
  
  GBaseInitFunc          base_init;
  GBaseFinalizeFunc      base_finalize;
  
  /* interface types, classed types, instantiated types */
  GClassInitFunc         class_init;
  GClassFinalizeFunc     class_finalize;
  gconstpointer          class_data;
  
  /* instantiated types */
  guint16                instance_size;
  guint16                n_preallocs;
  GInstanceInitFunc      instance_init;
  
  /* value handling */
  const GTypeValueTable	*value_table;
} GTypeInfo;

Эта структура используется для обеспечения системы типов информацией запрашиваемой для инициализации и уничтожения (финализации) типового класса и его экземпляра. Инициализированная структура помещается в функцию g_type_register_static() (или копируется в структуру GTypeInfo обеспеченную функцией g_type_plugin_complete_type_info()). Система типов выполнит глубокую копию этой сструктуры, поэтому память не должна быть постоянной через вызов g_type_register_static().

GTypeFundamentalInfo

typedef struct {
  GTypeFundamentalFlags  type_flags;
} GTypeFundamentalInfo;

Структура обеспечивающая информацией систему типов специально для управления базовыми типами.

GInterfaceInfo

typedef struct {
  GInterfaceInitFunc     interface_init;
  GInterfaceFinalizeFunc interface_finalize;
  gpointer               interface_data;
} GInterfaceInfo;

Структура обеспечивает информацию для системы типов которая используется специально для управления интерфейсными типами.

GTypeValueTable

typedef struct {
  void     (*value_init)         (GValue       *value);
  void     (*value_free)         (GValue       *value);
  void     (*value_copy)         (const GValue *src_value,
				  GValue       *dest_value);
  /* varargs functionality (optional) */
  gpointer (*value_peek_pointer) (const GValue *value);
  gchar	    *collect_format;
  gchar*   (*collect_value)      (GValue       *value,
				  guint         n_collect_values,
				  GTypeCValue  *collect_values,
				  guint		collect_flags);
  gchar	    *lcopy_format;
  gchar*   (*lcopy_value)        (const GValue *value,
				  guint         n_collect_values,
				  GTypeCValue  *collect_values,
				  guint		collect_flags);
} GTypeValueTable;

GTypeValueTable обеспечивает функции требуемые реализацией GValue, которая служит контейнером для значений типа.

{
  value->data[0].v_pointer = g_strdup ("");
}

{
  /* освобождает строки только без определённого флага статического хранения */
  if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
    g_free (value->data[0].v_pointer);
}

{
  dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);
}

{
  return value->data[0].v_pointer;
}

{
  if (!collect_values[0].v_pointer)
    value->data[0].v_pointer = g_strdup ("");
  else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
    {
      value->data[0].v_pointer = collect_values[0].v_pointer;
      /* keep a flag for the value_free() implementation to not free this string */
      value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
    }
  else
    value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);

  return NULL;
}

{
  if (collect_values[0].v_pointer)
    {
      GObject *object = G_OBJECT (collect_values[0].v_pointer);

      /* never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types */
      value->data[0].v_pointer = g_object_ref (object);
      return NULL;
    }
  else
    return g_strdup_printf ("Object passed as invalid NULL pointer");
}

{
  gchar **string_p = collect_values[0].v_pointer;

  if (!string_p)
    return g_strdup_printf ("string location passed as NULL");

  if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
    *string_p = value->data[0].v_pointer;
  else
    *string_p = g_strdup (value->data[0].v_pointer);

}

{
  GObject **object_p = collect_values[0].v_pointer;

  if (!object_p)
    return g_strdup_printf ("object location passed as NULL");
  if (!value->data[0].v_pointer)
    *object_p = NULL;
  else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) /* always honour */
    *object_p = value->data[0].v_pointer;
  else
    *object_p = g_object_ref (value->data[0].v_pointer);
  return NULL;
}

G_TYPE_FROM_INSTANCE()

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

Возвращает идентификатор типа из полученной сструктуры instance.

Этот макрос должен использоваться только при реализации типа.

G_TYPE_FROM_CLASS()

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

Возвращает идентификатор из полученной сструктуры class.

Этот макрос должен использоваться только при реализации типа.

G_TYPE_FROM_INTERFACE()

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

Возвращает идентификатор из полученной сструктуры interface.

Этот макрос должен использоваться только при реализации типа.

G_TYPE_INSTANCE_GET_CLASS()

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

Возвращает структуру класса полученного instance, приводя к указанному типу предка экземпляра g_type.

Этот макрос должен использоваться только при реализации типа.

G_TYPE_INSTANCE_GET_INTERFACE()

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

Возвращает структуру интерфейса для интерфейса g_type полученного instance.

Этот макрос должен использоваться только для реализации типа.

G_TYPE_INSTANCE_GET_PRIVATE()

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

Выдаёт закрытую структуру для определённого типа. Закрытая структура должна быть зарегистрирована в функции class_init с помощью g_type_class_add_private().

Этот макрос должен использоваться только при реализации типа.

Начиная с версии 2.4

G_TYPE_CHECK_INSTANCE()

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

Возвращает TRUE если instance является допустимой структурой GTypeInstance, иначе издаёт предупреждение и возвращает FALSE.

Этот макрос должен использоваться только при реализации типа.

G_TYPE_CHECK_INSTANCE_CAST()

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

Проверяет является ли instance экземпляром типа идентифицируемым g_type и издаёт предупреждение если это не так. Возвращает instance приведённый к указателю c_type.

Этот макрос должен использоваться только при реализации типа.

G_TYPE_CHECK_INSTANCE_TYPE()

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

Возвращает TRUE если instance является экземпляром типа идентифицируемым g_type. Иначе издаёт предупреждение и возвращает FALSE.

Этот макрос должен использоваться только при реализации типа.

G_TYPE_CHECK_CLASS_CAST()

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

Проверяет является ли g_class классовой структурой типа идентифицируемого g_type и издаёт предупреждение если это не так. Возвращает g_class приведённый к указателю c_type.

Этот макрос должен использоваться только при реализации типа.

G_TYPE_CHECK_CLASS_TYPE()

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

Возвращает TRUE если g_class является классовой структурой типа идентифицируемого с помощью g_type. Иначе издаёт предупреждение и возвращает FALSE.

Этот макрос должен использоваться только при реализации типа.

G_TYPE_CHECK_VALUE()

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

Возвращает TRUE если value инициализировано типовым значением.

Этот макрос должен использоваться только при реализации типа.

G_TYPE_CHECK_VALUE_TYPE()

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

Возвращает TRUE если value инициализировано значением типа g_type.

Этот макрос должен использоваться только при реализации типа.

G_TYPE_FLAG_RESERVED_ID_BIT

#define	G_TYPE_FLAG_RESERVED_ID_BIT	((GType) (1 << 0))

Бит в числе типа который должен быть нетронутым.

g_type_init ()

void                g_type_init                         (void);

Перед любым использованием системы типов, вызывается g_type_init() для инициализации системы типов и сортировки других частей кода (таких как различные реализации базовых типов или системы сигналов).

Перечисление GTypeDebugFlags

typedef enum	/*< skip >*/
{
  G_TYPE_DEBUG_NONE	= 0,
  G_TYPE_DEBUG_OBJECTS	= 1 << 0,
  G_TYPE_DEBUG_SIGNALS	= 1 << 1,
  G_TYPE_DEBUG_MASK	= 0x03
} GTypeDebugFlags;

Перечисление значений GTypeDebugFlags может помещаться в g_type_init_with_debug_flags() для переключения отладочных сообщений в процессе выполнения. Помните что сообщения могут также переключаться с помощью установки переменной окружения GOBJECT_DEBUG в список разделённых между собой символом ':' "objects" и "signals".

g_type_init_with_debug_flags ()

void                g_type_init_with_debug_flags        (GTypeDebugFlags debug_flags);

Подобна g_type_init(), но дополнительно устанавливает отладочные флаги.

g_type_name ()

const gchar*        g_type_name                         (GType type);

Возвращает уникальное имя которое назначено типу ID (это привилегированный метод определения был ли определённый тип зарегистрирован для помещённого ID).

g_type_qname ()

GQuark              g_type_qname                        (GType type);

Возвращает соответствующий кварк названия типа ID.

g_type_from_name ()

GType               g_type_from_name                    (const gchar *name);

Находит типовой ID из полученного имени типа, возвращает 0 если нет зарегистрированного типа с данным именем (это привилегированный метод определения по имени был ли зарегистрирован тип).

g_type_parent ()

GType               g_type_parent                       (GType type);

Возвращает прямого родителя типа переданного в типе. Если тип не имеет помещённого в него родителя, то есть это базовый тип, возвращается 0.

g_type_depth ()

guint               g_type_depth                        (GType type);

Возвращает длину родословной помещенной в тип. Это включает сам тип непосредственно, поэтому базовые типы имеют глубину 1.

g_type_next_base ()

GType               g_type_next_base                    (GType leaf_type,
                                                         GType root_type);

Получает leaf_type и root_type который содержится в его родителе, возвращает тип непосредственно родителя root_type. Другими словами, эта функция определяет тип который получен непосредственно из root_type, который является также базовым классом leaf_type. Учитывая корневой тип и тип ответвления, эта функция может использоваться для определения типов и порядка в котором тип ответвления появляется из корневого типа.

g_type_is_a ()

gboolean            g_type_is_a                         (GType type,
                                                         GType is_a_type);

Если is_a_type является производным типом, проверяет является ли type потомком is_a_type. Если is_a_type является интерфейсом, проверяет соответствует ли он type.

g_type_class_ref ()

gpointer            g_type_class_ref                    (GType type);

Увеличивает количество ссылок классовой сструктуры принадлежащей type. Эта функция создаст запрашиваемый класс если он ещё не существует.

g_type_class_peek ()

gpointer            g_type_class_peek                   (GType type);

Эта функция такая же как g_type_class_ref(), только количество ссылок уменьшается. Как следствие, эта функция может вернуть NULL если помещённый в неё классовый тип в данный момент не существует (не имеет ссылок).

g_type_class_peek_static ()

gpointer            g_type_class_peek_static            (GType type);

Более эффективная версия g_type_class_peek() которая работает только для статических типов.

Начиная с версии 2.4

g_type_class_unref ()

void                g_type_class_unref                  (gpointer g_class);

Уменьшает количество ссылок помещённой сструктуры класса. Как только последняя ссылка была освобождена, класс может финализироваться системой типов, поэтому дальнейшее разыменование указателя класса после g_type_class_unref() невозможно.

g_type_class_peek_parent ()

gpointer            g_type_class_peek_parent            (gpointer g_class);

Эта удобная функция часто необходима при инициализации класса. Она возвращает структуру класса непосредственно родительского типа помещенного класса. Так как производные классы содержат количество ссылок их родительских классов пока они инстанциирубтся, возвращаемый класс будет всегда существовать. Эта функция очень похожа на:

g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class)));

g_type_class_add_private ()

void                g_type_class_add_private            (gpointer g_class,
                                                         gsize private_size);

Регистрирует закрытую структуру для инстанциируемого типа; когда объект распределён, закрытая структура типа и все родительские типы распределяются последовательно в тот же блок памяти что и общие сструктуры. Эта функция должна вызываться в типовой функции class_init(). Закрытая структура может быть найдена используя макрос G_TYPE_INSTANCE_GET_PRIVATE(). В следующем примере показано прикрепление закрытой сструктуры MyObjectPrivate к объекту MyObject определённому в стандартном стиле GObject.

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;
}

Начиная с версии 2.4

g_type_interface_peek ()

gpointer            g_type_interface_peek               (gpointer instance_class,
                                                         GType iface_type);

Возвращает структуру GTypeInterface интерфейса которому соответствует помещённый класс.

g_type_interface_peek_parent ()

gpointer            g_type_interface_peek_parent        (gpointer g_iface);

Возвращает структуру GTypeInterface соответствующего родительского типа типового экземпляра которому принадлежит g_iface. Это полезно когда наследуется реализация интерфейса из родительского типа и возможно отменяются некоторые методы.

g_type_default_interface_ref ()

gpointer            g_type_default_interface_ref        (GType g_type);

Увеличивает количество ссылок для интерфейсного типа g_type, и возвращает значение по умолчанию интерфейс vtable для типа.

Если тип в текущий момент не используется, то значение по умолчанию vtable для типа будет создано и инициализировано вызовом инициализации основного типа и функций инициализации значения по умолчанию vtable для типа (@base_init и class_init члены GTypeInfo). Вызов g_type_default_interface_ref() полезен когда вам нужно убедиться что сигналы и свойства для интерфейса были установлены.

Начиная с версии 2.4

g_type_default_interface_peek ()

gpointer            g_type_default_interface_peek       (GType g_type);

Если интерфейсный тип g_type в текущий момент используется, возвращает значение по умолчанию vtable интерфейса.

Начиная с версии 2.4

g_type_default_interface_unref ()

void                g_type_default_interface_unref      (gpointer g_iface);

Уменьшает количество ссылок для типа соответствующего значению по умолчанию vtable интерфейса g_iface. Если тип динамический, то когда ни кто не использует интерфейс и все ссылки сброшены, будет вызвана функция финализации для значения по умолчанию vtable интерфейса (class_finalize член GTypeInfo).

Начиная с версии 2.4

g_type_children ()

GType*              g_type_children                     (GType type,
                                                         guint *n_children);

Возвращает вновь распределенный и 0-завершённый массив типа ID, записывая в список дочерние типы type. Возвращаемое значение должно быть освобождено с помощью g_free() после использования.

g_type_interfaces ()

GType*              g_type_interfaces                   (GType type,
                                                         guint *n_interfaces);

Возвращает вновь распределённый и 0-завершённый массив типа ID, записывая в список интерфейсные типы которым соответствует этот type. Возвращаемое значение должно быть освобождено с помощью g_free() после использования.

g_type_interface_prerequisites ()

GType*              g_type_interface_prerequisites      (GType interface_type,
                                                         guint *n_prerequisites);

Возвращает предпосылки интерфейсного типа.

Начиная с версии 2.2

g_type_set_qdata ()

void                g_type_set_qdata                    (GType type,
                                                         GQuark quark,
                                                         gpointer data);

Прикрепляет произвольные данные к типу.

g_type_get_qdata ()

gpointer            g_type_get_qdata                    (GType type,
                                                         GQuark quark);

Возвращает данные предварительно прикреплённые к type с помощью g_type_set_qdata().

g_type_query ()

void                g_type_query                        (GType type,
                                                         GTypeQuery *query);

Запрашивает у системы типов информацию об определённом типе. Эта функция заполняет определённую пользователем структуру типовой информацией. Если помещен неверный GType, type член GTypeQuery равен 0. Все члены заполненные в структуре GTypeQuery должны рассматриваться как константы и не должны изменяться.

GTypeQuery

typedef struct {
  GType		type;
  const gchar  *type_name;
  guint		class_size;
  guint		instance_size;
} GTypeQuery;

Структура содержащая информацию для определённого типа. Она заполняется функцией g_type_query().

GBaseInitFunc ()

void                (*GBaseInitFunc)                    (gpointer g_class);

Это callback-функция используемая системой типов для основной инициализации классовых структур производных типов. Она вызывается как часть процесса инициализации всех производных классов и должна перераспределить или сбросить все динамические члены класса скопированные из родительского класса. Например, члены класса (такие как строки) которые не достаточно обработать простым копированием памяти родительского класса в производный класс, должны быть изменены. Смотрите GClassInitFunc() для обсуждения процесса инициализации классов.

GBaseFinalizeFunc ()

void                (*GBaseFinalizeFunc)                (gpointer g_class);

Это callback-функция используемая системой типов для финализации тех частей сструктуры класса производного типа которые были установлены из соответствующей функции GBaseInitFunc(). Финализация класса в основном работает в обратном порядке относительно процесса инициализации класса. Смотрите GClassInitFunc() для обсуждения процесса инициализации класса.

GClassInitFunc ()

void                (*GClassInitFunc)                   (gpointer g_class,
                                                         gpointer class_data);

Это callback-функция используемая системой типов для инициализации класса определённого типа. Она должна инициализировать все статичные члены класса. Процесс инициализации класса включает:

Так как производные классы частично инициализируются через копирование памяти родительского класса, основное правило в том, что GBaseInitFunc() и GBaseFinalizeFunc() должны заботится о необходимой переинициализации и высвобождении тех членов класса которые были введены типом определившим эти GBaseInitFunc()/GBaseFinalizeFunc(). GClassInitFunc() должна заботиться только об инициализации статичных членов класса, в то время как динамические члены класса (такие как распределённые строки или ресурсы подсчёта ссылок) лучше обрабатывать с помощью GBaseInitFunc() для данного типа, таким образом надлежащая инициализация динамических членов класса также выполняется для инициализации классов производных типов. Пример может помочь понять предназначение разных инициализаторов класса:

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;
}

Инициализация TypeBClass сначала вызовет инициализацию TypeAClass (производные классы ссылаются на их родительские классы, смотрите g_type_class_ref()). Инициализация TypeAClass инициализирует нулями свои поля, зтем вызовет свою GBaseInitFunc() type_a_base_class_init() для распределения своих динамических членов (dynamic_string), и наконец вызовет свою GClassInitFunc() type_a_class_init() для инициализации статических членов (static_integer). Первым шагом в процессе инициализации TypeBClass является прямое копирование памяти содержащей TypeAClass в TypeBClass и инициализация нулями оставшихся полей в TypeBClass. Динамические члены TypeAClass внутри TypeBClass теперь необходимо переинициализировать выполнив вызов type_a_base_class_init() с параметром TypeBClass. После GBaseInitFunc() из TypeBClass, вызывается type_b_base_class_init() для распределения динамических членов TypeBClass (dynamic_gstring), и наконец GClassInitFunc() из TypeBClass, вызывается type_b_class_init() для завершения процесса инициализации со статическими членами (static_float). Соответствующее количество частей финализации для GBaseInitFunc() функций обеспечивают освобождение распределённых ресурсов во время финализации класса.

GClassFinalizeFunc ()

void                (*GClassFinalizeFunc)               (gpointer g_class,
                                                         gpointer class_data);

Это callback-функция используемая системой типов для финализации класса. Она редко нужна, так как динамически распределяемые ресурсы классов должны обрабатываться с помощью GBaseInitFunc() и GBaseFinalizeFunc(). Кроме того, спецификация GClassFinalizeFunc() в структуре GTypeInfo статических типов недоступна, потому что классы статических типов никогда не финализируются (они искусственно поддерживаются когда количество их ссылок достигает нуля).

GInstanceInitFunc ()

void                (*GInstanceInitFunc)                (GTypeInstance *instance,
                                                         gpointer g_class);

Это callback-функция используемая системой типов для инициализации нового экземпляра типа. Эта функция инициализирует все члены экземпляра и распределяет все ресурсы запрашиваемые ими. Инициализация производного экземпляра включает вызов всех инициализаторов экземпляров его родительских типов, поэтому член класса экземпляра изменяется в течение его инициализации чтобы всегда указывать на класс к которому принадлежит тип введённый в текущий инициализатор.

GInterfaceInitFunc ()

void                (*GInterfaceInitFunc)               (gpointer g_iface,
                                                         gpointer iface_data);

Это callback-функция используемая системой типов для инициализации нового интерфейса. Эта функция должна инициализировать все внутренние данные и распределять любые ресурсы запрошенные интерфейсом.

GInterfaceFinalizeFunc ()

void                (*GInterfaceFinalizeFunc)           (gpointer g_iface,
                                                         gpointer iface_data);

Это callback-функция используемая системой типов для финализации интерфейса. Эта функция должна уничтожать любые внутренние данные и освобождать любые ресурсы распределённые соответствующей функцией GInterfaceInitFunc().

GTypeClassCacheFunc ()

gboolean            (*GTypeClassCacheFunc)              (gpointer cache_data,
                                                         GTypeClass *g_class);

Эта callback-функция вызывается когда количество ссылок класса сбрасывается к нулю. Она может использовать g_type_class_ref() чтобы предотвратить освобождение класса. Вы не должны вызывать g_type_class_unref() из функции GTypeClassCacheFunc чтобы не допустить бесконечную рекурсию, используйте вместо неё g_type_class_unref_uncached().

Функции должны проверять id класса является ли он фактически кэшируеммым классом данного типа, так как все классы проходят через туже цепочку GTypeClassCacheFunc.

enum GTypeFlags

typedef enum    /*< skip >*/
{
  G_TYPE_FLAG_ABSTRACT		= (1 << 4),
  G_TYPE_FLAG_VALUE_ABSTRACT	= (1 << 5)
} GTypeFlags;

Битовая маска для контроля характеристик типа.

enum GTypeFundamentalFlags

typedef enum    /*< skip >*/
{
  G_TYPE_FLAG_CLASSED           = (1 << 0),
  G_TYPE_FLAG_INSTANTIATABLE    = (1 << 1),
  G_TYPE_FLAG_DERIVABLE         = (1 << 2),
  G_TYPE_FLAG_DEEP_DERIVABLE    = (1 << 3)
} GTypeFundamentalFlags;

Битовая маска используемая для контроля специфичных характеристик базового типа.

g_type_register_static ()

GType               g_type_register_static              (GType parent_type,
                                                         const gchar *type_name,
                                                         const GTypeInfo *info,
                                                         GTypeFlags flags);

Регистрирует type_name как имя нового статичного типа унаследовавшего parent_type. Система типов использует информацию содержащуюся в структуре GTypeInfo указанной параметром info для управления типом и его экземплярами (если не абстрактный). Значение flags определяет природу типа (например абстрактный или нет).

g_type_register_static_simple ()

GType               g_type_register_static_simple       (GType parent_type,
                                                         const gchar *type_name,
                                                         guint class_size,
                                                         GClassInitFunc class_init,
                                                         guint instance_size,
                                                         GInstanceInitFunc instance_init,
                                                         GTypeFlags flags);

Регистрирует type_name как имя нового статичного типа унаследовавшего parent_type. Значение flags определяет природу типа (например абстрактный или нет). Она заполняет GTypeInfo структуру и вызывает g_type_register_static().

Начиная с версии 2.12

g_type_register_dynamic ()

GType               g_type_register_dynamic             (GType parent_type,
                                                         const gchar *type_name,
                                                         GTypePlugin *plugin,
                                                         GTypeFlags flags);

Регистрирует type_name как имя нового динамического типа унаследовавшего parent_type. Система типов использует информацию содержащуюся в структуре GTypePlugin указанной параметром plugin для управления типом и его экземпляром (если не абстрактный). Значение flags определяет природу типа (например абстрактный или нет).

g_type_register_fundamental ()

GType               g_type_register_fundamental         (GType type_id,
                                                         const gchar *type_name,
                                                         const GTypeInfo *info,
                                                         const GTypeFundamentalInfo *finfo,
                                                         GTypeFlags flags);

Регистрирует type_id как предопределённый идентификатор, а type_name как имя базового типа. Система типов использует информацию содержащуюся в структуре GTypeInfo указанной параметром info и в структуре GTypeFundamentalInfo указанной параметром finfo для управления экземпляром типа. Значение flags определяет дополнительные характеристики базового типа.

g_type_add_interface_static ()

void                g_type_add_interface_static         (GType instance_type,
                                                         GType interface_type,
                                                         const GInterfaceInfo *info);

Добавляет статический interface_type к instantiable_type. Информация содержащаяся в структуре GTypeInterfaceInfo указанная параметром info используется для управления связью.

g_type_add_interface_dynamic ()

void                g_type_add_interface_dynamic        (GType instance_type,
                                                         GType interface_type,
                                                         GTypePlugin *plugin);

Добавляет динамический interface_type к instantiable_type. Информация содержащаяся в структуре GTypePlugin указанной параметром plugin используется для управления связью.

g_type_interface_add_prerequisite ()

void                g_type_interface_add_prerequisite   (GType interface_type,
                                                         GType prerequisite_type);

Добавляет prerequisite_type в список предпосылок interface_type. Это значит что любая реализация типа interface_type должна так же реализовать prerequisite_type. Предпосылки могут рассматриваться как альтернатива интерфейсного ответвления (которые не поддерживает GType). Интерфейс может иметь один инстанциируемый тип предпосылки.

g_type_get_plugin ()

GTypePlugin*        g_type_get_plugin                   (GType type);

Возвращает структуру GTypePlugin для type или NULL если type не имеет структуру GTypePlugin.

g_type_interface_get_plugin ()

GTypePlugin*        g_type_interface_get_plugin         (GType instance_type,
                                                         GType interface_type);

Возвращает структуру GTypePlugin для динамического интерфейса interface_type который был добавлен к instance_type, или NULL если interface_type не добавлен к instance_type или если не имеет GTypePlugin структуру. Смотрите g_type_add_interface_dynamic().

g_type_fundamental_next ()

GType               g_type_fundamental_next             (void);

Возвращает следующий свободный идентификатор базового типа который можно использовать для регистрации нового базового типа с помощью g_type_register_fundamental(). Возвращаемый ID типа представляет наивысший регистрируемый идентификатор базового типа.

g_type_fundamental ()

GType               g_type_fundamental                  (GType type_id);

Внутренняя функция, используется для извлечения части ID базового типа. вместо неё используйте G_TYPE_FUNDAMENTAL().

g_type_create_instance ()

GTypeInstance*      g_type_create_instance              (GType type);

Создаёт инициализированный экземпляр type если type является допустимым и может быть инстанциирован. Система типов выполняет только основное распределение и установку сструктуры для экземпляра: фактически экземпляр создаётся функциями поставляемыми реализацией базового типа. Поэтому использование g_type_create_instance() зарезервировано только для реализации базового типа. Например экземпляры иерархии GObject должны создаваться через g_object_new() и никогда не должны создаваться непосредственно через g_type_create_instance() которая не обрабатывает такие вещи как единственный ребёнок объекта или конструкцию объекта. Помните: Не используйте эту функцию, кроме как для реализации базового типа. Также языковые привязки не должны использовать эту функцию, а использовать вместо неё g_object_new().

g_type_free_instance ()

void                g_type_free_instance                (GTypeInstance *instance);

Освобождает экземпляр типа, возвращает его в пул экземпляров типа, если он есть.

Как g_type_create_instance(), эта функция зарезервирована для реализаций базовых типов.

g_type_add_class_cache_func ()

void                g_type_add_class_cache_func         (gpointer cache_data,
                                                         GTypeClassCacheFunc cache_func);

Добавляет GTypeClassCacheFunc которая будет вызвана перед сбросом количества ссылок класса в ноль. Это может использоваться для предотвращения преждевременного разрушения класса. Все установленные функции GTypeClassCacheFunc будут скованы пока одна из них не вернёт TRUE. Функции должны контролировать помещаемый id класс, должна ли она фактически кэшировать класс этого типа, так как все классы направляются через туже цепочку GTypeClassCacheFunc.

g_type_remove_class_cache_func ()

void                g_type_remove_class_cache_func      (gpointer cache_data,
                                                         GTypeClassCacheFunc cache_func);

Удаляет предварительно установленную GTypeClassCacheFunc. Кэш содержащийся в cache_func должен быть пустым когда вызывается g_type_remove_class_cache_func() чтобы избежать утечек.

g_type_class_unref_uncached ()

void                g_type_class_unref_uncached         (gpointer g_class);

Вариант g_type_class_unref() для использования в GTypeClassCacheFunc реализации. Она отменяет ссылку на класс без контроля цепочки GTypeClassCacheFunc, избегая рекурсии которая моглабы иначе произойти.

g_type_add_interface_check ()

void                g_type_add_interface_check          (gpointer check_data,
                                                         GTypeInterfaceCheckFunc check_func);

Добавляет функцию вызываемую после инициализации vtable интерфейса для любого класса (то есть после вызова interface_init члена GInterfaceInfo).

Эта функция полезна когда вам нужно контролировать логическое выражение зависящее от интерфейсного класса. Например, реализация GObject использует это средство для контроля реализации объектом всех свойств которые определены его интерфейсом.

Начиная с версии 2.4

g_type_remove_interface_check ()

void                g_type_remove_interface_check       (gpointer check_data,
                                                         GTypeInterfaceCheckFunc check_func);

Удаляет интерфейсную функцию контроля добавленную с помощью g_type_add_interface_check().

Начиная с версии 2.4

GTypeInterfaceCheckFunc ()

void                (*GTypeInterfaceCheckFunc)          (gpointer check_data,
                                                         gpointer g_iface);

Эта callback-функция вызывается после инициализации vtable интерфейса. Смотрите g_type_add_interface_check().

Начиная с версии 2.4

g_type_value_table_peek ()

GTypeValueTable*    g_type_value_table_peek             (GType type);

Возвращает расположение GTypeValueTable связанной с type. Помните что эта функция должна использоваться только из исходного кода который реализует или знает внутреннюю реализацию type.

G_DEFINE_TYPE()

#define G_DEFINE_TYPE(TN, t_n, T_P)			    G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, 0, {})

Удобный макрос для реализации типа, который декларирует функцию инициализации класса, функцию инициализации экземпляра (смотрите GTypeInfo для информации об этом) и статическую переменную с именем t_n_parent_class указывающую на родительский класс. Кроме того, он определяет функцию *_get_type(). Смотрите G_DEFINE_TYPE_EXTENDED() для примера.

Начиная с версии 2.4

G_DEFINE_TYPE_WITH_CODE()

#define G_DEFINE_TYPE_WITH_CODE(TN, t_n, T_P, _C_)	    _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, 0) {_C_;} _G_DEFINE_TYPE_EXTENDED_END()

Удобный макрос для реализации типа. Похож на G_DEFINE_TYPE(), но позволяет вставить произвольный код в функцию *_get_type(), например реализовать интерфейс через G_IMPLEMENT_INTERFACE(). Смотрите G_DEFINE_TYPE_EXTENDED() для примера.

Начиная с версии 2.4

G_DEFINE_ABSTRACT_TYPE()

#define G_DEFINE_ABSTRACT_TYPE(TN, t_n, T_P)		    G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, G_TYPE_FLAG_ABSTRACT, {})

Удобный макрос для реализации типа. Похож на G_DEFINE_TYPE(), но определяет абстрактный тип. Смотрите G_DEFINE_TYPE_EXTENDED() для примера.

Начиная с версии 2.4

G_DEFINE_ABSTRACT_TYPE_WITH_CODE()

#define G_DEFINE_ABSTRACT_TYPE_WITH_CODE(TN, t_n, T_P, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, G_TYPE_FLAG_ABSTRACT) {_C_;} _G_DEFINE_TYPE_EXTENDED_END()

Удобный макрос для реализации типа. Похож на G_DEFINE_TYPE_WITH_CODE(), определяет абстрактный тип и позволяет вставить произвольный код в функцию *_get_type(), например реализовать интерфейс через G_IMPLEMENT_INTERFACE(). Смотрите G_DEFINE_TYPE_EXTENDED() для примера.

Начиная с версии 2.4

G_IMPLEMENT_INTERFACE()

#define             G_IMPLEMENT_INTERFACE(TYPE_IFACE, iface_init)

Удобный макрос для простого добавления интерфейса в _C_ раздел G_DEFINE_TYPE_WITH_CODE() или G_DEFINE_ABSTRACT_TYPE_WITH_CODE(). Смотрите G_DEFINE_TYPE_EXTENDED() для примера.

Помните что этот макрос может использоваться только вместе с G_DEFINE_TYPE_* макросами, так как он зависит от переменных имён из этих макросов.

Начиная с версии 2.4

G_DEFINE_TYPE_EXTENDED()

#define G_DEFINE_TYPE_EXTENDED(TN, t_n, T_P, _f_, _C_)	    _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, _f_) {_C_;} _G_DEFINE_TYPE_EXTENDED_END()

Основной макрос для удобной реализации типа, на котором основан G_DEFINE_TYPE(), и так далее.

G_DEFINE_TYPE_EXTENDED (GtkGadget, 
                        gtk_gadget, 
                        GTK_TYPE_WIDGET,
                        0, 
                        G_IMPLEMENT_INTERFACE (TYPE_GIZMO, 
                                               gtk_gadget_gizmo_init));

static void     gtk_gadget_init       (GtkGadget      *self);
static void     gtk_gadget_class_init (GtkGadgetClass *klass);
static gpointer gtk_gadget_parent_class = NULL;
static void     gtk_gadget_class_intern_init (gpointer klass)
{
  gtk_gadget_parent_class = g_type_class_peek_parent (klass);
  gtk_gadget_class_init ((GtkGadgetClass*) klass);
}

GType
gtk_gadget_get_type (void)
{
  static GType g_define_type_id = 0; 
  if (G_UNLIKELY (g_define_type_id == 0)) 
    { 
      static const GTypeInfo g_define_type_info = { 
        sizeof (GtkGadgetClass), 
        (GBaseInitFunc) NULL, 
        (GBaseFinalizeFunc) NULL, 
        (GClassInitFunc) gtk_gadget_class_intern_init, 
        (GClassFinalizeFunc) NULL, 
        NULL,   /* class_data */ 
        sizeof (GtkGadget), 
        0,      /* n_preallocs */ 
        (GInstanceInitFunc) gtk_gadget_init, 
      }; 
      g_define_type_id = g_type_register_static (GTK_TYPE_WIDGET, "GtkGadget", &g_define_type_info, 0); 
      {
        static const GInterfaceInfo g_implement_interface_info = {
          (GInterfaceInitFunc) gtk_gadget_gizmo_init
        };
        g_type_add_interface_static (g_define_type_id, TYPE_GIZMO, &g_implement_interface_info);
      } 
    } 
  return g_define_type_id; 
}

Начиная с версии 2.4

G_TYPE_INVALID

#define G_TYPE_INVALID			G_TYPE_MAKE_FUNDAMENTAL (0)

Недопустимый GType используется как ошибочное значение которое возвращают некоторые функции возвращающие GType.

G_TYPE_NONE

#define G_TYPE_NONE			G_TYPE_MAKE_FUNDAMENTAL (1)

Базовый тип который используется как замена для возвращаемого типа C void.

G_TYPE_INTERFACE

#define G_TYPE_INTERFACE		G_TYPE_MAKE_FUNDAMENTAL (2)

Базовый тип из который наследуют все интерфейсы.

G_TYPE_CHAR

#define G_TYPE_CHAR			G_TYPE_MAKE_FUNDAMENTAL (3)

Базовый тип соответствующий gchar. Тип подписываемый с помощью G_TYPE_CHAR беззаговорочно 8-битное целочисленное со знаком. Это может быть или не может быть тем же C типом "gchar".

G_TYPE_UCHAR

#define G_TYPE_UCHAR			G_TYPE_MAKE_FUNDAMENTAL (4)

Базовый тип соответствующий guchar.

G_TYPE_BOOLEAN

#define G_TYPE_BOOLEAN			G_TYPE_MAKE_FUNDAMENTAL (5)

Базовый тип соответствующий gboolean.

G_TYPE_INT

#define G_TYPE_INT			G_TYPE_MAKE_FUNDAMENTAL (6)

Базовый тип соответствующий gint.

G_TYPE_UINT

#define G_TYPE_UINT			G_TYPE_MAKE_FUNDAMENTAL (7)

Базовый тип соответствующий guint.

G_TYPE_LONG

#define G_TYPE_LONG			G_TYPE_MAKE_FUNDAMENTAL (8)

Базовый тип соответствующий glong.

G_TYPE_ULONG

#define G_TYPE_ULONG			G_TYPE_MAKE_FUNDAMENTAL (9)

Базовый тип соответствующий gulong.

G_TYPE_INT64

#define G_TYPE_INT64			G_TYPE_MAKE_FUNDAMENTAL (10)

Базовый тип соответствующий gint64.

G_TYPE_UINT64

#define G_TYPE_UINT64			G_TYPE_MAKE_FUNDAMENTAL (11)

Базовый тип соответствующий guint64.

G_TYPE_ENUM

#define G_TYPE_ENUM			G_TYPE_MAKE_FUNDAMENTAL (12)

Базовый тип который наследуют все перечислимые типы.

G_TYPE_FLAGS

#define G_TYPE_FLAGS			G_TYPE_MAKE_FUNDAMENTAL (13)

Базовый тип который наследуют все флаговые типы.

G_TYPE_FLOAT

#define G_TYPE_FLOAT			G_TYPE_MAKE_FUNDAMENTAL (14)

Базовый тип соответствующий gfloat.

G_TYPE_DOUBLE

#define G_TYPE_DOUBLE			G_TYPE_MAKE_FUNDAMENTAL (15)

Базовый тип соответствующий gdouble.

G_TYPE_STRING

#define G_TYPE_STRING			G_TYPE_MAKE_FUNDAMENTAL (16)

Базовый тип соответствующий nul-завершённой C строке.

G_TYPE_POINTER

#define G_TYPE_POINTER			G_TYPE_MAKE_FUNDAMENTAL (17)

Базовый тип соответствующий gpointer.

G_TYPE_BOXED

#define G_TYPE_BOXED			G_TYPE_MAKE_FUNDAMENTAL (18)

Базовый тип который наследуют все boxed типы.

G_TYPE_PARAM

#define G_TYPE_PARAM			G_TYPE_MAKE_FUNDAMENTAL (19)

Базовый тип который наследуют все GParamSpec типы.

G_TYPE_OBJECT

#define G_TYPE_OBJECT			G_TYPE_MAKE_FUNDAMENTAL (20)

Базовый тип для GObject.

G_TYPE_GTYPE

#define	G_TYPE_GTYPE			 (g_gtype_get_type())

Тип для GType.

G_TYPE_RESERVED_GLIB_FIRST

#define G_TYPE_RESERVED_GLIB_FIRST	(21)

Первый номер базового типа для создания идентификатора базового типа с помощью G_TYPE_MAKE_FUNDAMENTAL() зарезервированный для GLib.

G_TYPE_RESERVED_GLIB_LAST

#define G_TYPE_RESERVED_GLIB_LAST	(31)

Последний номер базового типа зарезервированный для GLib.

G_TYPE_RESERVED_BSE_FIRST

#define G_TYPE_RESERVED_BSE_FIRST	(32)

Первый номер базового типа для создания идентификатора базового типа с помощью G_TYPE_MAKE_FUNDAMENTAL() зарезервированный для BSE.

G_TYPE_RESERVED_BSE_LAST

#define G_TYPE_RESERVED_BSE_LAST	(48)

Последний номер базового типа зарезервированный для BSE.

G_TYPE_RESERVED_USER_FIRST

#define G_TYPE_RESERVED_USER_FIRST	(49)

Первый доступный номер базового типа для создания нового идентификатора базового типа с помощью G_TYPE_MAKE_FUNDAMENTAL().