gunichar

typedef guint32 gunichar;

Тип который может содержать любой код символа UCS-4.

gunichar2

typedef guint16 gunichar2;

Тип который может содержать любой указатель кода UTF-16^[3].

g_unichar_validate ()

gboolean    g_unichar_validate              (gunichar ch);

Проверяет является ли ch допустимым символом Unicode. Любые возможные целочисленные значения ch не будут допустимы. 0 рассматривается как правильный символ, хотя обычно он является концом строки.

g_unichar_isalnum ()

gboolean    g_unichar_isalnum               (gunichar c);

Определяет является ли символ алфавитно-цифровым. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

g_unichar_isalpha ()

gboolean    g_unichar_isalpha               (gunichar c);

Определяет является ли символ алфавитным (то есть буквой). Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

g_unichar_iscntrl ()

gboolean    g_unichar_iscntrl               (gunichar c);

Определяет является ли символ управляющим символом. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

g_unichar_isdigit ()

gboolean    g_unichar_isdigit               (gunichar c);

Определяет является ли символ числовым (то есть цифрой). Это распространяется на ASCII 0-9 а так же цифры в других языках/сценариях. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

g_unichar_isgraph ()

gboolean    g_unichar_isgraph               (gunichar c);

Определяет является ли символ печатным и не пробелом (возвращает FALSE для управляющих символов, символов форматирования, и пробелов). Похожа на g_unichar_isprint(), но возвращает TRUE для пробелов. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

g_unichar_islower ()

gboolean    g_unichar_islower               (gunichar c);

Определяет является ли символ буквой в нижнем регистре. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

g_unichar_isprint ()

gboolean    g_unichar_isprint               (gunichar c);

Определяет является ли символ печатным. В отличие от g_unichar_isgraph(), возвращает TRUE для пробелов. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

g_unichar_ispunct ()

gboolean    g_unichar_ispunct               (gunichar c);

Определяет является ли символ символом пунктуации или знаком. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

g_unichar_isspace ()

gboolean    g_unichar_isspace               (gunichar c);

Определяет является ли символ пробелом, табуляцией, или строковым разделителем (перевод строки, возврат каретки, и т.д.). Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

(Помните: не нужно использовать это для прерывания слова; вы должны использовать Pango или эквивалент для получения правильного прерывания слова, алгоритм довольно сложен.)

g_unichar_isupper ()

gboolean    g_unichar_isupper               (gunichar c);

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

g_unichar_isxdigit ()

gboolean    g_unichar_isxdigit              (gunichar c);

Определяет является ли символ шестнадцатеричным числом.

g_unichar_istitle ()

gboolean    g_unichar_istitle               (gunichar c);

Определяет является ли символ символом заголовочного регистра (titlecase). Некоторые символы в Unicode которые являются составными, такие как DZ диаграф имеют три варианта регистра вместо двух. Форма заголовочного регистра (titlecase) используется в начале слова, где только первый символ напечатан только прописными буквами. Форма заголовочного регистра (titlecase) из DZ диаграфа это U+01F2 ЛАТИНСКАЯ ПРОПИСНАЯ БУКВА D СО СТРОЧНОЙ БУКВОЙ Z.

g_unichar_isdefined ()

gboolean    g_unichar_isdefined             (gunichar c);

Определяет является ли полученный символ назначенным в Unicode стандарте.

g_unichar_iswide ()

gboolean    g_unichar_iswide                (gunichar c);

Определяет если символ обычно отрисовывается в ячейке двойной ширины.

g_unichar_iswide_cjk ()

gboolean    g_unichar_iswide_cjk            (gunichar c);

Определяет если символ обычно отрисовывается в ячейке двойной ширины устаревшей East Asian локали. Если символ шире согласно g_unichar_iswide(), то он также сообщает ширину этой функции, но обратное не обязательно верно. Смотрите Unicode Standard Annex 11 для детального изучения.

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

g_unichar_toupper ()

gunichar    g_unichar_toupper               (gunichar c);

Конвертирует символ в верхний регистр.

g_unichar_tolower ()

gunichar    g_unichar_tolower               (gunichar c);

Конвертирует символ в нижний регистр.

g_unichar_totitle ()

gunichar    g_unichar_totitle               (gunichar c);

Конвертирует символ в заголовочный регистр.

g_unichar_digit_value ()

gint        g_unichar_digit_value           (gunichar c);

Определяет числовое значение символа как десятичное число.

g_unichar_xdigit_value ()

gint        g_unichar_xdigit_value          (gunichar c);

Определяет числовое значение символа как шестнадцатеричное число.

enum GUnicodeType

typedef enum
{
  G_UNICODE_CONTROL,
  G_UNICODE_FORMAT,
  G_UNICODE_UNASSIGNED,
  G_UNICODE_PRIVATE_USE,
  G_UNICODE_SURROGATE,
  G_UNICODE_LOWERCASE_LETTER,
  G_UNICODE_MODIFIER_LETTER,
  G_UNICODE_OTHER_LETTER,
  G_UNICODE_TITLECASE_LETTER,
  G_UNICODE_UPPERCASE_LETTER,
  G_UNICODE_COMBINING_MARK,
  G_UNICODE_ENCLOSING_MARK,
  G_UNICODE_NON_SPACING_MARK,
  G_UNICODE_DECIMAL_NUMBER,
  G_UNICODE_LETTER_NUMBER,
  G_UNICODE_OTHER_NUMBER,
  G_UNICODE_CONNECT_PUNCTUATION,
  G_UNICODE_DASH_PUNCTUATION,
  G_UNICODE_CLOSE_PUNCTUATION,
  G_UNICODE_FINAL_PUNCTUATION,
  G_UNICODE_INITIAL_PUNCTUATION,
  G_UNICODE_OTHER_PUNCTUATION,
  G_UNICODE_OPEN_PUNCTUATION,
  G_UNICODE_CURRENCY_SYMBOL,
  G_UNICODE_MODIFIER_SYMBOL,
  G_UNICODE_MATH_SYMBOL,
  G_UNICODE_OTHER_SYMBOL,
  G_UNICODE_LINE_SEPARATOR,
  G_UNICODE_PARAGRAPH_SEPARATOR,
  G_UNICODE_SPACE_SEPARATOR
} GUnicodeType;

Это возможная классификация символа из спецификации Unicode. Смотрите http://www.unicode.org/Public/UNIDATA/UnicodeData.html.

g_unichar_type ()

GUnicodeType g_unichar_type                 (gunichar c);

Класифицирует Unicode символ по типу.

enum GUnicodeBreakType

typedef enum
{
  G_UNICODE_BREAK_MANDATORY,
  G_UNICODE_BREAK_CARRIAGE_RETURN,
  G_UNICODE_BREAK_LINE_FEED,
  G_UNICODE_BREAK_COMBINING_MARK,
  G_UNICODE_BREAK_SURROGATE,
  G_UNICODE_BREAK_ZERO_WIDTH_SPACE,
  G_UNICODE_BREAK_INSEPARABLE,
  G_UNICODE_BREAK_NON_BREAKING_GLUE,
  G_UNICODE_BREAK_CONTINGENT,
  G_UNICODE_BREAK_SPACE,
  G_UNICODE_BREAK_AFTER,
  G_UNICODE_BREAK_BEFORE,
  G_UNICODE_BREAK_BEFORE_AND_AFTER,
  G_UNICODE_BREAK_HYPHEN,
  G_UNICODE_BREAK_NON_STARTER,
  G_UNICODE_BREAK_OPEN_PUNCTUATION,
  G_UNICODE_BREAK_CLOSE_PUNCTUATION,
  G_UNICODE_BREAK_QUOTATION,
  G_UNICODE_BREAK_EXCLAMATION,
  G_UNICODE_BREAK_IDEOGRAPHIC,
  G_UNICODE_BREAK_NUMERIC,
  G_UNICODE_BREAK_INFIX_SEPARATOR,
  G_UNICODE_BREAK_SYMBOL,
  G_UNICODE_BREAK_ALPHABETIC,
  G_UNICODE_BREAK_PREFIX,
  G_UNICODE_BREAK_POSTFIX,
  G_UNICODE_BREAK_COMPLEX_CONTEXT,
  G_UNICODE_BREAK_AMBIGUOUS,
  G_UNICODE_BREAK_UNKNOWN,
  G_UNICODE_BREAK_NEXT_LINE,
  G_UNICODE_BREAK_WORD_JOINER,
  G_UNICODE_BREAK_HANGUL_L_JAMO,
  G_UNICODE_BREAK_HANGUL_V_JAMO,
  G_UNICODE_BREAK_HANGUL_T_JAMO,
  G_UNICODE_BREAK_HANGUL_LV_SYLLABLE,
  G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE
} GUnicodeBreakType;

Это классификация возможных прерываний строк. Пять типов корейской азбуки (Hangul) добавлены в Unicode 4.1, поэтому были введены в GLib 2.10. Помните что новые типы могут быть добавлены в будущем. Приложения должны быть готовы обрабатывать не известные значения. Они могут расцениваться как G_UNICODE_BREAK_UNKNOWN. Смотрите http://www.unicode.org/unicode/reports/tr14/.

g_unichar_break_type ()

GUnicodeBreakType g_unichar_break_type      (gunichar c);

Определяет тип прерывания c. c должен быть Unicode символом (для извлечения символа из текста в кодировке UTF-8, используйте g_utf8_get_char()). Тип прерывания используется для поиска конца слова и строки ("границы текста"), Pango реализует алгоритмы разрешения границ Unicode и обычно вы должны использовать функции такие как pango_break() вместо того, чтобы беспокоится о типе границы самостоятельно.

g_unicode_canonical_ordering ()

void        g_unicode_canonical_ordering    (gunichar *string,
                                             gsize len);

Расчитывает канонический порядок строки на месте. Это перераспределяет разложение символов в строке согласно их классам объединения. Смотрите руководство Unicode для большей информации.

g_unicode_canonical_decomposition ()

gunichar*   g_unicode_canonical_decomposition
                                            (gunichar ch,
                                             gsize *result_len);

Расчитывает каноническую декомпозицию символа Unicode.

g_unichar_get_mirror_char ()

gboolean    g_unichar_get_mirror_char       (gunichar ch,
                                             gunichar *mirrored_ch);

В Unicode, некоторые символы являются зеркальными (mirrored). Это значит что их изображение является отражённым горизонтально в тексте который расположен с право на лево. Например, "(" стал бы зеркальным отражением, ")", в тексте с обратной ориентацией (right-to-left).

Если ch имеет зеркальное свойство Unicode и есть другой символ unicode который обычно имеет глиф являющийся зеркальным изображением ch's глифа и параметр mirrored_ch установлен, он помещает символ в адрес указанный mirrored_ch. Иначе размещается оригинальный символ.

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

enum GUnicodeScript

typedef enum 
{                         /* ISO 15924 code */
  G_UNICODE_SCRIPT_INVALID_CODE = -1,
  G_UNICODE_SCRIPT_COMMON       = 0,   /* Zyyy */
  G_UNICODE_SCRIPT_INHERITED,          /* Qaai */
  G_UNICODE_SCRIPT_ARABIC,             /* Arab */
  G_UNICODE_SCRIPT_ARMENIAN,           /* Armn */
  G_UNICODE_SCRIPT_BENGALI,            /* Beng */
  G_UNICODE_SCRIPT_BOPOMOFO,           /* Bopo */
  G_UNICODE_SCRIPT_CHEROKEE,           /* Cher */
  G_UNICODE_SCRIPT_COPTIC,             /* Qaac */
  G_UNICODE_SCRIPT_CYRILLIC,           /* Cyrl (Cyrs) */
  G_UNICODE_SCRIPT_DESERET,            /* Dsrt */
  G_UNICODE_SCRIPT_DEVANAGARI,         /* Deva */
  G_UNICODE_SCRIPT_ETHIOPIC,           /* Ethi */
  G_UNICODE_SCRIPT_GEORGIAN,           /* Geor (Geon, Geoa) */
  G_UNICODE_SCRIPT_GOTHIC,             /* Goth */
  G_UNICODE_SCRIPT_GREEK,              /* Grek */
  G_UNICODE_SCRIPT_GUJARATI,           /* Gujr */
  G_UNICODE_SCRIPT_GURMUKHI,           /* Guru */
  G_UNICODE_SCRIPT_HAN,                /* Hani */
  G_UNICODE_SCRIPT_HANGUL,             /* Hang */
  G_UNICODE_SCRIPT_HEBREW,             /* Hebr */
  G_UNICODE_SCRIPT_HIRAGANA,           /* Hira */
  G_UNICODE_SCRIPT_KANNADA,            /* Knda */
  G_UNICODE_SCRIPT_KATAKANA,           /* Kana */
  G_UNICODE_SCRIPT_KHMER,              /* Khmr */
  G_UNICODE_SCRIPT_LAO,                /* Laoo */
  G_UNICODE_SCRIPT_LATIN,              /* Latn (Latf, Latg) */
  G_UNICODE_SCRIPT_MALAYALAM,          /* Mlym */
  G_UNICODE_SCRIPT_MONGOLIAN,          /* Mong */
  G_UNICODE_SCRIPT_MYANMAR,            /* Mymr */
  G_UNICODE_SCRIPT_OGHAM,              /* Ogam */
  G_UNICODE_SCRIPT_OLD_ITALIC,         /* Ital */
  G_UNICODE_SCRIPT_ORIYA,              /* Orya */
  G_UNICODE_SCRIPT_RUNIC,              /* Runr */
  G_UNICODE_SCRIPT_SINHALA,            /* Sinh */
  G_UNICODE_SCRIPT_SYRIAC,             /* Syrc (Syrj, Syrn, Syre) */
  G_UNICODE_SCRIPT_TAMIL,              /* Taml */
  G_UNICODE_SCRIPT_TELUGU,             /* Telu */
  G_UNICODE_SCRIPT_THAANA,             /* Thaa */
  G_UNICODE_SCRIPT_THAI,               /* Thai */
  G_UNICODE_SCRIPT_TIBETAN,            /* Tibt */
  G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, /* Cans */
  G_UNICODE_SCRIPT_YI,                 /* Yiii */
  G_UNICODE_SCRIPT_TAGALOG,            /* Tglg */
  G_UNICODE_SCRIPT_HANUNOO,            /* Hano */
  G_UNICODE_SCRIPT_BUHID,              /* Buhd */
  G_UNICODE_SCRIPT_TAGBANWA,           /* Tagb */

  /* Unicode-4.0 additions */
  G_UNICODE_SCRIPT_BRAILLE,            /* Brai */
  G_UNICODE_SCRIPT_CYPRIOT,            /* Cprt */
  G_UNICODE_SCRIPT_LIMBU,              /* Limb */
  G_UNICODE_SCRIPT_OSMANYA,            /* Osma */
  G_UNICODE_SCRIPT_SHAVIAN,            /* Shaw */
  G_UNICODE_SCRIPT_LINEAR_B,           /* Linb */
  G_UNICODE_SCRIPT_TAI_LE,             /* Tale */
  G_UNICODE_SCRIPT_UGARITIC,           /* Ugar */
      
  /* Unicode-4.1 additions */
  G_UNICODE_SCRIPT_NEW_TAI_LUE,        /* Talu */
  G_UNICODE_SCRIPT_BUGINESE,           /* Bugi */
  G_UNICODE_SCRIPT_GLAGOLITIC,         /* Glag */
  G_UNICODE_SCRIPT_TIFINAGH,           /* Tfng */
  G_UNICODE_SCRIPT_SYLOTI_NAGRI,       /* Sylo */
  G_UNICODE_SCRIPT_OLD_PERSIAN,        /* Xpeo */
  G_UNICODE_SCRIPT_KHAROSHTHI,         /* Khar */

  /* Unicode-5.0 additions */
  G_UNICODE_SCRIPT_UNKNOWN,            /* Zzzz */
  G_UNICODE_SCRIPT_BALINESE,           /* Bali */
  G_UNICODE_SCRIPT_CUNEIFORM,          /* Xsux */
  G_UNICODE_SCRIPT_PHOENICIAN,         /* Phnx */
  G_UNICODE_SCRIPT_PHAGS_PA,           /* Phag */
  G_UNICODE_SCRIPT_NKO                 /* Nkoo */
} GUnicodeScript;

Перечисление GUnicodeScript идентифицирует различные системы записи. Значения соответствуют именам определённым в стандарте Unicode. Перечисление было добавлено в GLib 2.14. Помните что новые типы могут быть добавлены в будущем. Приложения должны уметь обрабатывать неизвестные значения. Смотрите Unicode Standard Annex 24: Script names.

g_unichar_get_script ()

GUnicodeScript g_unichar_get_script         (gunichar ch);

Находит GUnicodeScript для специфического символа (как определено в Unicode Standard Annex 24). Проверка на правильность ch для Unicode символа не производится; если вы поместите недопустимый символ, результат будет неопределённым.

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

g_utf8_next_char()

#define     g_utf8_next_char(p)

Пропускает следующий символ в UTF-8 строке. Строка должна быть допустимой; это максимально быстрая макрокоманда и никакого контроля ошибок не проводится. Вы должны использовать эту макрокоманду для посимвольной итерации строки. Эта макрокоманда возвращает начало следующего символа UTF-8. Перед использованием этой макрокоманды используйте g_utf8_validate() для проверки правильности строк которые могут содержать недопустимые символы UTF-8.

g_utf8_get_char ()

gunichar    g_utf8_get_char                 (const gchar *p);

Конвертирует последовательность байт в кодировке UTF-8 в Unicode символ. Если p не указывает на допустимый символ в кодировке UTF-8, результат будет неопределённым. Если вы не уверены в том что последовательность байт является допустимым кодом Unicode символов, вы должны использовать вместо этой функции g_utf8_get_char_validated().

g_utf8_get_char_validated ()

gunichar    g_utf8_get_char_validated       (const gchar *p,
                                             gssize max_len);

Конвертирует последовательность байт в кодировке UTF-8 в Unicode символ. Эта функция проверяет незаконченность символов, для недопустимых символов таких как символы которые выходят за диапазон Unicode и слишком длинных допустимых символов.

g_utf8_offset_to_pointer ()

gchar*      g_utf8_offset_to_pointer        (const gchar *str,
                                             glong offset);

Конвертирует из целочисленного символа смещения в указатель на позицию внутри строки.

Начиная с версии 2.10, эта функция позволяет помещать отрицательное offset для смещения назад. Это в основном полезно при движении с конца вместо движения вперед если offset это последняя четверть строки, так как передвижение вперёд в три раза быстрее чем назад.

g_utf8_pointer_to_offset ()

glong       g_utf8_pointer_to_offset        (const gchar *str,
                                             const gchar *pos);

Конвертирует из указателя внутри строки в целочисленное смещение символов.

Начиная с версии 2.10, эта функция позволяет pos быть перед str, и возвращает негативное смещение в этом случае.

g_utf8_prev_char ()

gchar*      g_utf8_prev_char                (const gchar *p);

Находит предыдущий символ UTF-8 в строке перед p.

p не должен быть в начале символа UTF-8. Никакая проверка не проводится для найденого символа кроме фактической допустимости начального байта. Если p может оказаться первым символом строки, вы должны использовать g_utf8_find_prev_char() вместо этой функции.

g_utf8_find_next_char ()

gchar*      g_utf8_find_next_char           (const gchar *p,
                                             const gchar *end);

Ищет начало следующего символа UTF-8 в строке после p.

p не должен быть началом UTF-8 символа. Для найденного символа не проводится никакой проверки фактической правильности символа, кроме допустимости начального байта.

g_utf8_find_prev_char ()

gchar*      g_utf8_find_prev_char           (const gchar *str,
                                             const gchar *p);

Учитывая позицию p со строкой UTF-8 str, находит начало предыдущего символа UTF-8 строки перед p. Возвращает NULL если нет символов UTF-8 представленных в строке str перед p.

p не должен быть началом UTF-8 символа. Никакой проверки не проводится для найденного символа за исключением соответствия начального байта.

g_utf8_strlen ()

glong       g_utf8_strlen                   (const gchar *p,
                                             gssize max);

Возвращает длину строки в символах.

g_utf8_strncpy ()

gchar*      g_utf8_strncpy                  (gchar *dest,
                                             const gchar *src,
                                             gsize n);

Как стандартная C функция strncpy(), но копирует полученное количество символов а не байт. Строка src должна быть допустимым UTF-8 текстом. (Используйте g_utf8_validate() для всех текстов перед попыткой использования UTF-8 функций.)

g_utf8_strchr ()

gchar*      g_utf8_strchr                   (const gchar *p,
                                             gssize len,
                                             gunichar c);

Находит крайнее левое появление полученного символа Unicode в строке UTF-8, ограничивая поиск в len байт. Если len равен -1, допускается неограниченный поиск.

g_utf8_strrchr ()

gchar*      g_utf8_strrchr                  (const gchar *p,
                                             gssize len,
                                             gunichar c);

Находит крайний правый полученный Unicode символ в строке UTF-8, поиск ограничивается len байтами. Если len это -1, допускается неограниченный поиск.

g_utf8_strreverse ()

gchar*      g_utf8_strreverse               (const gchar *str,
                                             gssize len);

Переворачивает строку в кодировке UTF-8. str должна быть допустимым текстом в кодировке UTF-8. (Используйте g_utf8_validate() для всех текстов перед попыткой использования сервисных функций UTF-8.)

Помните что в отличие от g_strreverse(), эта функция возвращает вновь распределённую память, которая должна быть освобождена с помощью g_free() когда больше не нужна.

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

g_utf8_validate ()

gboolean    g_utf8_validate                 (const gchar *str,
                                             gssize max_len,
                                             const gchar **end);

Утверждает правильность текста в кодировке UTF-8. str это текст для подтверждения; если str nul-завершённая, то max_len может быть -1, иначе max_len должен быть количеством байт для подтверждения. Если end это non-NULL, то конец подтверждённого диапазона будет сохранён здесь (то есть начало первого недопустимого символа, если некоторые байты недопустимы, или иначе конец подтверждённого текста).

Помните что g_utf8_validate() возвращает FALSE если max_len положительное и NUL был встречен перед прочтением max_len байт.

Возвращает TRUE если вся str была допустимой. Многие GLib и GTK+ подпрограммы требуют допустимого ввода UTF-8; поэтому данные прочтённые из файла или сети должны быть проверены с помощью g_utf8_validate() перед выполнением других действий с ними.

g_utf8_strup ()

gchar*      g_utf8_strup                    (const gchar *str,
                                             gssize len);

Конвертирует все Unicode символы строки в верхний регистр. Точный способ которым это выполняется зависит от текущей локали, и может привести к увеличению количества символов в строке. (Например, немецкая ess-zet будет изменена на SS.)

g_utf8_strdown ()

gchar*      g_utf8_strdown                  (const gchar *str,
                                             gssize len);

Конвертирует все Unicode символы строки в нижний регистр. Точный способ которым это выполняется зависит от текущей локали, и может привести к изменению количества символов в строке.

g_utf8_casefold ()

gchar*      g_utf8_casefold                 (const gchar *str,
                                             gssize len);

Конвертирует строку в форму которая не зависит от регистра. Результат не будет соответствовать никакому специальному регистру, но может быть сравнен для равенства или упорядочен с результатом вызова g_utf8_casefold() для других строк.

Помните что вызов g_utf8_casefold() сопровождаемый g_utf8_collate() только приближает к правильному лингвистическому регистру нечувствительному к упорядочиванию, однако это достаточно хорошо. Получение более точного и правильного результата требует более сложной функции сопоставления которая принимает во внимание чувствительность к регистру. GLib в настоящее время не поддерживает такую функцию.

g_utf8_normalize ()

gchar*      g_utf8_normalize                (const gchar *str,
                                             gssize len,
                                             GNormalizeMode mode);

Конвертирует строку в изначальную форму, стандартизируя такие проблемы как, представлен ли символ с акцентом как основной и комбинирующий акцент, или как единственный составной символ. В основном вы должны вызвать g_utf8_normalize() перед сравнением двух Unicode строк.

Режим нормализации G_NORMALIZE_DEFAULT только стандартизирует различия которые не затрагивают текстовое содержание, такие как упомянутые выше акценты представления. G_NORMALIZE_ALL также стандартизирует символы "совместимости" в Unicode, такие как SUPERSCRIPT THREE в стандартные формы (в данном случае DIGIT THREE). Форматирование информации может быть потеряно но в большинстве текстовых операций такие символы должны быть рассмотрены одинаково. Например, g_utf8_collate() нормализуется с помощью G_NORMALIZE_ALL как первый шаг.

G_NORMALIZE_DEFAULT_COMPOSE и G_NORMALIZE_ALL_COMPOSE являются подобными G_NORMALIZE_DEFAULT и G_NORMALIZE_ALL, но возвращают результат с составными формами а не в максимально разложенной форме. Это часто полезно если вы хотите преобразовать строку в устаревшую кодировку или поместить её в систему с меньшей способностью обрабатывать Unicode.

enum GNormalizeMode

typedef enum {
  G_NORMALIZE_DEFAULT,
  G_NORMALIZE_NFD = G_NORMALIZE_DEFAULT,
  G_NORMALIZE_DEFAULT_COMPOSE,
  G_NORMALIZE_NFC = G_NORMALIZE_DEFAULT_COMPOSE,
  G_NORMALIZE_ALL,
  G_NORMALIZE_NFKD = G_NORMALIZE_ALL,
  G_NORMALIZE_ALL_COMPOSE,
  G_NORMALIZE_NFKC = G_NORMALIZE_ALL_COMPOSE
} GNormalizeMode;

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

g_utf8_collate ()

gint        g_utf8_collate                  (const gchar *str1,
                                             const gchar *str2);

Сравнивает две строки для правильного использования лингвистических правил текущей локали. Сортируя большое количество строк, она будет значительно быстрее определять ключи сопоставления с помощью g_utf8_collate_key() и сравнивать ключи и сортируя с помощью strcmp(), вместо сортировки оригинальных строк.

g_utf8_collate_key ()

gchar*      g_utf8_collate_key              (const gchar *str,
                                             gssize len);

Конвертирует строку в ключ сопоставления который можно сравнить с другим ключом сравнения произведенным той же функцией используя strcmp(). Результат сравнения ключей сопоставления двух строк с помощью strcmp() всегда будет сопоставим с результатом сравнения оригинальных ключей с помощью g_utf8_collate().

g_utf8_collate_key_for_filename ()

gchar*      g_utf8_collate_key_for_filename (const gchar *str,
                                             gssize len);

Конвертирует строку в ключ сопоставления который можно сравнить с другим ключом произведённым этой же функцией с помощью strcmp().

Для правильной сортировки имён файлов, эта функция обрабатывает точку '.' как специфичный случай. Большинство словарей считают это незначительным, производя таким образом порядок "event.c" "eventgenerator.c" "event.h" вместо "event.c" "event.h" "eventgenerator.c". Кроме того, хотелось бы обрабатывать разумно числа, так чтобы "file1" "file10" "file5" сортировались как "file1" "file5" "file10".

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

g_utf8_to_utf16 ()

gunichar2*  g_utf8_to_utf16                 (const gchar *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);

Конвертирует строку из UTF-8 в UTF-16. Символ 0 будет добавлен к результату после конвертации текста.

g_utf8_to_ucs4 ()

gunichar*   g_utf8_to_ucs4                  (const gchar *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);

Конвертирует строку из UTF-8 в 32-bit фиксированной ширины представленный как UCS-4. Заверщающий 0 будет добавлен к строке после конвертации текста.

g_utf8_to_ucs4_fast ()

gunichar*   g_utf8_to_ucs4_fast             (const gchar *str,
                                             glong len,
                                             glong *items_written);

Конвертирует строку из UTF-8 в 32-bit представление фиксированной ширины UCS-4, принимая правильный ввод UTF-8. Эта функция примерно в два раза быстрее чем g_utf8_to_ucs4(), но не производит никакой проверки ошибок ввода.

g_utf16_to_ucs4 ()

gunichar*   g_utf16_to_ucs4                 (const gunichar2 *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);

Конвертирует строку из UTF-16 в UCS-4. Результат будет завершён символом 0.

g_utf16_to_utf8 ()

gchar*      g_utf16_to_utf8                 (const gunichar2 *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);

Конвертирует строку из UTF-16 в UTF-8. Результат будет завершён 0 байтом.

Помните что ввод находится уже в родном порядке байт (endianness), начальный символ byte-order-mark специально не обрабатывается. g_convert() может быть использована для конвертации буфера байт данных UTF-16 неоднозначного порядка байт (endianess).

g_ucs4_to_utf16 ()

gunichar2*  g_ucs4_to_utf16                 (const gunichar *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);

Конвертирует строку из UCS-4 в UTF-16. Символ 0 будет добавлен к результату после конвертации текста.

g_ucs4_to_utf8 ()

gchar*      g_ucs4_to_utf8                  (const gunichar *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);

Конвертирует строку из 32-bit фиксированной ширины представленной как UCS-4. в UTF-8. Результат будет завершён 0 байтом.

g_unichar_to_utf8 ()

gint        g_unichar_to_utf8               (gunichar c,
                                             gchar *outbuf);

Конвертирует единственный символ в UTF-8.