ch.bailu.gtk.glib.Glib

public class Glib extends Package

https://docs.gtk.org/

Nested Class Summary

Nested Classes

Modifier and Type

Class

Description

static interface

Glib.OnCompareDataFunc

static interface

Glib.OnDataForeachFunc

static interface

Glib.OnDestroyNotify

static interface

Glib.OnIOFunc

static interface

Glib.OnLogFunc

static interface

Glib.OnSourceFunc

static interface

Glib.OnSourceOnceFunc

static interface

Glib.OnTestDataFunc

static interface

Glib.OnTestFixtureFunc

static interface

Glib.OnTestFunc

static interface

Glib.OnTestLogFatalFunc

static interface

Glib.OnUnixFDSourceFunc
Constructor Summary

Constructors

Constructor

Description

Glib()
Method Summary

Modifier and Type

Method

Description

static int

access(Str filename, int mode)

A wrapper for the POSIX access() function.

static Pointer

alignedAlloc(long n_blocks, long n_block_bytes, long alignment)

This function is similar to g_malloc(), allocating (@n_blocks * @n_block_bytes)
bytes, but care is taken to align the allocated memory to with the given
alignment value.

static Pointer

alignedAlloc0(long n_blocks, long n_block_bytes, long alignment)

This function is similar to g_aligned_alloc(), but it will
also clear the allocated memory before returning it.

static void

alignedFree(Pointer mem)

Frees the memory allocated by g_aligned_alloc().

static int

asciiDigitValue(byte c)

Determines the numeric value of a character as a decimal digit.

static Str

asciiDtostr(Str buffer, int buf_len, double d)

Converts a #gdouble to a string, using the '.' as
decimal point.

static Str

asciiFormatd(Str buffer, int buf_len, Str format, double d)

Converts a #gdouble to a string, using the '.' as
decimal point.

static int

asciiStrcasecmp(Str s1, Str s2)

Compare two strings, ignoring the case of ASCII characters.

static Str

asciiStrdown(Str str, long len)

Converts all upper case ASCII letters to lower case ASCII letters.

static int

asciiStrncasecmp(Str s1, Str s2, long n)

Compare @s1 and @s2, ignoring the case of ASCII characters and any
characters after the first @n in each string.

static Str

asciiStrup(Str str, long len)

Converts all lower case ASCII letters to upper case ASCII letters.

static byte

asciiTolower(byte c)

Convert a character to ASCII lower case.

static byte

asciiToupper(byte c)

Convert a character to ASCII upper case.

static int

asciiXdigitValue(byte c)

Determines the numeric value of a character as a hexadecimal
digit.

static void

assertionMessage(Str domain, Str file, int line, Str func, Str message)

static void

assertionMessageCmpstr(Str domain, Str file, int line, Str func, Str expr, Str arg1, Str cmp, Str arg2)

static void

assertionMessageCmpstrv(Str domain, Str file, int line, Str func, Str expr, Strs arg1, Strs arg2, long first_wrong_idx)

static void

assertionMessageError(Str domain, Str file, int line, Str func, Str expr, Error error, int error_domain, int error_code)

static void

assertionMessageExpr(Str domain, Str file, int line, Str func, Str expr)

Internal function used to print messages from the public g_assert() and
g_assert_not_reached() macros.

static boolean

atomicIntCompareAndExchangeFull(Int atomic, int oldval, int newval, Int preval)

Compares @atomic to @oldval and, if equal, sets it to @newval.

static int

atomicIntExchange(Int atomic, int newval)

Sets the @atomic to @newval and returns the old value from @atomic.

static long

atomicPointerAdd(Pointer atomic, long val)

Atomically adds @val to the value of @atomic.

static long

atomicPointerAnd(Pointer atomic, long val)

Performs an atomic bitwise 'and' of the value of @atomic and @val,
storing the result back in @atomic.

static boolean

atomicPointerCompareAndExchange(Pointer atomic, Pointer oldval, Pointer newval)

Compares @atomic to @oldval and, if equal, sets it to @newval.

static boolean

atomicPointerCompareAndExchangeFull(Pointer atomic, Pointer oldval, Pointer newval, Pointer preval)

Compares @atomic to @oldval and, if equal, sets it to @newval.

static Pointer

atomicPointerExchange(Pointer atomic, Pointer newval)

Sets the @atomic to @newval and returns the old value from @atomic.

static Pointer

atomicPointerGet(Pointer atomic)

Gets the current value of @atomic.

static long

atomicPointerOr(Pointer atomic, long val)

Performs an atomic bitwise 'or' of the value of @atomic and @val,
storing the result back in @atomic.

static void

atomicPointerSet(Pointer atomic, Pointer newval)

Sets the value of @atomic to @newval.

static long

atomicPointerXor(Pointer atomic, long val)

Performs an atomic bitwise 'xor' of the value of @atomic and @val,
storing the result back in @atomic.

static Pointer

atomicRcBoxAcquire(Pointer mem_block)

Atomically acquires a reference on the data pointed by @mem_block.

static Pointer

atomicRcBoxAlloc(long block_size)

Allocates @block_size bytes of memory, and adds atomic
reference counting semantics to it.

static Pointer

atomicRcBoxAlloc0(long block_size)

Allocates @block_size bytes of memory, and adds atomic
reference counting semantics to it.

static Pointer

atomicRcBoxDup(long block_size, Pointer mem_block)

Allocates a new block of data with atomic reference counting
semantics, and copies @block_size bytes of @mem_block
into it.

static long

atomicRcBoxGetSize(Pointer mem_block)

Retrieves the size of the reference counted data pointed by @mem_block.

static void

atomicRcBoxRelease(Pointer mem_block)

Atomically releases a reference on the data pointed by @mem_block.

static void

atomicRcBoxReleaseFull(Pointer mem_block, Glib.OnDestroyNotify clear_func)

Atomically releases a reference on the data pointed by @mem_block.

static long

base64EncodeClose(boolean break_lines, Str out, Int state, Int save)

Flush the status from a sequence of calls to g_base64_encode_step().

static int

bitNthLsf(long mask, int nth_bit)

Find the position of the first bit set in @mask, searching
from (but not including) @nth_bit upwards.

static int

bitNthMsf(long mask, int nth_bit)

Find the position of the first bit set in @mask, searching
from (but not including) @nth_bit downwards.

static int

bitStorage(long number)

Gets the number of bits used to hold @number,
e.g. if @number is 4, 3 bits are needed.

static int

bookmarkFileErrorQuark()

static Str

buildFilename(Str first_element, Object... _elipse)

Creates a filename from a series of elements using the correct
separator for filenames.

static Str

buildPath(Str separator, Str first_element, Object... _elipse)

Creates a path from a series of elements using @separator as the
separator between elements.

static Bytes

byteArrayFreeToBytes(ByteArray array)

Transfers the data from the #GByteArray into a new immutable #GBytes.

static ByteArray

byteArrayNew()

Creates a new #GByteArray with a reference count of 1.

static void

byteArrayUnref(ByteArray array)

Atomically decrements the reference count of @array by one.

static Str

canonicalizeFilename(Str filename, Str relative_to)

Gets the canonical file name from @filename.

static int

chdir(Str path)

A wrapper for the POSIX chdir() function.

static long

checksumTypeGetLength(int checksum_type)

Gets the length in bytes of digests of type @checksum_type

static Str

checkVersion(int required_major, int required_minor, int required_micro)

Checks that the GLib library in use is compatible with the
given version.

static void

clearError()

If @err or *@err is %NULL, does nothing.

static boolean

close(int fd)

This wraps the close() call; in case of error, %errno will be
preserved, but the error will also be stored as a #GError in @error.

static Str

computeChecksumForBytes(int checksum_type, Bytes data)

Computes the checksum for a binary @data.

static Str

computeChecksumForString(int checksum_type, Str str, long length)

Computes the checksum of a string.

static Str

computeHmacForBytes(int digest_type, Bytes key, Bytes data)

Computes the HMAC for a binary @data.

static Str

convert(Str str, long len, Str to_codeset, Str from_codeset, Int64 bytes_read, Int64 bytes_written)

Converts a string from one character set to another.

static int

convertErrorQuark()

static Str

convertWithFallback(Str str, long len, Str to_codeset, Str from_codeset, Str fallback, Int64 bytes_read, Int64 bytes_written)

Converts a string from one character set to another, possibly
including fallback sequences for characters not representable
in the output.

static void

datasetDestroy(Pointer dataset_location)

Destroys the dataset, freeing all memory allocated, and calling any
destroy functions set for data elements.

static void

datasetForeach(Pointer dataset_location, Glib.OnDataForeachFunc func, Pointer user_data)

Calls the given function for each data element which is associated
with the given location.

static Pointer

datasetIdGetData(Pointer dataset_location, int key_id)

Gets the data element corresponding to a #GQuark.

static Pointer

datasetIdRemoveNoNotify(Pointer dataset_location, int key_id)

Removes an element, without calling its destroy notification
function.

static void

datasetIdSetDataFull(Pointer dataset_location, int key_id, Pointer data, Glib.OnDestroyNotify destroy_func)

Sets the data element associated with the given #GQuark id, and also
the function to call when the data element is destroyed.

static long

dateStrftime(Str s, long slen, Str format, Date date)

Generates a printed representation of the date, in a
[locale][setlocale]-specific way.

static boolean

dateValidJulian(int julian_date)

Returns %TRUE if the Julian day is valid.

static boolean

dateValidMonth(int month)

Returns %TRUE if the month value is valid.

static boolean

dateValidWeekday(int weekday)

Returns %TRUE if the weekday is valid.

static Str

dcgettext(Str domain, Str msgid, int category)

This is a variant of g_dgettext() that allows specifying a locale
category instead of always using `LC_MESSAGES`.

static Str

dgettext(Str domain, Str msgid)

This function is a wrapper of dgettext() which does not translate
the message if the default domain as set with textdomain() has no
translations for the current locale.

static boolean

directEqual(Pointer v1, Pointer v2)

Compares two #gpointer arguments and returns %TRUE if they are equal.

static int

directHash(Pointer v)

Converts a gpointer to a hash value.

static Str

dirMakeTmp(Str tmpl)

Creates a subdirectory in the preferred directory for temporary
files (as returned by g_get_tmp_dir()).

static Str

dngettext(Str domain, Str msgid, Str msgid_plural, long n)

This function is a wrapper of dngettext() which does not translate
the message if the default domain as set with textdomain() has no
translations for the current locale.

static boolean

doubleEqual(Pointer v1, Pointer v2)

Compares the two #gdouble values being pointed to and returns
%TRUE if they are equal.

static int

doubleHash(Pointer v)

Converts a pointer to a #gdouble to a hash value.

static Str

dpgettext(Str domain, Str msgctxtid, long msgidoffset)

This function is a variant of g_dgettext() which supports
a disambiguating message context.

static Str

dpgettext2(Str domain, Str context, Str msgid)

This function is a variant of g_dgettext() which supports
a disambiguating message context.

static int

fileErrorFromErrno(int err_no)

Gets a #GFileError constant based on the passed-in @err_no.

static int

fileErrorQuark()

static Str

filenameDisplayBasename(Str filename)

Returns the display basename for the particular filename, guaranteed
to be valid UTF-8.

static Str

filenameDisplayName(Str filename)

Converts a filename into a valid UTF-8 string.

static Str

filenameFromUtf8(Str utf8string, long len, Int64 bytes_read, Int64 bytes_written)

Converts a string from UTF-8 to the encoding GLib uses for
filenames.

static Str

filenameToUri(Str filename, Str hostname)

Converts an absolute filename to an escaped ASCII-encoded URI, with the path
component following Section 3.3. of RFC 2396.

static Str

filenameToUtf8(Str opsysstring, long len, Int64 bytes_read, Int64 bytes_written)

Converts a string which is in the encoding used by GLib for
filenames into a UTF-8 string.

static Str

fileReadLink(Str filename)

Reads the contents of the symbolic link @filename like the POSIX
readlink() function.

static boolean

fileSetContents(Str filename, Str contents, long length)

Writes all of @contents to a file named @filename.

static boolean

fileSetContentsFull(Str filename, Str contents, long length, int flags, int mode)

Writes all of @contents to a file named @filename, with good error checking.

static boolean

fileTest(Str filename, int test)

Returns %TRUE if any of the tests in the bitfield @test are
%TRUE.

static Str

findProgramInPath(Str program)

Locates the first executable named @program in the user's path, in the
same way that execvp() would locate it.

static Str

formatSize(long size)

Formats a size (for example the size of a file) into a human readable
string.

static Str

formatSizeFull(long size, int flags)

Formats a size.

static void

free(Pointer mem)

Frees the memory pointed to by @mem.

static Str

getApplicationName()

Gets a human-readable name for the application, as set by
g_set_application_name().

static boolean

getCharset(Strs charset)

Obtains the character set for the [current locale][setlocale]; you
might use this character set as an argument to g_convert(), to convert
from the current locale's encoding to some other encoding.

static ClassHandler

getClassHandler()

static Str

getCodeset()

Gets the character set for the current locale.

static boolean

getConsoleCharset(Strs charset)

Obtains the character set used by the console attached to the process,
which is suitable for printing output to the terminal.

static Str

getCurrentDir()

Gets the current directory.

static Str

getenv(Str variable)

Returns the value of an environment variable.

static Str

getHomeDir()

Gets the current user's home directory.

static Str

getHostName()

Return a name for the machine.

static long

getMonotonicTime()

Queries the system monotonic time.

static int

getNumProcessors()

Determine the approximate number of threads that the system will
schedule simultaneously for this process.

static Str

getOsInfo(Str key_name)

Get information about the operating system.

static Str

getPrgname()

Gets the name of the program.

static Str

getRealName()

Gets the real name of the user.

static long

getRealTime()

Queries the system wall-clock time.

static Str

getTmpDir()

Gets the directory to use for temporary files.

static Str

getUserCacheDir()

Returns a base directory in which to store non-essential, cached
data specific to particular user.

static Str

getUserConfigDir()

Returns a base directory in which to store user-specific application
configuration information such as user preferences and settings.

static Str

getUserDataDir()

Returns a base directory in which to access application data such
as icons that is customized for a particular user.

static Str

getUserName()

Gets the user name of the current user.

static Str

getUserRuntimeDir()

Returns a directory that is unique to the current user on the local
system.

static Str

getUserSpecialDir(int directory)

Returns the full path of a special directory using its logical id.

static Str

getUserStateDir()

Returns a base directory in which to store state files specific to
particular user.

static boolean

hashTableAdd(HashTable hash_table, Pointer key)

This is a convenience function for using a #GHashTable as a set.

static boolean

hashTableContains(HashTable hash_table, Pointer key)

Checks if @key is in @hash_table.

static void

hashTableDestroy(HashTable hash_table)

Destroys all keys and values in the #GHashTable and decrements its
reference count by 1.

static boolean

hashTableInsert(HashTable hash_table, Pointer key, Pointer value)

Inserts a new key and value into a #GHashTable.

static Pointer

hashTableLookup(HashTable hash_table, Pointer key)

Looks up a key in a #GHashTable.

static HashTable

hashTableNewSimilar(HashTable other_hash_table)

Creates a new #GHashTable like g_hash_table_new_full() with a reference
count of 1.

static boolean

hashTableRemove(HashTable hash_table, Pointer key)

Removes a key and its associated value from a #GHashTable.

static void

hashTableRemoveAll(HashTable hash_table)

Removes all keys and their associated values from a #GHashTable.

static boolean

hashTableReplace(HashTable hash_table, Pointer key, Pointer value)

Inserts a new key and value into a #GHashTable similar to
g_hash_table_insert().

static int

hashTableSize(HashTable hash_table)

Returns the number of elements contained in the #GHashTable.

static boolean

hashTableSteal(HashTable hash_table, Pointer key)

Removes a key and its associated value from a #GHashTable without
calling the key and value destroy functions.

static void

hashTableStealAll(HashTable hash_table)

Removes all keys and their associated values from a #GHashTable
without calling the key and value destroy functions.

static void

hashTableUnref(HashTable hash_table)

Atomically decrements the reference count of @hash_table by one.

static boolean

hookDestroy(HookList hook_list, long hook_id)

Destroys a #GHook, given its ID.

static void

hookDestroyLink(HookList hook_list, Hook hook)

Removes one #GHook from a #GHookList, marking it
inactive and calling g_hook_unref() on it.

static void

hookFree(HookList hook_list, Hook hook)

Calls the #GHookList @finalize_hook function if it exists,
and frees the memory allocated for the #GHook.

static void

hookInsertBefore(HookList hook_list, Hook sibling, Hook hook)

Inserts a #GHook into a #GHookList, before a given #GHook.

static void

hookPrepend(HookList hook_list, Hook hook)

Prepends a #GHook on the start of a #GHookList.

static void

hookUnref(HookList hook_list, Hook hook)

Decrements the reference count of a #GHook.

static boolean

hostnameIsAsciiEncoded(Str hostname)

Tests if @hostname contains segments with an ASCII-compatible
encoding of an Internationalized Domain Name.

static boolean

hostnameIsIpAddress(Str hostname)

Tests if @hostname is the string form of an IPv4 or IPv6 address.

static boolean

hostnameIsNonAscii(Str hostname)

Tests if @hostname contains Unicode characters.

static Str

hostnameToAscii(Str hostname)

Converts @hostname to its canonical ASCII form; an ASCII-only
string containing no uppercase letters and not ending with a
trailing dot.

static Str

hostnameToUnicode(Str hostname)

Converts @hostname to its canonical presentation form; a UTF-8
string in Unicode normalization form C, containing no uppercase
letters, no forbidden characters, and no ASCII-encoded segments,
and not ending with a trailing dot.

static int

idleAdd(Glib.OnSourceFunc function, Pointer data)

Adds a function to be called whenever there are no higher priority
events pending to the default main loop.

static int

idleAddFull(int priority, Glib.OnSourceFunc function, Pointer data, Glib.OnDestroyNotify notify)

Adds a function to be called whenever there are no higher priority
events pending.

static int

idleAddOnce(Glib.OnSourceOnceFunc function, Pointer data)

Adds a function to be called whenever there are no higher priority
events pending to the default main loop.

static boolean

idleRemoveByData(Pointer data)

Removes the idle function with the given data.

static Source

idleSourceNew()

Creates a new idle source.

static boolean

int64Equal(Pointer v1, Pointer v2)

Compares the two #gint64 values being pointed to and returns
%TRUE if they are equal.

static int

int64Hash(Pointer v)

Converts a pointer to a #gint64 to a hash value.

static boolean

intEqual(Pointer v1, Pointer v2)

Compares the two #gint values being pointed to and returns
%TRUE if they are equal.

static Str

internStaticString(Str string)

Returns a canonical representation for @string.

static Str

internString(Str string)

Returns a canonical representation for @string.

static int

intHash(Pointer v)

Converts a pointer to a #gint to a hash value.

static int

ioAddWatch(IOChannel channel, int condition, Glib.OnIOFunc func, Pointer user_data)

Adds the #GIOChannel into the default main loop context
with the default priority.

static int

ioAddWatchFull(IOChannel channel, int priority, int condition, Glib.OnIOFunc func, Pointer user_data, Glib.OnDestroyNotify notify)

Adds the #GIOChannel into the default main loop context
with the given priority.

static int

ioChannelErrorFromErrno(int en)

Converts an `errno` error number to a #GIOChannelError.

static int

ioChannelErrorQuark()

static Source

ioCreateWatch(IOChannel channel, int condition)

Creates a #GSource that's dispatched when @condition is met for the
given @channel.

static int

keyFileErrorQuark()

static Str

localeFromUtf8(Str utf8string, long len, Int64 bytes_read, Int64 bytes_written)

Converts a string from UTF-8 to the encoding used for strings by
the C runtime (usually the same as that used by the operating
system) in the [current locale][setlocale].

static Str

localeToUtf8(Str opsysstring, long len, Int64 bytes_read, Int64 bytes_written)

Converts a string which is in the encoding used for strings by
the C runtime (usually the same as that used by the operating
system) in the [current locale][setlocale] into a UTF-8 string.

static void

log(Str log_domain, int log_level, Str format, Object... _elipse)

Logs an error or debugging message.

static void

logDefaultHandler(Str log_domain, int log_level, Str message, Pointer unused_data)

The default log handler set up by GLib; g_log_set_default_handler()
allows to install an alternate default log handler.

static boolean

logGetDebugEnabled()

Return whether debug output from the GLib logging system is enabled.

static void

logRemoveHandler(Str log_domain, int handler_id)

Removes the log handler.

static int

logSetAlwaysFatal(int fatal_mask)

Sets the message levels which are always fatal, in any log domain.

static void

logSetDebugEnabled(boolean enabled)

Enable or disable debug output from the GLib logging system for all domains.

static int

logSetFatalMask(Str log_domain, int fatal_mask)

Sets the log levels which are fatal in the given domain.

static int

logSetHandler(Str log_domain, int log_levels, Glib.OnLogFunc log_func, Pointer user_data)

Sets the log handler for a domain and a set of log levels.

static int

logSetHandlerFull(Str log_domain, int log_levels, Glib.OnLogFunc log_func, Pointer user_data, Glib.OnDestroyNotify destroy)

Like g_log_set_handler(), but takes a destroy notify for the @user_data.

static void

logStructured(Str log_domain, int log_level, Object... _elipse)

Log a message with structured data.

static void

logStructuredStandard(Str log_domain, int log_level, Str file, Str line, Str func, Str message_format, Object... _elipse)

static void

logVariant(Str log_domain, int log_level, Variant fields)

Log a message with structured data, accepting the data within a #GVariant.

static void

logWriterDefaultSetUseStderr(boolean use_stderr)

Configure whether the built-in log functions
(g_log_default_handler() for the old-style API, and both
g_log_writer_default() and g_log_writer_standard_streams() for the
structured API) will output all log messages to `stderr`.

static boolean

logWriterDefaultWouldDrop(int log_level, Str log_domain)

Check whether g_log_writer_default() and g_log_default_handler() would
ignore a message with the given domain and level.

static boolean

logWriterIsJournald(int output_fd)

Check whether the given @output_fd file descriptor is a connection to the
systemd journal, or something else (like a log file or `stdout` or
`stderr`).

static boolean

logWriterSupportsColor(int output_fd)

Check whether the given @output_fd file descriptor supports ANSI color
escape sequences.

static MainContext

mainContextDefault()

Returns the global default main context.

static MainContext

mainContextGetThreadDefault()

Gets the thread-default #GMainContext for this thread.

static MainContext

mainContextRefThreadDefault()

Gets the thread-default #GMainContext for this thread, as with
g_main_context_get_thread_default(), but also adds a reference to
it with g_main_context_ref().

static Source

mainCurrentSource()

Returns the currently firing source for this thread.

static int

mainDepth()

Returns the depth of the stack of calls to
g_main_context_dispatch() on any #GMainContext in the current thread.

static Pointer

malloc(long n_bytes)

Allocates @n_bytes bytes of memory.

static Pointer

malloc0(long n_bytes)

Allocates @n_bytes bytes of memory, initialized to 0's.

static Pointer

malloc0N(long n_blocks, long n_block_bytes)

This function is similar to g_malloc0(), allocating (@n_blocks * @n_block_bytes) bytes,
but care is taken to detect possible overflow during multiplication.

static Pointer

mallocN(long n_blocks, long n_block_bytes)

This function is similar to g_malloc(), allocating (@n_blocks * @n_block_bytes) bytes,
but care is taken to detect possible overflow during multiplication.

static int

markupErrorQuark()

static Str

markupEscapeText(Str text, long length)

Escapes text so that the markup parser will parse it verbatim.

static Str

markupPrintfEscaped(Str format, Object... _elipse)

Formats arguments according to @format, escaping
all string and character arguments in the fashion
of g_markup_escape_text().

static Pointer

memdup2(Pointer mem, long byte_size)

Allocates @byte_size bytes of memory, and copies @byte_size bytes into it
from @mem.

static int

mkdirWithParents(Str pathname, int mode)

Create a directory if it doesn't already exist.

static Str

mkdtemp(Str tmpl)

Creates a temporary directory.

static Str

mkdtempFull(Str tmpl, int mode)

Creates a temporary directory.

static int

mkstemp(Str tmpl)

Opens a temporary file.

static int

mkstempFull(Str tmpl, int flags, int mode)

Opens a temporary file.

static int

numberParserErrorQuark()

static boolean

onceInitEnter(Pointer location)

Function to be called when starting a critical initialization
section.

static void

onceInitLeave(Pointer location, long result)

Counterpart to g_once_init_enter().

static void

onErrorQuery(Str prg_name)

Prompts the user with
`[E]xit, [H]alt, show [S]tack trace or [P]roceed`.

static void

onErrorStackTrace(Str prg_name)

Invokes gdb, which attaches to the current process and shows a
stack trace.

static int

optionErrorQuark()

static Str

pathGetBasename(Str file_name)

Gets the last component of the filename.

static Str

pathGetDirname(Str file_name)

Gets the directory components of a file name.

static boolean

pathIsAbsolute(Str file_name)

Returns %TRUE if the given @file_name is an absolute file name.

static Str

pathSkipRoot(Str file_name)

Returns a pointer into @file_name after the root component,
i.e. after the "/" in UNIX or "C:\" under Windows.

static boolean

patternMatchSimple(Str pattern, Str string)

Matches a string against a pattern given as a string.

static void

pointerBitLock(Pointer address, int lock_bit)

This is equivalent to g_bit_lock, but working on pointers (or other
pointer-sized values).

static boolean

pointerBitTrylock(Pointer address, int lock_bit)

This is equivalent to g_bit_trylock(), but working on pointers (or
other pointer-sized values).

static void

pointerBitUnlock(Pointer address, int lock_bit)

This is equivalent to g_bit_unlock, but working on pointers (or other
pointer-sized values).

static int

poll(PollFD fds, int nfds, int timeout)

Polls @fds, as with the poll() system call, but portably.

static void

print(Str format, Object... _elipse)

Outputs a formatted message via the print handler.

static void

printerr(Str format, Object... _elipse)

Outputs a formatted message via the error message handler.

static int

printf(Str format, Object... _elipse)

An implementation of the standard printf() function which supports
positional parameters, as specified in the Single Unix Specification.

static void

qsortWithData(Pointer pbase, int total_elems, long size, Glib.OnCompareDataFunc compare_func, Pointer user_data)

This is just like the standard C qsort() function, but
the comparison routine accepts a user data argument.

static int

quarkFromStaticString(Str string)

Gets the #GQuark identifying the given (static) string.

static int

quarkFromString(Str string)

Gets the #GQuark identifying the given string.

static Str

quarkToString(int quark)

Gets the string associated with the given #GQuark.

static int

quarkTryString(Str string)

Gets the #GQuark associated with the given string, or 0 if string is
%NULL or it has no associated #GQuark.

static double

randomDouble()

Returns a random #gdouble equally distributed over the range [0..1).

static double

randomDoubleRange(double begin, double end)

Returns a random #gdouble equally distributed over the range
[@begin..@end).

static int

randomInt()

Return a random #guint32 equally distributed over the range
[0..2^32-1].

static int

randomIntRange(int begin, int end)

Returns a random #gint32 equally distributed over the range
[@begin..@end-1].

static void

randomSetSeed(int seed)

Sets the seed for the global random number generator, which is used
by the g_random_* functions, to @seed.

static Pointer

rcBoxAcquire(Pointer mem_block)

Acquires a reference on the data pointed by @mem_block.

static Pointer

rcBoxAlloc(long block_size)

Allocates @block_size bytes of memory, and adds reference
counting semantics to it.

static Pointer

rcBoxAlloc0(long block_size)

Allocates @block_size bytes of memory, and adds reference
counting semantics to it.

static Pointer

rcBoxDup(long block_size, Pointer mem_block)

Allocates a new block of data with reference counting
semantics, and copies @block_size bytes of @mem_block
into it.

static long

rcBoxGetSize(Pointer mem_block)

Retrieves the size of the reference counted data pointed by @mem_block.

static void

rcBoxRelease(Pointer mem_block)

Releases a reference on the data pointed by @mem_block.

static void

rcBoxReleaseFull(Pointer mem_block, Glib.OnDestroyNotify clear_func)

Releases a reference on the data pointed by @mem_block.

static Pointer

realloc(Pointer mem, long n_bytes)

Reallocates the memory pointed to by @mem, so that it now has space for
@n_bytes bytes of memory.

static Pointer

reallocN(Pointer mem, long n_blocks, long n_block_bytes)

This function is similar to g_realloc(), allocating (@n_blocks * @n_block_bytes) bytes,
but care is taken to detect possible overflow during multiplication.

static Str

refStringAcquire(Str str)

Acquires a reference on a string.

static long

refStringLength(Str str)

Retrieves the length of @str.

static Str

refStringNew(Str str)

Creates a new reference counted string and copies the contents of @str
into it.

static Str

refStringNewIntern(Str str)

Creates a new reference counted string and copies the content of @str
into it.

static Str

refStringNewLen(Str str, long len)

Creates a new reference counted string and copies the contents of @str
into it, up to @len bytes.

static void

refStringRelease(Str str)

Releases a reference on a string; if it was the last reference, the
resources allocated by the string are freed as well.

static boolean

regexCheckReplacement(Str replacement, Int has_references)

Checks whether @replacement is a valid replacement string
(see g_regex_replace()), i.e. that all escape sequences in
it are valid.

static int

regexErrorQuark()

static Str

regexEscapeNul(Str string, int length)

Escapes the nul characters in @string to "\x00".

static Str

regexEscapeString(Str string, int length)

Escapes the special characters used for regular expressions
in @string, for instance "a.b*c" becomes "a\.b\*c".

static boolean

regexMatchSimple(Str pattern, Str string, int compile_options, int match_options)

Scans for a match in @string for @pattern.

static void

reloadUserSpecialDirsCache()

Resets the cache used for g_get_user_special_dir(), so
that the latest on-disk version is used.

static void

returnIfFailWarning(Str log_domain, Str pretty_function, Str expression)

Internal function used to print messages from the public g_return_if_fail()
and g_return_val_if_fail() macros.

static int

rmdir(Str filename)

A wrapper for the POSIX rmdir() function.

static Pointer

sequenceGet(ch.bailu.gtk.glib.SequenceIter iter)

Returns the data that @iter points to.

static ch.bailu.gtk.glib.SequenceIter

sequenceInsertBefore(ch.bailu.gtk.glib.SequenceIter iter, Pointer data)

Inserts a new item just before the item pointed to by @iter.

static void

sequenceMove(ch.bailu.gtk.glib.SequenceIter src, ch.bailu.gtk.glib.SequenceIter dest)

Moves the item pointed to by @src to the position indicated by @dest.

static void

sequenceMoveRange(ch.bailu.gtk.glib.SequenceIter dest, ch.bailu.gtk.glib.SequenceIter begin, ch.bailu.gtk.glib.SequenceIter end)

Inserts the (@begin, @end) range at the destination pointed to by @dest.

static ch.bailu.gtk.glib.SequenceIter

sequenceRangeGetMidpoint(ch.bailu.gtk.glib.SequenceIter begin, ch.bailu.gtk.glib.SequenceIter end)

Finds an iterator somewhere in the range (@begin, @end).

static void

sequenceRemove(ch.bailu.gtk.glib.SequenceIter iter)

Removes the item pointed to by @iter.

static void

sequenceRemoveRange(ch.bailu.gtk.glib.SequenceIter begin, ch.bailu.gtk.glib.SequenceIter end)

Removes all items in the (@begin, @end) range.

static void

sequenceSet(ch.bailu.gtk.glib.SequenceIter iter, Pointer data)

Changes the data for the item pointed to by @iter to be @data.

static void

sequenceSwap(ch.bailu.gtk.glib.SequenceIter a, ch.bailu.gtk.glib.SequenceIter b)

Swaps the items pointed to by @a and @b.

static void

setApplicationName(Str application_name)

Sets a human-readable name for the application.

static boolean

setenv(Str variable, Str value, boolean overwrite)

Sets an environment variable.

static void

setPrgname(Str prgname)

Sets the name of the program.

static int

shellErrorQuark()

static Str

shellQuote(Str unquoted_string)

Quotes a string so that the shell (/bin/sh) will interpret the
quoted string to mean @unquoted_string.

static Str

shellUnquote(Str quoted_string)

Unquotes a string as the shell (/bin/sh) would.

static Pointer

sliceAlloc(long block_size)

Allocates a block of memory from the slice allocator.

static Pointer

sliceAlloc0(long block_size)

Allocates a block of memory via g_slice_alloc() and initializes
the returned memory to 0.

static Pointer

sliceCopy(long block_size, Pointer mem_block)

Allocates a block of memory from the slice allocator
and copies @block_size bytes into it from @mem_block.

static void

sliceFree1(long block_size, Pointer mem_block)

Frees a block of memory.

static void

sliceFreeChainWithOffset(long block_size, Pointer mem_chain, long next_offset)

Frees a linked list of memory blocks of structure type @type.

static long

sliceGetConfig(int ckey)

static void

sliceSetConfig(int ckey, long value)

static int

snprintf(Str string, long n, Str format, Object... _elipse)

A safer form of the standard sprintf() function.

static boolean

sourceRemove(int tag)

Removes the source with the given ID from the default main context.

static boolean

sourceRemoveByFuncsUserData(SourceFuncs funcs, Pointer user_data)

Removes a source from the default main loop context given the
source functions and user data.

static boolean

sourceRemoveByUserData(Pointer user_data)

Removes a source from the default main loop context given the user
data for the callback.

static void

sourceSetNameById(int tag, Str name)

Sets the name of a source using its ID.

static int

spacedPrimesClosest(int num)

Gets the smallest prime number from a built-in array of primes which
is larger than @num.

static boolean

spawnCheckWaitStatus(int wait_status)

Set @error if @wait_status indicates the child exited abnormally
(e.g. with a nonzero exit code, or via a fatal signal).

static boolean

spawnCommandLineAsync(Str command_line)

A simple version of g_spawn_async() that parses a command line with
g_shell_parse_argv() and passes it to g_spawn_async().

static int

spawnErrorQuark()

static int

spawnExitErrorQuark()

static int

sprintf(Str string, Str format, Object... _elipse)

An implementation of the standard sprintf() function which supports
positional parameters, as specified in the Single Unix Specification.

static Str

stpcpy(Str dest, Str src)

Copies a nul-terminated string into the dest buffer, include the
trailing nul, and return a pointer to the trailing nul byte.

static Str

strcanon(Str string, Str valid_chars, byte substitutor)

For each character in @string, if the character is not in @valid_chars,
replaces the character with @substitutor.

static Str

strchomp(Str string)

Removes trailing whitespace from a string.

static Str

strchug(Str string)

Removes leading whitespace from a string, by moving the rest
of the characters forward.

static int

strcmp0(Str str1, Str str2)

Compares @str1 and @str2 like strcmp().

static Str

strcompress(Str source)

Replaces all escaped characters with their one byte equivalent.

static Str

strconcat(Str string1, Object... _elipse)

Concatenates all of the given strings into one long string.

static Str

strdelimit(Str string, Str delimiters, byte new_delimiter)

Converts any delimiter characters in @string to @new_delimiter.

static Str

strdup(Str str)

Duplicates a string.

static Str

strdupPrintf(Str format, Object... _elipse)

Similar to the standard C sprintf() function but safer, since it
calculates the maximum space required and allocates memory to hold
the result.

static boolean

strEqual(Pointer v1, Pointer v2)

Compares two strings for byte-by-byte equality and returns %TRUE
if they are equal.

static Str

strerror(int errnum)

Returns a string corresponding to the given error code, e.g.

static Str

strescape(Str source, Str exceptions)

Escapes the special characters '\b', '\f', '\n', '\r', '\t', '\v', '\'
and '"' in the string @source by inserting a '\' before
them.

static int

strHash(Pointer v)

Converts a string to a hash value.

static boolean

strHasPrefix(Str str, Str prefix)

Looks whether the string @str begins with @prefix.

static boolean

strHasSuffix(Str str, Str suffix)

Looks whether the string @str ends with @suffix.

static Str

stripContext(Str msgid, Str msgval)

An auxiliary function for gettext() support (see Q_()).

static boolean

strIsAscii(Str str)

Determines if a string is pure ASCII.

static Str

strjoin(Str separator, Object... _elipse)

Joins a number of strings together to form one long string, with the
optional @separator inserted between each of them.

static long

strlcat(Str dest, Str src, long dest_size)

Portability wrapper that calls strlcat() on systems which have it,
and emulates it otherwise.

static long

strlcpy(Str dest, Str src, long dest_size)

Portability wrapper that calls strlcpy() on systems which have it,
and emulates strlcpy() otherwise.

static boolean

strMatchString(Str search_term, Str potential_hit, boolean accept_alternates)

Checks if a search conducted for @search_term should match
@potential_hit.

static Str

strndup(Str str, long n)

Duplicates the first @n bytes of a string, returning a newly-allocated
buffer @n + 1 bytes long which will always be nul-terminated.

static Str

strnfill(long length, byte fill_char)

Creates a new string @length bytes long filled with @fill_char.

static Str

strreverse(Str string)

Reverses all of the bytes in a string.

static Str

strrstr(Str haystack, Str needle)

Searches the string @haystack for the last occurrence
of the string @needle.

static Str

strrstrLen(Str haystack, long haystack_len, Str needle)

Searches the string @haystack for the last occurrence
of the string @needle, limiting the length of the search
to @haystack_len.

static Str

strsignal(int signum)

Returns a string describing the given signal, e.g.

static Str

strstrLen(Str haystack, long haystack_len, Str needle)

Searches the string @haystack for the first occurrence
of the string @needle, limiting the length of the search
to @haystack_len.

static Str

strToAscii(Str str, Str from_locale)

Transliterate @str to plain ASCII.

static long

strvGetType()

static void

testAddDataFunc(Str testpath, Pointer test_data, Glib.OnTestDataFunc test_func)

Create a new test case, similar to g_test_create_case().

static void

testAddDataFuncFull(Str testpath, Pointer test_data, Glib.OnTestDataFunc test_func, Glib.OnDestroyNotify data_free_func)

Create a new test case, as with g_test_add_data_func(), but freeing
@test_data after the test run is complete.

static void

testAddFunc(Str testpath, Glib.OnTestFunc test_func)

Create a new test case, similar to g_test_create_case().

static void

testAddVtable(Str testpath, long data_size, Pointer test_data, Glib.OnTestFixtureFunc data_setup, Glib.OnTestFixtureFunc data_test, Glib.OnTestFixtureFunc data_teardown)

static void

testAssertExpectedMessagesInternal(Str domain, Str file, int line, Str func)

static void

testBug(Str bug_uri_snippet)

This function adds a message to test reports that
associates a bug URI with a test case.

static void

testBugBase(Str uri_pattern)

Specify the base URI for bug reports.

static Str

testBuildFilename(int file_type, Str first_path, Object... _elipse)

Creates the pathname to a data file that is required for a test.

static ch.bailu.gtk.glib.TestCase

testCreateCase(Str test_name, long data_size, Pointer test_data, Glib.OnTestFixtureFunc data_setup, Glib.OnTestFixtureFunc data_test, Glib.OnTestFixtureFunc data_teardown)

Create a new #GTestCase, named @test_name.

static ch.bailu.gtk.glib.TestSuite

testCreateSuite(Str suite_name)

Create a new test suite with the name @suite_name.

static void

testExpectMessage(Str log_domain, int log_level, Str pattern)

Indicates that a message with the given @log_domain and @log_level,
with text matching @pattern, is expected to be logged.

static void

testFail()

Indicates that a test failed.

static boolean

testFailed()

Returns whether a test has already failed.

static void

testFailPrintf(Str format, Object... _elipse)

Equivalent to g_test_fail(), but also record a message like
g_test_skip_printf().

static Str

testGetDir(int file_type)

Gets the pathname of the directory containing test files of the type
specified by @file_type.

static Str

testGetFilename(int file_type, Str first_path, Object... _elipse)

Gets the pathname to a data file that is required for a test.

static Str

testGetPath()

Gets the test path for the test currently being run.

static ch.bailu.gtk.glib.TestSuite

testGetRoot()

Get the toplevel test suite for the test path API.

static void

testIncomplete(Str msg)

Indicates that a test failed because of some incomplete
functionality.

static void

testIncompletePrintf(Str format, Object... _elipse)

Equivalent to g_test_incomplete(), but the explanation is formatted
as if by g_strdup_printf().

static void

testLogSetFatalHandler(Glib.OnTestLogFatalFunc log_func, Pointer user_data)

Installs a non-error fatal log handler which can be
used to decide whether log messages which are counted
as fatal abort the program.

static Str

testLogTypeName(int log_type)

static void

testMaximizedResult(double maximized_quantity, Str format, Object... _elipse)

Report the result of a performance or measurement test.

static void

testMessage(Str format, Object... _elipse)

Add a message to the test report.

static void

testMinimizedResult(double minimized_quantity, Str format, Object... _elipse)

Report the result of a performance or measurement test.

static void

testQueueDestroy(Glib.OnDestroyNotify destroy_func, Pointer destroy_data)

This function enqueus a callback @destroy_func to be executed
during the next test case teardown phase.

static void

testQueueFree(Pointer gfree_pointer)

Enqueue a pointer to be released with g_free() during the next
teardown phase.

static double

testRandDouble()

Get a reproducible random floating point number,
see g_test_rand_int() for details on test case random numbers.

static double

testRandDoubleRange(double range_start, double range_end)

Get a reproducible random floating pointer number out of a specified range,
see g_test_rand_int() for details on test case random numbers.

static int

testRandInt()

Get a reproducible random integer number.

static int

testRandIntRange(int begin, int end)

Get a reproducible random integer number out of a specified range,
see g_test_rand_int() for details on test case random numbers.

static int

testRun()

Runs all tests under the toplevel suite which can be retrieved
with g_test_get_root().

static int

testRunSuite(ch.bailu.gtk.glib.TestSuite suite)

Execute the tests within @suite and all nested #GTestSuites.

static void

testSetNonfatalAssertions()

Changes the behaviour of the various `g_assert_*()` macros,
g_test_assert_expected_messages() and the various
`g_test_trap_assert_*()` macros to not abort to program, but instead
call g_test_fail() and continue.

static void

testSkip(Str msg)

Indicates that a test was skipped.

static void

testSkipPrintf(Str format, Object... _elipse)

Equivalent to g_test_skip(), but the explanation is formatted
as if by g_strdup_printf().

static boolean

testSubprocess()

Returns %TRUE (after g_test_init() has been called) if the test
program is running under g_test_trap_subprocess().

static void

testSummary(Str summary)

Set the summary for a test, which describes what the test checks, and how it
goes about checking it.

static double

testTimerElapsed()

Get the number of seconds since the last start of the timer with
g_test_timer_start().

static double

testTimerLast()

Report the last result of g_test_timer_elapsed().

static void

testTimerStart()

Start a timing test.

static void

testTrapAssertions(Str domain, Str file, int line, Str func, long assertion_flags, Str pattern)

static boolean

testTrapHasPassed()

Check the result of the last g_test_trap_subprocess() call.

static boolean

testTrapReachedTimeout()

Check the result of the last g_test_trap_subprocess() call.

static void

testTrapSubprocess(Str test_path, long usec_timeout, int test_flags)

Respawns the test program to run only @test_path in a subprocess.

static int

threadErrorQuark()

static void

threadExit(Pointer retval)

Terminates the current thread.

static int

threadPoolGetMaxIdleTime()

This function will return the maximum @interval that a
thread will wait in the thread pool for new tasks before
being stopped.

static int

threadPoolGetMaxUnusedThreads()

Returns the maximal allowed number of unused threads.

static int

threadPoolGetNumUnusedThreads()

Returns the number of currently unused threads.

static void

threadPoolSetMaxIdleTime(int interval)

This function will set the maximum @interval that a thread
waiting in the pool for new tasks can be idle for before
being stopped.

static void

threadPoolSetMaxUnusedThreads(int max_threads)

Sets the maximal number of unused threads to @max_threads.

static void

threadPoolStopUnusedThreads()

Stops all currently unused threads.

static Thread

threadSelf()

This function returns the #GThread corresponding to the
current thread.

static void

threadYield()

Causes the calling thread to voluntarily relinquish the CPU, so
that other threads can run.

static int

timeoutAdd(int interval, Glib.OnSourceFunc function, Pointer data)

Sets a function to be called at regular intervals, with the default
priority, %G_PRIORITY_DEFAULT.

static int

timeoutAddFull(int priority, int interval, Glib.OnSourceFunc function, Pointer data, Glib.OnDestroyNotify notify)

Sets a function to be called at regular intervals, with the given
priority.

static int

timeoutAddOnce(int interval, Glib.OnSourceOnceFunc function, Pointer data)

Sets a function to be called after @interval milliseconds have elapsed,
with the default priority, %G_PRIORITY_DEFAULT.

static int

timeoutAddSeconds(int interval, Glib.OnSourceFunc function, Pointer data)

Sets a function to be called at regular intervals with the default
priority, %G_PRIORITY_DEFAULT.

static int

timeoutAddSecondsFull(int priority, int interval, Glib.OnSourceFunc function, Pointer data, Glib.OnDestroyNotify notify)

Sets a function to be called at regular intervals, with @priority.

static Source

timeoutSourceNew(int interval)

Creates a new timeout source.

static Source

timeoutSourceNewSeconds(int interval)

Creates a new timeout source.

static Pointer

tryMalloc(long n_bytes)

Attempts to allocate @n_bytes, and returns %NULL on failure.

static Pointer

tryMalloc0(long n_bytes)

Attempts to allocate @n_bytes, initialized to 0's, and returns %NULL on
failure.

static Pointer

tryMalloc0N(long n_blocks, long n_block_bytes)

This function is similar to g_try_malloc0(), allocating (@n_blocks * @n_block_bytes) bytes,
but care is taken to detect possible overflow during multiplication.

static Pointer

tryMallocN(long n_blocks, long n_block_bytes)

This function is similar to g_try_malloc(), allocating (@n_blocks * @n_block_bytes) bytes,
but care is taken to detect possible overflow during multiplication.

static Pointer

tryRealloc(Pointer mem, long n_bytes)

Attempts to realloc @mem to a new size, @n_bytes, and returns %NULL
on failure.

static Pointer

tryReallocN(Pointer mem, long n_blocks, long n_block_bytes)

This function is similar to g_try_realloc(), allocating (@n_blocks * @n_block_bytes) bytes,
but care is taken to detect possible overflow during multiplication.

static int

unicharBreakType(byte c)

Determines the break type of @c.

static int

unicharCombiningClass(byte uc)

Determines the canonical combining class of a Unicode character.

static int

unicharDigitValue(byte c)

Determines the numeric value of a character as a decimal
digit.

static int

unicharGetScript(byte ch)

Looks up the #GUnicodeScript for a particular character (as defined
by Unicode Standard Annex \#24).

static boolean

unicharIsalnum(byte c)

Determines whether a character is alphanumeric.

static boolean

unicharIsalpha(byte c)

Determines whether a character is alphabetic (i.e. a letter).

static boolean

unicharIscntrl(byte c)

Determines whether a character is a control character.

static boolean

unicharIsdefined(byte c)

Determines if a given character is assigned in the Unicode
standard.

static boolean

unicharIsdigit(byte c)

Determines whether a character is numeric (i.e. a digit).

static boolean

unicharIsgraph(byte c)

Determines whether a character is printable and not a space
(returns %FALSE for control characters, format characters, and
spaces). g_unichar_isprint() is similar, but returns %TRUE for
spaces.

static boolean

unicharIslower(byte c)

Determines whether a character is a lowercase letter.

static boolean

unicharIsmark(byte c)

Determines whether a character is a mark (non-spacing mark,
combining mark, or enclosing mark in Unicode speak).

static boolean

unicharIsprint(byte c)

Determines whether a character is printable.

static boolean

unicharIspunct(byte c)

Determines whether a character is punctuation or a symbol.

static boolean

unicharIsspace(byte c)

Determines whether a character is a space, tab, or line separator
(newline, carriage return, etc.).

static boolean

unicharIstitle(byte c)

Determines if a character is titlecase.

static boolean

unicharIsupper(byte c)

Determines if a character is uppercase.

static boolean

unicharIswide(byte c)

Determines if a character is typically rendered in a double-width
cell.

static boolean

unicharIswideCjk(byte c)

Determines if a character is typically rendered in a double-width
cell under legacy East Asian locales.

static boolean

unicharIsxdigit(byte c)

Determines if a character is a hexadecimal digit.

static boolean

unicharIszerowidth(byte c)

Determines if a given character typically takes zero width when rendered.

static byte

unicharTolower(byte c)

Converts a character to lower case.

static byte

unicharTotitle(byte c)

Converts a character to the titlecase.

static byte

unicharToupper(byte c)

Converts a character to uppercase.

static int

unicharToUtf8(byte c, Str outbuf)

Converts a single character to UTF-8.

static int

unicharType(byte c)

Classifies a Unicode character by type.

static boolean

unicharValidate(byte ch)

Checks whether @ch is a valid Unicode character.

static int

unicharXdigitValue(byte c)

Determines the numeric value of a character as a hexadecimal
digit.

static int

unicodeScriptFromIso15924(int iso15924)

Looks up the Unicode script for @iso15924.

static int

unicodeScriptToIso15924(int script)

Looks up the ISO 15924 code for @script.

static int

unixErrorQuark()

static int

unixFdAdd(int fd, int condition, Glib.OnUnixFDSourceFunc function, Pointer user_data)

Sets a function to be called when the IO condition, as specified by
@condition becomes true for @fd.

static int

unixFdAddFull(int priority, int fd, int condition, Glib.OnUnixFDSourceFunc function, Pointer user_data, Glib.OnDestroyNotify notify)

Sets a function to be called when the IO condition, as specified by
@condition becomes true for @fd.

static Source

unixFdSourceNew(int fd, int condition)

Creates a #GSource to watch for a particular IO condition on a file
descriptor.

static boolean

unixOpenPipe(Int fds, int flags)

Similar to the UNIX pipe() call, but on modern systems like Linux
uses the pipe2() system call, which atomically creates a pipe with
the configured flags.

static boolean

unixSetFdNonblocking(int fd, boolean nonblock)

Control the non-blocking state of the given file descriptor,
according to @nonblock.

static int

unixSignalAdd(int signum, Glib.OnSourceFunc handler, Pointer user_data)

A convenience function for g_unix_signal_source_new(), which
attaches to the default #GMainContext.

static int

unixSignalAddFull(int priority, int signum, Glib.OnSourceFunc handler, Pointer user_data, Glib.OnDestroyNotify notify)

A convenience function for g_unix_signal_source_new(), which
attaches to the default #GMainContext.

static Source

unixSignalSourceNew(int signum)

Create a #GSource that will be dispatched upon delivery of the UNIX
signal @signum.

static int

unlink(Str filename)

A wrapper for the POSIX unlink() function.

static void

unsetenv(Str variable)

Removes an environment variable from the environment.

static Uri

uriBuild(int flags, Str scheme, Str userinfo, Str host, int port, Str path, Str query, Str fragment)

Creates a new #GUri from the given components according to @flags.

static Uri

uriBuildWithUser(int flags, Str scheme, Str user, Str password, Str auth_params, Str host, int port, Str path, Str query, Str fragment)

Creates a new #GUri from the given components according to @flags
(%G_URI_FLAGS_HAS_PASSWORD is added unconditionally).

static int

uriErrorQuark()

static Str

uriEscapeString(Str unescaped, Str reserved_chars_allowed, boolean allow_utf8)

Escapes a string for use in a URI.

static boolean

uriIsValid(Str uri_string, int flags)

Parses @uri_string according to @flags, to determine whether it is a valid
[absolute URI][relative-absolute-uris], i.e. it does not need to be resolved
relative to another URI using g_uri_parse_relative().

static Str

uriJoin(int flags, Str scheme, Str userinfo, Str host, int port, Str path, Str query, Str fragment)

Joins the given components together according to @flags to create
an absolute URI string.

static Str

uriJoinWithUser(int flags, Str scheme, Str user, Str password, Str auth_params, Str host, int port, Str path, Str query, Str fragment)

Joins the given components together according to @flags to create
an absolute URI string.

static Uri

uriParse(Str uri_string, int flags)

Parses @uri_string according to @flags.

static HashTable

uriParseParams(Str params, long length, Str separators, int flags)

Many URI schemes include one or more attribute/value pairs as part of the URI
value.

static Str

uriParseScheme(Str uri)

Gets the scheme portion of a URI string.

static Str

uriPeekScheme(Str uri)

Gets the scheme portion of a URI string.

static Str

uriResolveRelative(Str base_uri_string, Str uri_ref, int flags)

Parses @uri_ref according to @flags and, if it is a
[relative URI][relative-absolute-uris], resolves it relative to
@base_uri_string.

static Bytes

uriUnescapeBytes(Str escaped_string, long length, Str illegal_characters)

Unescapes a segment of an escaped string as binary data.

static Str

uriUnescapeSegment(Str escaped_string, Str escaped_string_end, Str illegal_characters)

Unescapes a segment of an escaped string.

static Str

uriUnescapeString(Str escaped_string, Str illegal_characters)

Unescapes a whole escaped string.

static void

usleep(long microseconds)

Pauses the current thread for the given number of microseconds.

static Str

utf8Casefold(Str str, long len)

Converts a string into a form that is independent of case.

static int

utf8Collate(Str str1, Str str2)

Compares two strings for ordering using the linguistically
correct rules for the [current locale][setlocale].

static Str

utf8CollateKey(Str str, long len)

Converts a string into a collation key that can be compared
with other collation keys produced by the same function using
strcmp().

static Str

utf8CollateKeyForFilename(Str str, long len)

Converts a string into a collation key that can be compared
with other collation keys produced by the same function using strcmp().

static Str

utf8FindNextChar(Str p, Str end)

Finds the start of the next UTF-8 character in the string after @p.

static Str

utf8FindPrevChar(Str str, Str p)

Given a position @p with a UTF-8 encoded string @str, find the start
of the previous UTF-8 character starting before @p.

static byte

utf8GetChar(Str p)

Converts a sequence of bytes encoded as UTF-8 to a Unicode character.

static byte

utf8GetCharValidated(Str p, long max_len)

Convert a sequence of bytes encoded as UTF-8 to a Unicode character.

static Str

utf8MakeValid(Str str, long len)

If the provided string is valid UTF-8, return a copy of it.

static Str

utf8Normalize(Str str, long len, int mode)

Converts a string into canonical form, standardizing
such issues as whether a character with an accent
is represented as a base character and combining
accent or as a single precomposed character.

static Str

utf8OffsetToPointer(Str str, long offset)

Converts from an integer character offset to a pointer to a position
within the string.

static long

utf8PointerToOffset(Str str, Str pos)

Converts from a pointer to position within a string to an integer
character offset.

static Str

utf8PrevChar(Str p)

Finds the previous UTF-8 character in the string before @p.

static Str

utf8Strchr(Str p, long len, byte c)

Finds the leftmost occurrence of the given Unicode character
in a UTF-8 encoded string, while limiting the search to @len bytes.

static Str

utf8Strdown(Str str, long len)

Converts all Unicode characters in the string that have a case
to lowercase.

static long

utf8Strlen(Str p, long max)

Computes the length of the string in characters, not including
the terminating nul character.

static Str

utf8Strncpy(Str dest, Str src, long n)

Like the standard C strncpy() function, but copies a given number
of characters instead of a given number of bytes.

static Str

utf8Strrchr(Str p, long len, byte c)

Find the rightmost occurrence of the given Unicode character
in a UTF-8 encoded string, while limiting the search to @len bytes.

static Str

utf8Strreverse(Str str, long len)

Reverses a UTF-8 string.

static Str

utf8Strup(Str str, long len)

Converts all Unicode characters in the string that have a case
to uppercase.

static Str

utf8Substring(Str str, long start_pos, long end_pos)

Copies a substring out of a UTF-8 encoded string.

static boolean

uuidStringIsValid(Str str)

Parses the string @str and verify if it is a UUID.

static Str

uuidStringRandom()

Generates a random UUID (RFC 4122 version 4) as a string.

static long

variantGetGtype()

static boolean

variantIsObjectPath(Str string)

Determines if a given string is a valid D-Bus object path.

static boolean

variantIsSignature(Str string)

Determines if a given string is a valid D-Bus type signature.

static Str

variantParseErrorPrintContext(Error error, Str source_str)

Pretty-prints a message showing the context of a #GVariant parse
error within the string for which parsing was attempted.

static int

variantParseErrorQuark()

static VariantType

variantTypeChecked(Str arg0)

static long

variantTypeStringGetDepth(Str type_string)

static boolean

variantTypeStringIsValid(Str type_string)

Checks if @type_string is a valid GVariant type string.

static void

warnMessage(Str domain, Str file, int line, Str func, Str warnexpr)

Internal function used to print messages from the public g_warn_if_reached()
and g_warn_if_fail() macros.

Methods inherited from class ch.bailu.gtk.type.Type
asCPointer, asCPointer, asCPointerNotNull, asJnaPointer, asJnaPointer, asPointer, asPointer, cast, cast, throwIfNull

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details
- Glib
  
  public Glib()
Method Details
- getClassHandler
  
  public static ClassHandler getClassHandler()
- access
  
  public static int access(@Nonnull Str filename, int mode)
  
  A wrapper for the POSIX access() function. This function is used to
  test a pathname for one or several of read, write or execute
  permissions, or just existence.
  
  On Windows, the file protection mechanism is not at all POSIX-like,
  and the underlying function in the C library only checks the
  FAT-style READONLY attribute, and does not look at the ACL of a
  file at all. This function is this in practise almost useless on
  Windows. Software that needs to handle file permissions on Windows
  more exactly should use the Win32 API.
  
  See your C library manual for more details about access().
  
  Parameters:
  
  filename - a pathname in the GLib file name encoding (UTF-8 on Windows)
  
  mode - as in access()
  
  Returns:
  
  zero if the pathname refers to an existing file system object that has all the tested permissions, or -1 otherwise or on error.
- alignedAlloc
  
  public static Pointer alignedAlloc(long n_blocks, long n_block_bytes, long alignment)
  
  This function is similar to g_malloc(), allocating (@n_blocks * @n_block_bytes)
  bytes, but care is taken to align the allocated memory to with the given
  alignment value. Additionally, it will detect possible overflow during
  multiplication.
  
  If the allocation fails (because the system is out of memory),
  the program is terminated.
  
  Aligned memory allocations returned by this function can only be
  freed using g_aligned_free().
  
  Parameters:
  
  n_blocks - the number of blocks to allocate
  
  n_block_bytes - the size of each block in bytes
  
  alignment - the alignment to be enforced, which must be a positive power of 2 and a multiple of `sizeof(void*)`
  
  Returns:
  
  the allocated memory
- alignedAlloc0
  
  public static Pointer alignedAlloc0(long n_blocks, long n_block_bytes, long alignment)
  
  This function is similar to g_aligned_alloc(), but it will
  also clear the allocated memory before returning it.
  
  Parameters:
  
  n_blocks - the number of blocks to allocate
  
  n_block_bytes - the size of each block in bytes
  
  alignment - the alignment to be enforced, which must be a positive power of 2 and a multiple of `sizeof(void*)`
  
  Returns:
  
  the allocated, cleared memory
- alignedFree
  
  public static void alignedFree(@Nullable Pointer mem)
  
  Frees the memory allocated by g_aligned_alloc().
  
  Parameters:
  
  mem - the memory to deallocate
- asciiDigitValue
  
  public static int asciiDigitValue(byte c)
  
  Determines the numeric value of a character as a decimal digit.
  Differs from g_unichar_digit_value() because it takes a char, so
  there's no worry about sign extension if characters are signed.
  
  Parameters:
  
  c - an ASCII character
  
  Returns:
  
  If @c is a decimal digit (according to g_ascii_isdigit()), its numeric value. Otherwise, -1.
- asciiDtostr
  
  public static Str asciiDtostr(@Nonnull Str buffer, int buf_len, double d)
  
  Converts a #gdouble to a string, using the '.' as
  decimal point.
  
  This function generates enough precision that converting
  the string back using g_ascii_strtod() gives the same machine-number
  (on machines with IEEE compatible 64bit doubles). It is
  guaranteed that the size of the resulting string will never
  be larger than %G_ASCII_DTOSTR_BUF_SIZE bytes, including the terminating
  nul character, which is always added.
  
  Parameters:
  
  buffer - A buffer to place the resulting string in
  
  buf_len - The length of the buffer.
  
  d - The #gdouble to convert
  
  Returns:
  
  The pointer to the buffer with the converted string.
- asciiFormatd
  
  public static Str asciiFormatd(@Nonnull Str buffer, int buf_len, @Nonnull Str format, double d)
  
  Converts a #gdouble to a string, using the '.' as
  decimal point. To format the number you pass in
  a printf()-style format string. Allowed conversion
  specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'.
  
  The @format must just be a single format specifier
  starting with `%`, expecting a #gdouble argument.
  
  The returned buffer is guaranteed to be nul-terminated.
  
  If you just want to want to serialize the value into a
  string, use g_ascii_dtostr().
  
  Parameters:
  
  buffer - A buffer to place the resulting string in
  
  buf_len - The length of the buffer.
  
  format - The printf()-style format to use for the code to use for converting
  
  d - The #gdouble to convert
  
  Returns:
  
  The pointer to the buffer with the converted string.
- asciiStrcasecmp
  
  public static int asciiStrcasecmp(@Nonnull Str s1, @Nonnull Str s2)
  
  Compare two strings, ignoring the case of ASCII characters.
  
  Unlike the BSD strcasecmp() function, this only recognizes standard
  ASCII letters and ignores the locale, treating all non-ASCII
  bytes as if they are not letters.
  
  This function should be used only on strings that are known to be
  in encodings where the bytes corresponding to ASCII letters always
  represent themselves. This includes UTF-8 and the ISO-8859-*
  charsets, but not for instance double-byte encodings like the
  Windows Codepage 932, where the trailing bytes of double-byte
  characters include all ASCII letters. If you compare two CP932
  strings using this function, you will get false matches.
  
  Both @s1 and @s2 must be non-%NULL.
  
  Parameters:
  
  s1 - string to compare with @s2
  
  s2 - string to compare with @s1
  
  Returns:
  
  0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2.
- asciiStrdown
  
  public static Str asciiStrdown(@Nonnull Str str, long len)
  
  Converts all upper case ASCII letters to lower case ASCII letters.
  
  Parameters:
  
  str - a string
  
  len - length of @str in bytes, or -1 if @str is nul-terminated
  
  Returns:
  
  a newly-allocated string, with all the upper case characters in @str converted to lower case, with semantics that exactly match g_ascii_tolower(). (Note that this is unlike the old g_strdown(), which modified the string in place.)
- asciiStrncasecmp
  
  public static int asciiStrncasecmp(@Nonnull Str s1, @Nonnull Str s2, long n)
  
  Compare @s1 and @s2, ignoring the case of ASCII characters and any
  characters after the first @n in each string. If either string is
  less than @n bytes long, comparison will stop at the first nul byte
  encountered.
  
  Unlike the BSD strcasecmp() function, this only recognizes standard
  ASCII letters and ignores the locale, treating all non-ASCII
  characters as if they are not letters.
  
  The same warning as in g_ascii_strcasecmp() applies: Use this
  function only on strings known to be in encodings where bytes
  corresponding to ASCII letters always represent themselves.
  
  Parameters:
  
  s1 - string to compare with @s2
  
  s2 - string to compare with @s1
  
  n - number of characters to compare
  
  Returns:
  
  0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2.
- asciiStrup
  
  public static Str asciiStrup(@Nonnull Str str, long len)
  
  Converts all lower case ASCII letters to upper case ASCII letters.
  
  Parameters:
  
  str - a string
  
  len - length of @str in bytes, or -1 if @str is nul-terminated
  
  Returns:
  
  a newly allocated string, with all the lower case characters in @str converted to upper case, with semantics that exactly match g_ascii_toupper(). (Note that this is unlike the old g_strup(), which modified the string in place.)
- asciiTolower
  
  public static byte asciiTolower(byte c)
  
  Convert a character to ASCII lower case.
  
  Unlike the standard C library tolower() function, this only
  recognizes standard ASCII letters and ignores the locale, returning
  all non-ASCII characters unchanged, even if they are lower case
  letters in a particular character set. Also unlike the standard
  library function, this takes and returns a char, not an int, so
  don't call it on %EOF but no need to worry about casting to #guchar
  before passing a possibly non-ASCII character in.
  
  Parameters:
  
  c - any character
  
  Returns:
  
  the result of converting @c to lower case. If @c is not an ASCII upper case letter, @c is returned unchanged.
- asciiToupper
  
  public static byte asciiToupper(byte c)
  
  Convert a character to ASCII upper case.
  
  Unlike the standard C library toupper() function, this only
  recognizes standard ASCII letters and ignores the locale, returning
  all non-ASCII characters unchanged, even if they are upper case
  letters in a particular character set. Also unlike the standard
  library function, this takes and returns a char, not an int, so
  don't call it on %EOF but no need to worry about casting to #guchar
  before passing a possibly non-ASCII character in.
  
  Parameters:
  
  c - any character
  
  Returns:
  
  the result of converting @c to upper case. If @c is not an ASCII lower case letter, @c is returned unchanged.
- asciiXdigitValue
  
  public static int asciiXdigitValue(byte c)
  
  Determines the numeric value of a character as a hexadecimal
  digit. Differs from g_unichar_xdigit_value() because it takes
  a char, so there's no worry about sign extension if characters
  are signed.
  
  Parameters:
  
  c - an ASCII character.
  
  Returns:
  
  If @c is a hex digit (according to g_ascii_isxdigit()), its numeric value. Otherwise, -1.
- assertionMessage
  
  public static void assertionMessage(@Nonnull Str domain, @Nonnull Str file, int line, @Nonnull Str func, @Nonnull Str message)
  
  Parameters:
  
  domain -
  
  file -
  
  line -
  
  func -
  
  message -
- assertionMessageCmpstr
  
  public static void assertionMessageCmpstr(@Nonnull Str domain, @Nonnull Str file, int line, @Nonnull Str func, @Nonnull Str expr, @Nonnull Str arg1, @Nonnull Str cmp, @Nonnull Str arg2)
  
  Parameters:
  
  domain -
  
  file -
  
  line -
  
  func -
  
  expr -
  
  arg1 -
  
  cmp -
  
  arg2 -
- assertionMessageCmpstrv
  
  public static void assertionMessageCmpstrv(@Nonnull Str domain, @Nonnull Str file, int line, @Nonnull Str func, @Nonnull Str expr, @Nonnull Strs arg1, @Nonnull Strs arg2, long first_wrong_idx)
  
  Parameters:
  
  domain -
  
  file -
  
  line -
  
  func -
  
  expr -
  
  arg1 -
  
  arg2 -
  
  first_wrong_idx -
- assertionMessageError
  
  public static void assertionMessageError(@Nonnull Str domain, @Nonnull Str file, int line, @Nonnull Str func, @Nonnull Str expr, @Nonnull Error error, int error_domain, int error_code)
  
  Parameters:
  
  domain -
  
  file -
  
  line -
  
  func -
  
  expr -
  
  error -
  
  error_domain -
  
  error_code -
- assertionMessageExpr
  
  public static void assertionMessageExpr(@Nullable Str domain, @Nonnull Str file, int line, @Nonnull Str func, @Nullable Str expr)
  
  Internal function used to print messages from the public g_assert() and
  g_assert_not_reached() macros.
  
  Parameters:
  
  domain - log domain
  
  file - file containing the assertion
  
  line - line number of the assertion
  
  func - function containing the assertion
  
  expr - expression which failed
- atomicIntCompareAndExchangeFull
  
  public static boolean atomicIntCompareAndExchangeFull(@Nonnull Int atomic, int oldval, int newval, @Nonnull Int preval)
  
  Compares @atomic to @oldval and, if equal, sets it to @newval.
  If @atomic was not equal to @oldval then no change occurs.
  In any case the value of @atomic before this operation is stored in @preval.
  
  This compare and exchange is done atomically.
  
  Think of this operation as an atomic version of
  `{ *preval = *atomic; if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`.
  
  This call acts as a full compiler and hardware memory barrier.
  
  See also g_atomic_int_compare_and_exchange()
  
  Parameters:
  
  atomic - a pointer to a #gint or #guint
  
  oldval - the value to compare with
  
  newval - the value to conditionally replace with
  
  preval - the contents of @atomic before this operation
  
  Returns:
  
  %TRUE if the exchange took place
- atomicIntExchange
  
  public static int atomicIntExchange(@Nonnull Int atomic, int newval)
  
  Sets the @atomic to @newval and returns the old value from @atomic.
  
  This exchange is done atomically.
  
  Think of this operation as an atomic version of
  `{ tmp = *atomic; *atomic = val; return tmp; }`.
  
  This call acts as a full compiler and hardware memory barrier.
  
  Parameters:
  
  atomic - a pointer to a #gint or #guint
  
  newval - the value to replace with
  
  Returns:
  
  the value of @atomic before the exchange, signed
- atomicPointerAdd
  
  public static long atomicPointerAdd(@Nonnull Pointer atomic, long val)
  
  Atomically adds @val to the value of @atomic.
  
  Think of this operation as an atomic version of
  `{ tmp = *atomic; *atomic += val; return tmp; }`.
  
  This call acts as a full compiler and hardware memory barrier.
  
  While @atomic has a `volatile` qualifier, this is a historical artifact and
  the pointer passed to it should not be `volatile`.
  
  Parameters:
  
  atomic - a pointer to a #gpointer-sized value
  
  val - the value to add
  
  Returns:
  
  the value of @atomic before the add, signed
- atomicPointerAnd
  
  public static long atomicPointerAnd(@Nonnull Pointer atomic, long val)
  
  Performs an atomic bitwise 'and' of the value of @atomic and @val,
  storing the result back in @atomic.
  
  Think of this operation as an atomic version of
  `{ tmp = *atomic; *atomic &= val; return tmp; }`.
  
  This call acts as a full compiler and hardware memory barrier.
  
  While @atomic has a `volatile` qualifier, this is a historical artifact and
  the pointer passed to it should not be `volatile`.
  
  Parameters:
  
  atomic - a pointer to a #gpointer-sized value
  
  val - the value to 'and'
  
  Returns:
  
  the value of @atomic before the operation, unsigned
- atomicPointerCompareAndExchange
  
  public static boolean atomicPointerCompareAndExchange(@Nonnull Pointer atomic, @Nullable Pointer oldval, @Nullable Pointer newval)
  
  Compares @atomic to @oldval and, if equal, sets it to @newval.
  If @atomic was not equal to @oldval then no change occurs.
  
  This compare and exchange is done atomically.
  
  Think of this operation as an atomic version of
  `{ if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`.
  
  This call acts as a full compiler and hardware memory barrier.
  
  While @atomic has a `volatile` qualifier, this is a historical artifact and
  the pointer passed to it should not be `volatile`.
  
  Parameters:
  
  atomic - a pointer to a #gpointer-sized value
  
  oldval - the value to compare with
  
  newval - the value to conditionally replace with
  
  Returns:
  
  %TRUE if the exchange took place
- atomicPointerCompareAndExchangeFull
  
  public static boolean atomicPointerCompareAndExchangeFull(@Nonnull Pointer atomic, @Nullable Pointer oldval, @Nullable Pointer newval, @Nonnull Pointer preval)
  
  Compares @atomic to @oldval and, if equal, sets it to @newval.
  If @atomic was not equal to @oldval then no change occurs.
  In any case the value of @atomic before this operation is stored in @preval.
  
  This compare and exchange is done atomically.
  
  Think of this operation as an atomic version of
  `{ *preval = *atomic; if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`.
  
  This call acts as a full compiler and hardware memory barrier.
  
  See also g_atomic_pointer_compare_and_exchange()
  
  Parameters:
  
  atomic - a pointer to a #gpointer-sized value
  
  oldval - the value to compare with
  
  newval - the value to conditionally replace with
  
  preval - the contents of @atomic before this operation
  
  Returns:
  
  %TRUE if the exchange took place
- atomicPointerExchange
  
  public static Pointer atomicPointerExchange(@Nullable Pointer atomic, @Nullable Pointer newval)
  
  Sets the @atomic to @newval and returns the old value from @atomic.
  
  This exchange is done atomically.
  
  Think of this operation as an atomic version of
  `{ tmp = *atomic; *atomic = val; return tmp; }`.
  
  This call acts as a full compiler and hardware memory barrier.
  
  Parameters:
  
  atomic - a pointer to a #gpointer-sized value
  
  newval - the value to replace with
  
  Returns:
  
  the value of @atomic before the exchange
- atomicPointerGet
  
  public static Pointer atomicPointerGet(@Nonnull Pointer atomic)
  
  Gets the current value of @atomic.
  
  This call acts as a full compiler and hardware
  memory barrier (before the get).
  
  While @atomic has a `volatile` qualifier, this is a historical artifact and
  the pointer passed to it should not be `volatile`.
  
  Parameters:
  
  atomic - a pointer to a #gpointer-sized value
  
  Returns:
  
  the value of the pointer
- atomicPointerOr
  
  public static long atomicPointerOr(@Nonnull Pointer atomic, long val)
  
  Performs an atomic bitwise 'or' of the value of @atomic and @val,
  storing the result back in @atomic.
  
  Think of this operation as an atomic version of
  `{ tmp = *atomic; *atomic |= val; return tmp; }`.
  
  This call acts as a full compiler and hardware memory barrier.
  
  While @atomic has a `volatile` qualifier, this is a historical artifact and
  the pointer passed to it should not be `volatile`.
  
  Parameters:
  
  atomic - a pointer to a #gpointer-sized value
  
  val - the value to 'or'
  
  Returns:
  
  the value of @atomic before the operation, unsigned
- atomicPointerSet
  
  public static void atomicPointerSet(@Nonnull Pointer atomic, @Nullable Pointer newval)
  
  Sets the value of @atomic to @newval.
  
  This call acts as a full compiler and hardware
  memory barrier (after the set).
  
  While @atomic has a `volatile` qualifier, this is a historical artifact and
  the pointer passed to it should not be `volatile`.
  
  Parameters:
  
  atomic - a pointer to a #gpointer-sized value
  
  newval - a new value to store
- atomicPointerXor
  
  public static long atomicPointerXor(@Nonnull Pointer atomic, long val)
  
  Performs an atomic bitwise 'xor' of the value of @atomic and @val,
  storing the result back in @atomic.
  
  Think of this operation as an atomic version of
  `{ tmp = *atomic; *atomic ^= val; return tmp; }`.
  
  This call acts as a full compiler and hardware memory barrier.
  
  While @atomic has a `volatile` qualifier, this is a historical artifact and
  the pointer passed to it should not be `volatile`.
  
  Parameters:
  
  atomic - a pointer to a #gpointer-sized value
  
  val - the value to 'xor'
  
  Returns:
  
  the value of @atomic before the operation, unsigned
- atomicRcBoxAcquire
  
  public static Pointer atomicRcBoxAcquire(@Nonnull Pointer mem_block)
  
  Atomically acquires a reference on the data pointed by @mem_block.
  
  Parameters:
  
  mem_block - a pointer to reference counted data
  
  Returns:
  
  a pointer to the data, with its reference count increased
- atomicRcBoxAlloc
  
  public static Pointer atomicRcBoxAlloc(long block_size)
  
  Allocates @block_size bytes of memory, and adds atomic
  reference counting semantics to it.
  
  The data will be freed when its reference count drops to
  zero.
  
  The allocated data is guaranteed to be suitably aligned for any
  built-in type.
  
  Parameters:
  
  block_size - the size of the allocation, must be greater than 0
  
  Returns:
  
  a pointer to the allocated memory
- atomicRcBoxAlloc0
  
  public static Pointer atomicRcBoxAlloc0(long block_size)
  
  Allocates @block_size bytes of memory, and adds atomic
  reference counting semantics to it.
  
  The contents of the returned data is set to zero.
  
  The data will be freed when its reference count drops to
  zero.
  
  The allocated data is guaranteed to be suitably aligned for any
  built-in type.
  
  Parameters:
  
  block_size - the size of the allocation, must be greater than 0
  
  Returns:
  
  a pointer to the allocated memory
- atomicRcBoxDup
  
  public static Pointer atomicRcBoxDup(long block_size, @Nonnull Pointer mem_block)
  
  Allocates a new block of data with atomic reference counting
  semantics, and copies @block_size bytes of @mem_block
  into it.
  
  Parameters:
  
  block_size - the number of bytes to copy, must be greater than 0
  
  mem_block - the memory to copy
  
  Returns:
  
  a pointer to the allocated memory
- atomicRcBoxGetSize
  
  public static long atomicRcBoxGetSize(@Nonnull Pointer mem_block)
  
  Retrieves the size of the reference counted data pointed by @mem_block.
  
  Parameters:
  
  mem_block - a pointer to reference counted data
  
  Returns:
  
  the size of the data, in bytes
- atomicRcBoxRelease
  
  public static void atomicRcBoxRelease(@Nonnull Pointer mem_block)
  
  Atomically releases a reference on the data pointed by @mem_block.
  
  If the reference was the last one, it will free the
  resources allocated for @mem_block.
  
  Parameters:
  
  mem_block - a pointer to reference counted data
- atomicRcBoxReleaseFull
  
  public static void atomicRcBoxReleaseFull(@Nonnull Pointer mem_block, Glib.OnDestroyNotify clear_func)
  
  Atomically releases a reference on the data pointed by @mem_block.
  
  If the reference was the last one, it will call @clear_func
  to clear the contents of @mem_block, and then will free the
  resources allocated for @mem_block.
  
  Parameters:
  
  mem_block - a pointer to reference counted data
  
  clear_func - a function to call when clearing the data
- base64EncodeClose
  
  public static long base64EncodeClose(boolean break_lines, @Nonnull Str out, @Nonnull Int state, @Nonnull Int save)
  
  Flush the status from a sequence of calls to g_base64_encode_step().
  
  The output buffer must be large enough to fit all the data that will
  be written to it. It will need up to 4 bytes, or up to 5 bytes if
  line-breaking is enabled.
  
  The @out array will not be automatically nul-terminated.
  
  Parameters:
  
  break_lines - whether to break long lines
  
  out - pointer to destination buffer
  
  state - Saved state from g_base64_encode_step()
  
  save - Saved state from g_base64_encode_step()
  
  Returns:
  
  The number of bytes of output that was written
- bitNthLsf
  
  public static int bitNthLsf(long mask, int nth_bit)
  
  Find the position of the first bit set in @mask, searching
  from (but not including) @nth_bit upwards. Bits are numbered
  from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63,
  usually). To start searching from the 0th bit, set @nth_bit to -1.
  
  Parameters:
  
  mask - a #gulong containing flags
  
  nth_bit - the index of the bit to start the search from
  
  Returns:
  
  the index of the first bit set which is higher than @nth_bit, or -1 if no higher bits are set
- bitNthMsf
  
  public static int bitNthMsf(long mask, int nth_bit)
  
  Find the position of the first bit set in @mask, searching
  from (but not including) @nth_bit downwards. Bits are numbered
  from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63,
  usually). To start searching from the last bit, set @nth_bit to
  -1 or GLIB_SIZEOF_LONG * 8.
  
  Parameters:
  
  mask - a #gulong containing flags
  
  nth_bit - the index of the bit to start the search from
  
  Returns:
  
  the index of the first bit set which is lower than @nth_bit, or -1 if no lower bits are set
- bitStorage
  
  public static int bitStorage(long number)
  
  Gets the number of bits used to hold @number,
  e.g. if @number is 4, 3 bits are needed.
  
  Parameters:
  
  number - a #guint
  
  Returns:
  
  the number of bits used to hold @number
- bookmarkFileErrorQuark
  
  public static int bookmarkFileErrorQuark()
  
  Returns:
- buildFilename
  
  public static Str buildFilename(@Nonnull Str first_element, Object... _elipse)
  
  Creates a filename from a series of elements using the correct
  separator for filenames.
  
  On Unix, this function behaves identically to `g_build_path
  (G_DIR_SEPARATOR_S, first_element, ....)`.
  
  On Windows, it takes into account that either the backslash
  (`\` or slash (`/`) can be used as separator in filenames, but
  otherwise behaves as on UNIX. When file pathname separators need
  to be inserted, the one that last previously occurred in the
  parameters (reading from left to right) is used.
  
  No attempt is made to force the resulting filename to be an absolute
  path. If the first element is a relative path, the result will
  be a relative path.
  
  Parameters:
  
  first_element - the first element in the path
  
  _elipse - remaining elements in path, terminated by %NULL
  
  Returns:
  
  a newly-allocated string that must be freed with g_free().
- buildPath
  
  public static Str buildPath(@Nonnull Str separator, @Nonnull Str first_element, Object... _elipse)
  
  Creates a path from a series of elements using @separator as the
  separator between elements. At the boundary between two elements,
  any trailing occurrences of separator in the first element, or
  leading occurrences of separator in the second element are removed
  and exactly one copy of the separator is inserted.
  
  Empty elements are ignored.
  
  The number of leading copies of the separator on the result is
  the same as the number of leading copies of the separator on
  the first non-empty element.
  
  The number of trailing copies of the separator on the result is
  the same as the number of trailing copies of the separator on
  the last non-empty element. (Determination of the number of
  trailing copies is done without stripping leading copies, so
  if the separator is `ABA`, then `ABABA` has 1 trailing copy.)
  
  However, if there is only a single non-empty element, and there
  are no characters in that element not part of the leading or
  trailing separators, then the result is exactly the original value
  of that element.
  
  Other than for determination of the number of leading and trailing
  copies of the separator, elements consisting only of copies
  of the separator are ignored.
  
  Parameters:
  
  separator - a string used to separator the elements of the path.
  
  first_element - the first element in the path
  
  _elipse - remaining elements in path, terminated by %NULL
  
  Returns:
  
  a newly-allocated string that must be freed with g_free().
- byteArrayFreeToBytes
  
  public static Bytes byteArrayFreeToBytes(@Nonnull ByteArray array)
  
  Transfers the data from the #GByteArray into a new immutable #GBytes.
  
  The #GByteArray is freed unless the reference count of @array is greater
  than one, the #GByteArray wrapper is preserved but the size of @array
  will be set to zero.
  
  This is identical to using g_bytes_new_take() and g_byte_array_free()
  together.
  
  Parameters:
  
  array - a #GByteArray
  
  Returns:
  
  a new immutable #GBytes representing same byte data that was in the array
- byteArrayNew
  
  public static ByteArray byteArrayNew()
  
  Creates a new #GByteArray with a reference count of 1.
  
  Returns:
  
  the new #GByteArray
- byteArrayUnref
  
  public static void byteArrayUnref(@Nonnull ByteArray array)
  
  Atomically decrements the reference count of @array by one. If the
  reference count drops to 0, all memory allocated by the array is
  released. This function is thread-safe and may be called from any
  thread.
  
  Parameters:
  
  array - A #GByteArray
- canonicalizeFilename
  
  public static Str canonicalizeFilename(@Nonnull Str filename, @Nullable Str relative_to)
  
  Gets the canonical file name from @filename. All triple slashes are turned into
  single slashes, and all `..` and `.`s resolved against @relative_to.
  
  Symlinks are not followed, and the returned path is guaranteed to be absolute.
  
  If @filename is an absolute path, @relative_to is ignored. Otherwise,
  @relative_to will be prepended to @filename to make it absolute. @relative_to
  must be an absolute path, or %NULL. If @relative_to is %NULL, it'll fallback
  to g_get_current_dir().
  
  This function never fails, and will canonicalize file paths even if they don't
  exist.
  
  No file system I/O is done.
  
  Parameters:
  
  filename - the name of the file
  
  relative_to - the relative directory, or %NULL to use the current working directory
  
  Returns:
  
  a newly allocated string with the canonical file path
- chdir
  
  public static int chdir(@Nonnull Str path)
  
  A wrapper for the POSIX chdir() function. The function changes the
  current directory of the process to @path.
  
  See your C library manual for more details about chdir().
  
  Parameters:
  
  path - a pathname in the GLib file name encoding (UTF-8 on Windows)
  
  Returns:
  
  0 on success, -1 if an error occurred.
- checkVersion
  
  public static Str checkVersion(int required_major, int required_minor, int required_micro)
  
  Checks that the GLib library in use is compatible with the
  given version.
  
  Generally you would pass in the constants %GLIB_MAJOR_VERSION,
  %GLIB_MINOR_VERSION, %GLIB_MICRO_VERSION as the three arguments
  to this function; that produces a check that the library in use
  is compatible with the version of GLib the application or module
  was compiled against.
  
  Compatibility is defined by two things: first the version
  of the running library is newer than the version
  `@required_major.required_minor.@required_micro`. Second
  the running library must be binary compatible with the
  version `@required_major.@required_minor.@required_micro`
  (same major version.)
  
  Parameters:
  
  required_major - the required major version
  
  required_minor - the required minor version
  
  required_micro - the required micro version
  
  Returns:
  
  %NULL if the GLib library is compatible with the given version, or a string describing the version mismatch. The returned string is owned by GLib and must not be modified or freed.
- checksumTypeGetLength
  
  public static long checksumTypeGetLength(int checksum_type)
  
  Gets the length in bytes of digests of type @checksum_type
  
  Parameters:
  
  checksum_type - a #GChecksumType
  
  Returns:
  
  the checksum length, or -1 if @checksum_type is not supported.
- clearError
  
  public static void clearError() throws AllocationError
  
  If @err or *@err is %NULL, does nothing. Otherwise,
  calls g_error_free() on *@err and sets *@err to %NULL.
  
  Throws:
  
  AllocationError
- close
  
  public static boolean close(int fd) throws AllocationError
  
  This wraps the close() call; in case of error, %errno will be
  preserved, but the error will also be stored as a #GError in @error.
  
  Besides using #GError, there is another major reason to prefer this
  function over the call provided by the system; on Unix, it will
  attempt to correctly handle %EINTR, which has platform-specific
  semantics.
  
  Parameters:
  
  fd - A file descriptor
  
  Returns:
  
  %TRUE on success, %FALSE if there was an error.
  
  Throws:
  
  AllocationError
- computeChecksumForBytes
  
  public static Str computeChecksumForBytes(int checksum_type, @Nonnull Bytes data)
  
  Computes the checksum for a binary @data. This is a
  convenience wrapper for g_checksum_new(), g_checksum_get_string()
  and g_checksum_free().
  
  The hexadecimal string returned will be in lower case.
  
  Parameters:
  
  checksum_type - a #GChecksumType
  
  data - binary blob to compute the digest of
  
  Returns:
  
  the digest of the binary data as a string in hexadecimal, or %NULL if g_checksum_new() fails for @checksum_type. The returned string should be freed with g_free() when done using it.
- computeChecksumForString
  
  public static Str computeChecksumForString(int checksum_type, @Nonnull Str str, long length)
  
  Computes the checksum of a string.
  
  The hexadecimal string returned will be in lower case.
  
  Parameters:
  
  checksum_type - a #GChecksumType
  
  str - the string to compute the checksum of
  
  length - the length of the string, or -1 if the string is null-terminated.
  
  Returns:
  
  the checksum as a hexadecimal string, or %NULL if g_checksum_new() fails for @checksum_type. The returned string should be freed with g_free() when done using it.
- computeHmacForBytes
  
  public static Str computeHmacForBytes(int digest_type, @Nonnull Bytes key, @Nonnull Bytes data)
  
  Computes the HMAC for a binary @data. This is a
  convenience wrapper for g_hmac_new(), g_hmac_get_string()
  and g_hmac_unref().
  
  The hexadecimal string returned will be in lower case.
  
  Parameters:
  
  digest_type - a #GChecksumType to use for the HMAC
  
  key - the key to use in the HMAC
  
  data - binary blob to compute the HMAC of
  
  Returns:
  
  the HMAC of the binary data as a string in hexadecimal. The returned string should be freed with g_free() when done using it.
- convert
  
  public static Str convert(@Nonnull Str str, long len, @Nonnull Str to_codeset, @Nonnull Str from_codeset, @Nullable Int64 bytes_read, @Nullable Int64 bytes_written) throws AllocationError
  
  Converts a string from one character set to another.
  
  Note that you should use g_iconv() for streaming conversions.
  Despite the fact that @bytes_read can return information about partial
  characters, the g_convert_... functions are not generally suitable
  for streaming. If the underlying converter maintains internal state,
  then this won't be preserved across successive calls to g_convert(),
  g_convert_with_iconv() or g_convert_with_fallback(). (An example of
  this is the GNU C converter for CP1255 which does not emit a base
  character until it knows that the next character is not a mark that
  could combine with the base character.)
  
  Using extensions such as "//TRANSLIT" may not work (or may not work
  well) on many platforms. Consider using g_str_to_ascii() instead.
  
  Parameters:
  
  str - the string to convert.
  
  len - the length of the string in bytes, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe)
  
  to_codeset - name of character set into which to convert @str
  
  from_codeset - character set of @str.
  
  bytes_read - location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will be the byte offset after the last valid input sequence.
  
  bytes_written - the number of bytes stored in the output buffer (not including the terminating nul).
  
  Returns:
  
  If the conversion was successful, a newly allocated buffer containing the converted string, which must be freed with g_free(). Otherwise %NULL and @error will be set.
  
  Throws:
  
  AllocationError
- convertErrorQuark
  
  public static int convertErrorQuark()
  
  Returns:
- convertWithFallback
  
  public static Str convertWithFallback(@Nonnull Str str, long len, @Nonnull Str to_codeset, @Nonnull Str from_codeset, @Nonnull Str fallback, @Nullable Int64 bytes_read, @Nullable Int64 bytes_written) throws AllocationError
  
  Converts a string from one character set to another, possibly
  including fallback sequences for characters not representable
  in the output. Note that it is not guaranteed that the specification
  for the fallback sequences in @fallback will be honored. Some
  systems may do an approximate conversion from @from_codeset
  to @to_codeset in their iconv() functions,
  in which case GLib will simply return that approximate conversion.
  
  Note that you should use g_iconv() for streaming conversions.
  Despite the fact that @bytes_read can return information about partial
  characters, the g_convert_... functions are not generally suitable
  for streaming. If the underlying converter maintains internal state,
  then this won't be preserved across successive calls to g_convert(),
  g_convert_with_iconv() or g_convert_with_fallback(). (An example of
  this is the GNU C converter for CP1255 which does not emit a base
  character until it knows that the next character is not a mark that
  could combine with the base character.)
  
  Parameters:
  
  str - the string to convert.
  
  len - the length of the string in bytes, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe)
  
  to_codeset - name of character set into which to convert @str
  
  from_codeset - character set of @str.
  
  fallback - UTF-8 string to use in place of characters not present in the target encoding. (The string must be representable in the target encoding). If %NULL, characters not in the target encoding will be represented as Unicode escapes \uxxxx or \Uxxxxyyyy.
  
  bytes_read - location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input.
  
  bytes_written - the number of bytes stored in the output buffer (not including the terminating nul).
  
  Returns:
  
  If the conversion was successful, a newly allocated buffer containing the converted string, which must be freed with g_free(). Otherwise %NULL and @error will be set.
  
  Throws:
  
  AllocationError
- datasetDestroy
  
  public static void datasetDestroy(@Nonnull Pointer dataset_location)
  
  Destroys the dataset, freeing all memory allocated, and calling any
  destroy functions set for data elements.
  
  Parameters:
  
  dataset_location - the location identifying the dataset.
- datasetForeach
  
  public static void datasetForeach(@Nonnull Pointer dataset_location, Glib.OnDataForeachFunc func, @Nullable Pointer user_data)
  
  Calls the given function for each data element which is associated
  with the given location. Note that this function is NOT thread-safe.
  So unless @dataset_location can be protected from any modifications
  during invocation of this function, it should not be called.
  
  @func can make changes to the dataset, but the iteration will not
  reflect changes made during the g_dataset_foreach() call, other
  than skipping over elements that are removed.
  
  Parameters:
  
  dataset_location - the location identifying the dataset.
  
  func - the function to call for each data element.
  
  user_data - user data to pass to the function.
- datasetIdGetData
  
  public static Pointer datasetIdGetData(@Nonnull Pointer dataset_location, int key_id)
  
  Gets the data element corresponding to a #GQuark.
  
  Parameters:
  
  dataset_location - the location identifying the dataset.
  
  key_id - the #GQuark id to identify the data element.
  
  Returns:
  
  the data element corresponding to the #GQuark, or %NULL if it is not found.
- datasetIdRemoveNoNotify
  
  public static Pointer datasetIdRemoveNoNotify(@Nonnull Pointer dataset_location, int key_id)
  
  Removes an element, without calling its destroy notification
  function.
  
  Parameters:
  
  dataset_location - the location identifying the dataset.
  
  key_id - the #GQuark ID identifying the data element.
  
  Returns:
  
  the data previously stored at @key_id, or %NULL if none.
- datasetIdSetDataFull
  
  public static void datasetIdSetDataFull(@Nonnull Pointer dataset_location, int key_id, @Nullable Pointer data, Glib.OnDestroyNotify destroy_func)
  
  Sets the data element associated with the given #GQuark id, and also
  the function to call when the data element is destroyed. Any
  previous data with the same key is removed, and its destroy function
  is called.
  
  Parameters:
  
  dataset_location - the location identifying the dataset.
  
  key_id - the #GQuark id to identify the data element.
  
  data - the data element.
  
  destroy_func - the function to call when the data element is removed. This function will be called with the data element and can be used to free any memory allocated for it.
- dateStrftime
  
  public static long dateStrftime(@Nonnull Str s, long slen, @Nonnull Str format, @Nonnull Date date)
  
  Generates a printed representation of the date, in a
  [locale][setlocale]-specific way.
  Works just like the platform's C library strftime() function,
  but only accepts date-related formats; time-related formats
  give undefined results. Date must be valid. Unlike strftime()
  (which uses the locale encoding), works on a UTF-8 format
  string and stores a UTF-8 result.
  
  This function does not provide any conversion specifiers in
  addition to those implemented by the platform's C library.
  For example, don't expect that using g_date_strftime() would
  make the \%F provided by the C99 strftime() work on Windows
  where the C library only complies to C89.
  
  Parameters:
  
  s - destination buffer
  
  slen - buffer size
  
  format - format string
  
  date - valid #GDate
  
  Returns:
  
  number of characters written to the buffer, or 0 the buffer was too small
- dateValidJulian
  
  public static boolean dateValidJulian(int julian_date)
  
  Returns %TRUE if the Julian day is valid. Anything greater than zero
  is basically a valid Julian, though there is a 32-bit limit.
  
  Parameters:
  
  julian_date - Julian day to check
  
  Returns:
  
  %TRUE if the Julian day is valid
- dateValidMonth
  
  public static boolean dateValidMonth(int month)
  
  Returns %TRUE if the month value is valid. The 12 #GDateMonth
  enumeration values are the only valid months.
  
  Parameters:
  
  month - month
  
  Returns:
  
  %TRUE if the month is valid
- dateValidWeekday
  
  public static boolean dateValidWeekday(int weekday)
  
  Returns %TRUE if the weekday is valid. The seven #GDateWeekday enumeration
  values are the only valid weekdays.
  
  Parameters:
  
  weekday - weekday
  
  Returns:
  
  %TRUE if the weekday is valid
- dcgettext
  
  public static Str dcgettext(@Nullable Str domain, @Nonnull Str msgid, int category)
  
  This is a variant of g_dgettext() that allows specifying a locale
  category instead of always using `LC_MESSAGES`. See g_dgettext() for
  more information about how this functions differs from calling
  dcgettext() directly.
  
  Parameters:
  
  domain - the translation domain to use, or %NULL to use the domain set with textdomain()
  
  msgid - message to translate
  
  category - a locale category
  
  Returns:
  
  the translated string for the given locale category
- dgettext
  
  public static Str dgettext(@Nullable Str domain, @Nonnull Str msgid)
  
  This function is a wrapper of dgettext() which does not translate
  the message if the default domain as set with textdomain() has no
  translations for the current locale.
  
  The advantage of using this function over dgettext() proper is that
  libraries using this function (like GTK+) will not use translations
  if the application using the library does not have translations for
  the current locale. This results in a consistent English-only
  interface instead of one having partial translations. For this
  feature to work, the call to textdomain() and setlocale() should
  precede any g_dgettext() invocations. For GTK+, it means calling
  textdomain() before gtk_init or its variants.
  
  This function disables translations if and only if upon its first
  call all the following conditions hold:
  
  - @domain is not %NULL
  
  - textdomain() has been called to set a default text domain
  
  - there is no translations available for the default text domain
  and the current locale
  
  - current locale is not "C" or any English locales (those
  starting with "en_")
  
  Note that this behavior may not be desired for example if an application
  has its untranslated messages in a language other than English. In those
  cases the application should call textdomain() after initializing GTK+.
  
  Applications should normally not use this function directly,
  but use the _() macro for translations.
  
  Parameters:
  
  domain - the translation domain to use, or %NULL to use the domain set with textdomain()
  
  msgid - message to translate
  
  Returns:
  
  The translated string
- dirMakeTmp
  
  public static Str dirMakeTmp(@Nullable Str tmpl) throws AllocationError
  
  Creates a subdirectory in the preferred directory for temporary
  files (as returned by g_get_tmp_dir()).
  
  @tmpl should be a string in the GLib file name encoding containing
  a sequence of six 'X' characters, as the parameter to g_mkstemp().
  However, unlike these functions, the template should only be a
  basename, no directory components are allowed. If template is
  %NULL, a default template is used.
  
  Note that in contrast to g_mkdtemp() (and mkdtemp()) @tmpl is not
  modified, and might thus be a read-only literal string.
  
  Parameters:
  
  tmpl - Template for directory name, as in g_mkdtemp(), basename only, or %NULL for a default template
  
  Returns:
  
  The actual name used. This string should be freed with g_free() when not needed any longer and is is in the GLib file name encoding. In case of errors, %NULL is returned and @error will be set.
  
  Throws:
  
  AllocationError
- directEqual
  
  public static boolean directEqual(@Nullable Pointer v1, @Nullable Pointer v2)
  
  Compares two #gpointer arguments and returns %TRUE if they are equal.
  It can be passed to g_hash_table_new() as the @key_equal_func
  parameter, when using opaque pointers compared by pointer value as
  keys in a #GHashTable.
  
  This equality function is also appropriate for keys that are integers
  stored in pointers, such as `GINT_TO_POINTER (n)`.
  
  Parameters:
  
  v1 - a key
  
  v2 - a key to compare with @v1
  
  Returns:
  
  %TRUE if the two keys match.
- directHash
  
  public static int directHash(@Nullable Pointer v)
  
  Converts a gpointer to a hash value.
  It can be passed to g_hash_table_new() as the @hash_func parameter,
  when using opaque pointers compared by pointer value as keys in a
  #GHashTable.
  
  This hash function is also appropriate for keys that are integers
  stored in pointers, such as `GINT_TO_POINTER (n)`.
  
  Parameters:
  
  v - a #gpointer key
  
  Returns:
  
  a hash value corresponding to the key.
- dngettext
  
  public static Str dngettext(@Nullable Str domain, @Nonnull Str msgid, @Nonnull Str msgid_plural, long n)
  
  This function is a wrapper of dngettext() which does not translate
  the message if the default domain as set with textdomain() has no
  translations for the current locale.
  
  See g_dgettext() for details of how this differs from dngettext()
  proper.
  
  Parameters:
  
  domain - the translation domain to use, or %NULL to use the domain set with textdomain()
  
  msgid - message to translate
  
  msgid_plural - plural form of the message
  
  n - the quantity for which translation is needed
  
  Returns:
  
  The translated string
- doubleEqual
  
  public static boolean doubleEqual(@Nonnull Pointer v1, @Nonnull Pointer v2)
  
  Compares the two #gdouble values being pointed to and returns
  %TRUE if they are equal.
  It can be passed to g_hash_table_new() as the @key_equal_func
  parameter, when using non-%NULL pointers to doubles as keys in a
  #GHashTable.
  
  Parameters:
  
  v1 - a pointer to a #gdouble key
  
  v2 - a pointer to a #gdouble key to compare with @v1
  
  Returns:
  
  %TRUE if the two keys match.
- doubleHash
  
  public static int doubleHash(@Nonnull Pointer v)
  
  Converts a pointer to a #gdouble to a hash value.
  It can be passed to g_hash_table_new() as the @hash_func parameter,
  It can be passed to g_hash_table_new() as the @hash_func parameter,
  when using non-%NULL pointers to doubles as keys in a #GHashTable.
  
  Parameters:
  
  v - a pointer to a #gdouble key
  
  Returns:
  
  a hash value corresponding to the key.
- dpgettext
  
  public static Str dpgettext(@Nullable Str domain, @Nonnull Str msgctxtid, long msgidoffset)
  
  This function is a variant of g_dgettext() which supports
  a disambiguating message context. GNU gettext uses the
  '\004' character to separate the message context and
  message id in @msgctxtid.
  If 0 is passed as @msgidoffset, this function will fall back to
  trying to use the deprecated convention of using "|" as a separation
  character.
  
  This uses g_dgettext() internally. See that functions for differences
  with dgettext() proper.
  
  Applications should normally not use this function directly,
  but use the C_() macro for translations with context.
  
  Parameters:
  
  domain - the translation domain to use, or %NULL to use the domain set with textdomain()
  
  msgctxtid - a combined message context and message id, separated by a \004 character
  
  msgidoffset - the offset of the message id in @msgctxid
  
  Returns:
  
  The translated string
- dpgettext2
  
  public static Str dpgettext2(@Nullable Str domain, @Nonnull Str context, @Nonnull Str msgid)
  
  This function is a variant of g_dgettext() which supports
  a disambiguating message context. GNU gettext uses the
  '\004' character to separate the message context and
  message id in @msgctxtid.
  
  This uses g_dgettext() internally. See that functions for differences
  with dgettext() proper.
  
  This function differs from C_() in that it is not a macro and
  thus you may use non-string-literals as context and msgid arguments.
  
  Parameters:
  
  domain - the translation domain to use, or %NULL to use the domain set with textdomain()
  
  context - the message context
  
  msgid - the message
  
  Returns:
  
  The translated string
- fileErrorFromErrno
  
  public static int fileErrorFromErrno(int err_no)
  
  Gets a #GFileError constant based on the passed-in @err_no.
  
  For example, if you pass in `EEXIST` this function returns
  %G_FILE_ERROR_EXIST. Unlike `errno` values, you can portably
  assume that all #GFileError values will exist.
  
  Normally a #GFileError value goes into a #GError returned
  from a function that manipulates files. So you would use
  g_file_error_from_errno() when constructing a #GError.
  
  Parameters:
  
  err_no - an "errno" value
  
  Returns:
  
  #GFileError corresponding to the given @err_no
- fileErrorQuark
  
  public static int fileErrorQuark()
  
  Returns:
- fileReadLink
  
  public static Str fileReadLink(@Nonnull Str filename) throws AllocationError
  
  Reads the contents of the symbolic link @filename like the POSIX
  readlink() function. The returned string is in the encoding used
  for filenames. Use g_filename_to_utf8() to convert it to UTF-8.
  
  Parameters:
  
  filename - the symbolic link
  
  Returns:
  
  A newly-allocated string with the contents of the symbolic link, or %NULL if an error occurred.
  
  Throws:
  
  AllocationError
- fileSetContents
  
  public static boolean fileSetContents(@Nonnull Str filename, @Nonnull Str contents, long length) throws AllocationError
  
  Writes all of @contents to a file named @filename. This is a convenience
  wrapper around calling g_file_set_contents_full() with `flags` set to
  `G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_ONLY_EXISTING` and
  `mode` set to `0666`.
  
  Parameters:
  
  filename - name of a file to write @contents to, in the GLib file name encoding
  
  contents - string to write to the file
  
  length - length of @contents, or -1 if @contents is a nul-terminated string
  
  Returns:
  
  %TRUE on success, %FALSE if an error occurred
  
  Throws:
  
  AllocationError
- fileSetContentsFull
  
  public static boolean fileSetContentsFull(@Nonnull Str filename, @Nonnull Str contents, long length, int flags, int mode) throws AllocationError
  
  Writes all of @contents to a file named @filename, with good error checking.
  If a file called @filename already exists it will be overwritten.
  
  @flags control the properties of the write operation: whether it’s atomic,
  and what the tradeoff is between returning quickly or being resilient to
  system crashes.
  
  As this function performs file I/O, it is recommended to not call it anywhere
  where blocking would cause problems, such as in the main loop of a graphical
  application. In particular, if @flags has any value other than
  %G_FILE_SET_CONTENTS_NONE then this function may call `fsync()`.
  
  If %G_FILE_SET_CONTENTS_CONSISTENT is set in @flags, the operation is atomic
  in the sense that it is first written to a temporary file which is then
  renamed to the final name.
  
  Notes:
  
  - On UNIX, if @filename already exists hard links to @filename will break.
  Also since the file is recreated, existing permissions, access control
  lists, metadata etc. may be lost. If @filename is a symbolic link,
  the link itself will be replaced, not the linked file.
  
  - On UNIX, if @filename already exists and is non-empty, and if the system
  supports it (via a journalling filesystem or equivalent), and if
  %G_FILE_SET_CONTENTS_CONSISTENT is set in @flags, the `fsync()` call (or
  equivalent) will be used to ensure atomic replacement: @filename
  will contain either its old contents or @contents, even in the face of
  system power loss, the disk being unsafely removed, etc.
  
  - On UNIX, if @filename does not already exist or is empty, there is a
  possibility that system power loss etc. after calling this function will
  leave @filename empty or full of NUL bytes, depending on the underlying
  filesystem, unless %G_FILE_SET_CONTENTS_DURABLE and
  %G_FILE_SET_CONTENTS_CONSISTENT are set in @flags.
  
  - On Windows renaming a file will not remove an existing file with the
  new name, so on Windows there is a race condition between the existing
  file being removed and the temporary file being renamed.
  
  - On Windows there is no way to remove a file that is open to some
  process, or mapped into memory. Thus, this function will fail if
  @filename already exists and is open.
  
  If the call was successful, it returns %TRUE. If the call was not successful,
  it returns %FALSE and sets @error. The error domain is %G_FILE_ERROR.
  Possible error codes are those in the #GFileError enumeration.
  
  Note that the name for the temporary file is constructed by appending up
  to 7 characters to @filename.
  
  If the file didn’t exist before and is created, it will be given the
  permissions from @mode. Otherwise, the permissions of the existing file may
  be changed to @mode depending on @flags, or they may remain unchanged.
  
  Parameters:
  
  filename - name of a file to write @contents to, in the GLib file name encoding
  
  contents - string to write to the file
  
  length - length of @contents, or -1 if @contents is a nul-terminated string
  
  flags - flags controlling the safety vs speed of the operation
  
  mode - file mode, as passed to `open()`; typically this will be `0666`
  
  Returns:
  
  %TRUE on success, %FALSE if an error occurred
  
  Throws:
  
  AllocationError
- fileTest
  
  public static boolean fileTest(@Nonnull Str filename, int test)
  Returns %TRUE if any of the tests in the bitfield @test are
  %TRUE. For example, `(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)`
  will return %TRUE if the file exists; the check whether it's a
  directory doesn't matter since the existence test is %TRUE. With
  the current set of available tests, there's no point passing in
  more than one test at a time.
  
  Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links,
  so for a symbolic link to a regular file g_file_test() will return
  %TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR.
  
  Note, that for a dangling symbolic link g_file_test() will return
  %TRUE for %G_FILE_TEST_IS_SYMLINK and %FALSE for all other flags.
  
  You should never use g_file_test() to test whether it is safe
  to perform an operation, because there is always the possibility
  of the condition changing before you actually perform the operation.
  For example, you might think you could use %G_FILE_TEST_IS_SYMLINK
  to know whether it is safe to write to a file without being
  tricked into writing into a different location. It doesn't work!
   // DON'T DO THIS if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK)) { fd = g_open (filename, O_WRONLY); // write to fd }
  
  Another thing to note is that %G_FILE_TEST_EXISTS and
  %G_FILE_TEST_IS_EXECUTABLE are implemented using the access()
  system call. This usually doesn't matter, but if your program
  is setuid or setgid it means that these tests will give you
  the answer for the real user ID and group ID, rather than the
  effective user ID and group ID.
  
  On Windows, there are no symlinks, so testing for
  %G_FILE_TEST_IS_SYMLINK will always return %FALSE. Testing for
  %G_FILE_TEST_IS_EXECUTABLE will just check that the file exists and
  its name indicates that it is executable, checking for well-known
  extensions and those listed in the `PATHEXT` environment variable.
  Parameters:
  
  filename - a filename to test in the GLib file name encoding
  
  test - bitfield of #GFileTest flags
  
  Returns:
  
  whether a test was %TRUE
- filenameDisplayBasename
  
  public static Str filenameDisplayBasename(@Nonnull Str filename)
  
  Returns the display basename for the particular filename, guaranteed
  to be valid UTF-8. The display name might not be identical to the filename,
  for instance there might be problems converting it to UTF-8, and some files
  can be translated in the display.
  
  If GLib cannot make sense of the encoding of @filename, as a last resort it
  replaces unknown characters with U+FFFD, the Unicode replacement character.
  You can search the result for the UTF-8 encoding of this character (which is
  "\357\277\275" in octal notation) to find out if @filename was in an invalid
  encoding.
  
  You must pass the whole absolute pathname to this functions so that
  translation of well known locations can be done.
  
  This function is preferred over g_filename_display_name() if you know the
  whole path, as it allows translation.
  
  Parameters:
  
  filename - an absolute pathname in the GLib file name encoding
  
  Returns:
  
  a newly allocated string containing a rendition of the basename of the filename in valid UTF-8
- filenameDisplayName
  
  public static Str filenameDisplayName(@Nonnull Str filename)
  
  Converts a filename into a valid UTF-8 string. The conversion is
  not necessarily reversible, so you should keep the original around
  and use the return value of this function only for display purposes.
  Unlike g_filename_to_utf8(), the result is guaranteed to be non-%NULL
  even if the filename actually isn't in the GLib file name encoding.
  
  If GLib cannot make sense of the encoding of @filename, as a last resort it
  replaces unknown characters with U+FFFD, the Unicode replacement character.
  You can search the result for the UTF-8 encoding of this character (which is
  "\357\277\275" in octal notation) to find out if @filename was in an invalid
  encoding.
  
  If you know the whole pathname of the file you should use
  g_filename_display_basename(), since that allows location-based
  translation of filenames.
  
  Parameters:
  
  filename - a pathname hopefully in the GLib file name encoding
  
  Returns:
  
  a newly allocated string containing a rendition of the filename in valid UTF-8
- filenameFromUtf8
  
  public static Str filenameFromUtf8(@Nonnull Str utf8string, long len, @Nullable Int64 bytes_read, @Nullable Int64 bytes_written) throws AllocationError
  
  Converts a string from UTF-8 to the encoding GLib uses for
  filenames. Note that on Windows GLib uses UTF-8 for filenames;
  on other platforms, this function indirectly depends on the
  [current locale][setlocale].
  
  The input string shall not contain nul characters even if the @len
  argument is positive. A nul character found inside the string will result
  in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. If the filename encoding is
  not UTF-8 and the conversion output contains a nul character, the error
  %G_CONVERT_ERROR_EMBEDDED_NUL is set and the function returns %NULL.
  
  Parameters:
  
  utf8string - a UTF-8 encoded string.
  
  len - the length of the string, or -1 if the string is nul-terminated.
  
  bytes_read - location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will be the byte offset after the last valid input sequence.
  
  bytes_written - the number of bytes stored in the output buffer (not including the terminating nul).
  
  Returns:
  
  The converted string, or %NULL on an error.
  
  Throws:
  
  AllocationError
- filenameToUri
  
  public static Str filenameToUri(@Nonnull Str filename, @Nullable Str hostname) throws AllocationError
  
  Converts an absolute filename to an escaped ASCII-encoded URI, with the path
  component following Section 3.3. of RFC 2396.
  
  Parameters:
  
  filename - an absolute filename specified in the GLib file name encoding, which is the on-disk file name bytes on Unix, and UTF-8 on Windows
  
  hostname - A UTF-8 encoded hostname, or %NULL for none.
  
  Returns:
  
  a newly-allocated string holding the resulting URI, or %NULL on an error.
  
  Throws:
  
  AllocationError
- filenameToUtf8
  
  public static Str filenameToUtf8(@Nonnull Str opsysstring, long len, @Nullable Int64 bytes_read, @Nullable Int64 bytes_written) throws AllocationError
  
  Converts a string which is in the encoding used by GLib for
  filenames into a UTF-8 string. Note that on Windows GLib uses UTF-8
  for filenames; on other platforms, this function indirectly depends on
  the [current locale][setlocale].
  
  The input string shall not contain nul characters even if the @len
  argument is positive. A nul character found inside the string will result
  in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE.
  If the source encoding is not UTF-8 and the conversion output contains a
  nul character, the error %G_CONVERT_ERROR_EMBEDDED_NUL is set and the
  function returns %NULL. Use g_convert() to produce output that
  may contain embedded nul characters.
  
  Parameters:
  
  opsysstring - a string in the encoding for filenames
  
  len - the length of the string, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe)
  
  bytes_read - location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will be the byte offset after the last valid input sequence.
  
  bytes_written - the number of bytes stored in the output buffer (not including the terminating nul).
  
  Returns:
  
  The converted string, or %NULL on an error.
  
  Throws:
  
  AllocationError
- findProgramInPath
  
  public static Str findProgramInPath(@Nonnull Str program)
  
  Locates the first executable named @program in the user's path, in the
  same way that execvp() would locate it. Returns an allocated string
  with the absolute path name, or %NULL if the program is not found in
  the path. If @program is already an absolute path, returns a copy of
  @program if @program exists and is executable, and %NULL otherwise.
  
  On Windows, if @program does not have a file type suffix, tries
  with the suffixes .exe, .cmd, .bat and .com, and the suffixes in
  the `PATHEXT` environment variable.
  
  On Windows, it looks for the file in the same way as CreateProcess()
  would. This means first in the directory where the executing
  program was loaded from, then in the current directory, then in the
  Windows 32-bit system directory, then in the Windows directory, and
  finally in the directories in the `PATH` environment variable. If
  the program is found, the return value contains the full name
  including the type suffix.
  
  Parameters:
  
  program - a program name in the GLib file name encoding
  
  Returns:
  
  a newly-allocated string with the absolute path, or %NULL
- formatSize
  
  public static Str formatSize(long size)
  
  Formats a size (for example the size of a file) into a human readable
  string. Sizes are rounded to the nearest size prefix (kB, MB, GB)
  and are displayed rounded to the nearest tenth. E.g. the file size
  3292528 bytes will be converted into the string "3.2 MB". The returned string
  is UTF-8, and may use a non-breaking space to separate the number and units,
  to ensure they aren’t separated when line wrapped.
  
  The prefix units base is 1000 (i.e. 1 kB is 1000 bytes).
  
  This string should be freed with g_free() when not needed any longer.
  
  See g_format_size_full() for more options about how the size might be
  formatted.
  
  Parameters:
  
  size - a size in bytes
  
  Returns:
  
  a newly-allocated formatted string containing a human readable file size
- formatSizeFull
  
  public static Str formatSizeFull(long size, int flags)
  
  Formats a size.
  
  This function is similar to g_format_size() but allows for flags
  that modify the output. See #GFormatSizeFlags.
  
  Parameters:
  
  size - a size in bytes
  
  flags - #GFormatSizeFlags to modify the output
  
  Returns:
  
  a newly-allocated formatted string containing a human readable file size
- free
  
  public static void free(@Nullable Pointer mem)
  
  Frees the memory pointed to by @mem.
  
  If @mem is %NULL it simply returns, so there is no need to check @mem
  against %NULL before calling this function.
  
  Parameters:
  
  mem - the memory to free
- getApplicationName
  
  public static Str getApplicationName()
  
  Gets a human-readable name for the application, as set by
  g_set_application_name(). This name should be localized if
  possible, and is intended for display to the user. Contrast with
  g_get_prgname(), which gets a non-localized name. If
  g_set_application_name() has not been called, returns the result of
  g_get_prgname() (which may be %NULL if g_set_prgname() has also not
  been called).
  
  Returns:
  
  human-readable application name. May return %NULL
- getCharset
  
  public static boolean getCharset(@Nullable Strs charset)
  
  Obtains the character set for the [current locale][setlocale]; you
  might use this character set as an argument to g_convert(), to convert
  from the current locale's encoding to some other encoding. (Frequently
  g_locale_to_utf8() and g_locale_from_utf8() are nice shortcuts, though.)
  
  On Windows the character set returned by this function is the
  so-called system default ANSI code-page. That is the character set
  used by the "narrow" versions of C library and Win32 functions that
  handle file names. It might be different from the character set
  used by the C library's current locale.
  
  On Linux, the character set is found by consulting nl_langinfo() if
  available. If not, the environment variables `LC_ALL`, `LC_CTYPE`, `LANG`
  and `CHARSET` are queried in order.
  
  The return value is %TRUE if the locale's encoding is UTF-8, in that
  case you can perhaps avoid calling g_convert().
  
  The string returned in @charset is not allocated, and should not be
  freed.
  
  Parameters:
  
  charset - return location for character set name, or %NULL.
  
  Returns:
  
  %TRUE if the returned charset is UTF-8
- getCodeset
  
  public static Str getCodeset()
  
  Gets the character set for the current locale.
  
  Returns:
  
  a newly allocated string containing the name of the character set. This string must be freed with g_free().
- getConsoleCharset
  
  public static boolean getConsoleCharset(@Nullable Strs charset)
  
  Obtains the character set used by the console attached to the process,
  which is suitable for printing output to the terminal.
  
  Usually this matches the result returned by g_get_charset(), but in
  environments where the locale's character set does not match the encoding
  of the console this function tries to guess a more suitable value instead.
  
  On Windows the character set returned by this function is the
  output code page used by the console associated with the calling process.
  If the codepage can't be determined (for example because there is no
  console attached) UTF-8 is assumed.
  
  The return value is %TRUE if the locale's encoding is UTF-8, in that
  case you can perhaps avoid calling g_convert().
  
  The string returned in @charset is not allocated, and should not be
  freed.
  
  Parameters:
  
  charset - return location for character set name, or %NULL.
  
  Returns:
  
  %TRUE if the returned charset is UTF-8
- getCurrentDir
  
  public static Str getCurrentDir()
  
  Gets the current directory.
  
  The returned string should be freed when no longer needed.
  The encoding of the returned string is system defined.
  On Windows, it is always UTF-8.
  
  Since GLib 2.40, this function will return the value of the "PWD"
  environment variable if it is set and it happens to be the same as
  the current directory. This can make a difference in the case that
  the current directory is the target of a symbolic link.
  
  Returns:
  
  the current directory
- getHomeDir
  
  public static Str getHomeDir()
  
  Gets the current user's home directory.
  
  As with most UNIX tools, this function will return the value of the
  `HOME` environment variable if it is set to an existing absolute path
  name, falling back to the `passwd` file in the case that it is unset.
  
  If the path given in `HOME` is non-absolute, does not exist, or is
  not a directory, the result is undefined.
  
  Before version 2.36 this function would ignore the `HOME` environment
  variable, taking the value from the `passwd` database instead. This was
  changed to increase the compatibility of GLib with other programs (and
  the XDG basedir specification) and to increase testability of programs
  based on GLib (by making it easier to run them from test frameworks).
  
  If your program has a strong requirement for either the new or the
  old behaviour (and if you don't wish to increase your GLib
  dependency to ensure that the new behaviour is in effect) then you
  should either directly check the `HOME` environment variable yourself
  or unset it before calling any functions in GLib.
  
  Returns:
  
  the current user's home directory
- getHostName
  
  public static Str getHostName()
  
  Return a name for the machine.
  
  The returned name is not necessarily a fully-qualified domain name,
  or even present in DNS or some other name service at all. It need
  not even be unique on your local network or site, but usually it
  is. Callers should not rely on the return value having any specific
  properties like uniqueness for security purposes. Even if the name
  of the machine is changed while an application is running, the
  return value from this function does not change. The returned
  string is owned by GLib and should not be modified or freed. If no
  name can be determined, a default fixed string "localhost" is
  returned.
  
  The encoding of the returned string is UTF-8.
  
  Returns:
  
  the host name of the machine.
- getMonotonicTime
  
  public static long getMonotonicTime()
  
  Queries the system monotonic time.
  
  The monotonic clock will always increase and doesn't suffer
  discontinuities when the user (or NTP) changes the system time. It
  may or may not continue to tick during times where the machine is
  suspended.
  
  We try to use the clock that corresponds as closely as possible to
  the passage of time as measured by system calls such as poll() but it
  may not always be possible to do this.
  
  Returns:
  
  the monotonic time, in microseconds
- getNumProcessors
  
  public static int getNumProcessors()
  
  Determine the approximate number of threads that the system will
  schedule simultaneously for this process. This is intended to be
  used as a parameter to g_thread_pool_new() for CPU bound tasks and
  similar cases.
  
  Returns:
  
  Number of schedulable threads, always greater than 0
- getOsInfo
  
  public static Str getOsInfo(@Nonnull Str key_name)
  
  Get information about the operating system.
  
  On Linux this comes from the `/etc/os-release` file. On other systems, it may
  come from a variety of sources. You can either use the standard key names
  like %G_OS_INFO_KEY_NAME or pass any UTF-8 string key name. For example,
  `/etc/os-release` provides a number of other less commonly used values that may
  be useful. No key is guaranteed to be provided, so the caller should always
  check if the result is %NULL.
  
  Parameters:
  
  key_name - a key for the OS info being requested, for example %G_OS_INFO_KEY_NAME.
  
  Returns:
  
  The associated value for the requested key or %NULL if this information is not provided.
- getPrgname
  
  public static Str getPrgname()
  
  Gets the name of the program. This name should not be localized,
  in contrast to g_get_application_name().
  
  If you are using #GApplication the program name is set in
  g_application_run(). In case of GDK or GTK+ it is set in
  gdk_init(), which is called by gtk_init() and the
  #GtkApplication::startup handler. The program name is found by
  taking the last component of @argv[0].
  
  Returns:
  
  the name of the program, or %NULL if it has not been set yet. The returned string belongs to GLib and must not be modified or freed.
- getRealName
  
  public static Str getRealName()
  
  Gets the real name of the user. This usually comes from the user's
  entry in the `passwd` file. The encoding of the returned string is
  system-defined. (On Windows, it is, however, always UTF-8.) If the
  real user name cannot be determined, the string "Unknown" is
  returned.
  
  Returns:
  
  the user's real name.
- getRealTime
  
  public static long getRealTime()
  
  Queries the system wall-clock time.
  
  This call is functionally equivalent to g_get_current_time() except
  that the return value is often more convenient than dealing with a
  #GTimeVal.
  
  You should only use this call if you are actually interested in the real
  wall-clock time. g_get_monotonic_time() is probably more useful for
  measuring intervals.
  
  Returns:
  
  the number of microseconds since January 1, 1970 UTC.
- getTmpDir
  
  public static Str getTmpDir()
  
  Gets the directory to use for temporary files.
  
  On UNIX, this is taken from the `TMPDIR` environment variable.
  If the variable is not set, `P_tmpdir` is
  used, as defined by the system C library. Failing that, a
  hard-coded default of "/tmp" is returned.
  
  On Windows, the `TEMP` environment variable is used, with the
  root directory of the Windows installation (eg: "C:\") used
  as a default.
  
  The encoding of the returned string is system-defined. On Windows,
  it is always UTF-8. The return value is never %NULL or the empty
  string.
  
  Returns:
  
  the directory to use for temporary files.
- getUserCacheDir
  
  public static Str getUserCacheDir()
  
  Returns a base directory in which to store non-essential, cached
  data specific to particular user.
  
  On UNIX platforms this is determined using the mechanisms described
  in the
  [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
  In this case the directory retrieved will be `XDG_CACHE_HOME`.
  
  On Windows it follows XDG Base Directory Specification if `XDG_CACHE_HOME` is defined.
  If `XDG_CACHE_HOME` is undefined, the directory that serves as a common
  repository for temporary Internet files is used instead. A typical path is
  `C:\Documents and Settings\username\Local Settings\Temporary Internet Files`.
  See the [documentation for `FOLDERID_InternetCache`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
  
  The return value is cached and modifying it at runtime is not supported, as
  it’s not thread-safe to modify environment variables at runtime.
  
  Returns:
  
  a string owned by GLib that must not be modified or freed.
- getUserConfigDir
  
  public static Str getUserConfigDir()
  
  Returns a base directory in which to store user-specific application
  configuration information such as user preferences and settings.
  
  On UNIX platforms this is determined using the mechanisms described
  in the
  [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
  In this case the directory retrieved will be `XDG_CONFIG_HOME`.
  
  On Windows it follows XDG Base Directory Specification if `XDG_CONFIG_HOME` is defined.
  If `XDG_CONFIG_HOME` is undefined, the folder to use for local (as opposed
  to roaming) application data is used instead. See the
  [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
  Note that in this case on Windows it will be the same
  as what g_get_user_data_dir() returns.
  
  The return value is cached and modifying it at runtime is not supported, as
  it’s not thread-safe to modify environment variables at runtime.
  
  Returns:
  
  a string owned by GLib that must not be modified or freed.
- getUserDataDir
  
  public static Str getUserDataDir()
  
  Returns a base directory in which to access application data such
  as icons that is customized for a particular user.
  
  On UNIX platforms this is determined using the mechanisms described
  in the
  [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
  In this case the directory retrieved will be `XDG_DATA_HOME`.
  
  On Windows it follows XDG Base Directory Specification if `XDG_DATA_HOME`
  is defined. If `XDG_DATA_HOME` is undefined, the folder to use for local (as
  opposed to roaming) application data is used instead. See the
  [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
  Note that in this case on Windows it will be the same
  as what g_get_user_config_dir() returns.
  
  The return value is cached and modifying it at runtime is not supported, as
  it’s not thread-safe to modify environment variables at runtime.
  
  Returns:
  
  a string owned by GLib that must not be modified or freed.
- getUserName
  
  public static Str getUserName()
  
  Gets the user name of the current user. The encoding of the returned
  string is system-defined. On UNIX, it might be the preferred file name
  encoding, or something else, and there is no guarantee that it is even
  consistent on a machine. On Windows, it is always UTF-8.
  
  Returns:
  
  the user name of the current user.
- getUserRuntimeDir
  
  public static Str getUserRuntimeDir()
  
  Returns a directory that is unique to the current user on the local
  system.
  
  This is determined using the mechanisms described
  in the
  [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
  This is the directory
  specified in the `XDG_RUNTIME_DIR` environment variable.
  In the case that this variable is not set, we return the value of
  g_get_user_cache_dir(), after verifying that it exists.
  
  The return value is cached and modifying it at runtime is not supported, as
  it’s not thread-safe to modify environment variables at runtime.
  
  Returns:
  
  a string owned by GLib that must not be modified or freed.
- getUserSpecialDir
  
  public static Str getUserSpecialDir(int directory)
  
  Returns the full path of a special directory using its logical id.
  
  On UNIX this is done using the XDG special user directories.
  For compatibility with existing practise, %G_USER_DIRECTORY_DESKTOP
  falls back to `$HOME/Desktop` when XDG special user directories have
  not been set up.
  
  Depending on the platform, the user might be able to change the path
  of the special directory without requiring the session to restart; GLib
  will not reflect any change once the special directories are loaded.
  
  Parameters:
  
  directory - the logical id of special directory
  
  Returns:
  
  the path to the specified special directory, or %NULL if the logical id was not found. The returned string is owned by GLib and should not be modified or freed.
- getUserStateDir
  
  public static Str getUserStateDir()
  
  Returns a base directory in which to store state files specific to
  particular user.
  
  On UNIX platforms this is determined using the mechanisms described
  in the
  [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
  In this case the directory retrieved will be `XDG_STATE_HOME`.
  
  On Windows it follows XDG Base Directory Specification if `XDG_STATE_HOME` is defined.
  If `XDG_STATE_HOME` is undefined, the folder to use for local (as opposed
  to roaming) application data is used instead. See the
  [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
  Note that in this case on Windows it will be the same
  as what g_get_user_data_dir() returns.
  
  The return value is cached and modifying it at runtime is not supported, as
  it’s not thread-safe to modify environment variables at runtime.
  
  Returns:
  
  a string owned by GLib that must not be modified or freed.
- getenv
  
  public static Str getenv(@Nonnull Str variable)
  
  Returns the value of an environment variable.
  
  On UNIX, the name and value are byte strings which might or might not
  be in some consistent character set and encoding. On Windows, they are
  in UTF-8.
  On Windows, in case the environment variable's value contains
  references to other environment variables, they are expanded.
  
  Parameters:
  
  variable - the environment variable to get
  
  Returns:
  
  the value of the environment variable, or %NULL if the environment variable is not found. The returned string may be overwritten by the next call to g_getenv(), g_setenv() or g_unsetenv().
- hashTableAdd
  
  public static boolean hashTableAdd(@Nonnull HashTable hash_table, @Nullable Pointer key)
  
  This is a convenience function for using a #GHashTable as a set. It
  is equivalent to calling g_hash_table_replace() with @key as both the
  key and the value.
  
  In particular, this means that if @key already exists in the hash table, then
  the old copy of @key in the hash table is freed and @key replaces it in the
  table.
  
  When a hash table only ever contains keys that have themselves as the
  corresponding value it is able to be stored more efficiently. See
  the discussion in the section description.
  
  Starting from GLib 2.40, this function returns a boolean value to
  indicate whether the newly added value was already in the hash table
  or not.
  
  Parameters:
  
  hash_table - a #GHashTable
  
  key - a key to insert
  
  Returns:
  
  %TRUE if the key did not exist yet
- hashTableContains
  
  public static boolean hashTableContains(@Nonnull HashTable hash_table, @Nullable Pointer key)
  
  Checks if @key is in @hash_table.
  
  Parameters:
  
  hash_table - a #GHashTable
  
  key - a key to check
  
  Returns:
  
  %TRUE if @key is in @hash_table, %FALSE otherwise.
- hashTableDestroy
  
  public static void hashTableDestroy(@Nonnull HashTable hash_table)
  
  Destroys all keys and values in the #GHashTable and decrements its
  reference count by 1. If keys and/or values are dynamically allocated,
  you should either free them first or create the #GHashTable with destroy
  notifiers using g_hash_table_new_full(). In the latter case the destroy
  functions you supplied will be called on all keys and values during the
  destruction phase.
  
  Parameters:
  
  hash_table - a #GHashTable
- hashTableInsert
  
  public static boolean hashTableInsert(@Nonnull HashTable hash_table, @Nullable Pointer key, @Nullable Pointer value)
  
  Inserts a new key and value into a #GHashTable.
  
  If the key already exists in the #GHashTable its current
  value is replaced with the new value. If you supplied a
  @value_destroy_func when creating the #GHashTable, the old
  value is freed using that function. If you supplied a
  @key_destroy_func when creating the #GHashTable, the passed
  key is freed using that function.
  
  Starting from GLib 2.40, this function returns a boolean value to
  indicate whether the newly added value was already in the hash table
  or not.
  
  Parameters:
  
  hash_table - a #GHashTable
  
  key - a key to insert
  
  value - the value to associate with the key
  
  Returns:
  
  %TRUE if the key did not exist yet
- hashTableLookup
  
  public static Pointer hashTableLookup(@Nonnull HashTable hash_table, @Nullable Pointer key)
  
  Looks up a key in a #GHashTable. Note that this function cannot
  distinguish between a key that is not present and one which is present
  and has the value %NULL. If you need this distinction, use
  g_hash_table_lookup_extended().
  
  Parameters:
  
  hash_table - a #GHashTable
  
  key - the key to look up
  
  Returns:
  
  the associated value, or %NULL if the key is not found
- hashTableNewSimilar
  
  public static HashTable hashTableNewSimilar(@Nonnull HashTable other_hash_table)
  
  Creates a new #GHashTable like g_hash_table_new_full() with a reference
  count of 1.
  
  It inherits the hash function, the key equal function, the key destroy function,
  as well as the value destroy function, from @other_hash_table.
  
  The returned hash table will be empty; it will not contain the keys
  or values from @other_hash_table.
  
  Parameters:
  
  other_hash_table - Another #GHashTable
  
  Returns:
  
  a new #GHashTable
- hashTableRemove
  
  public static boolean hashTableRemove(@Nonnull HashTable hash_table, @Nullable Pointer key)
  
  Removes a key and its associated value from a #GHashTable.
  
  If the #GHashTable was created using g_hash_table_new_full(), the
  key and value are freed using the supplied destroy functions, otherwise
  you have to make sure that any dynamically allocated values are freed
  yourself.
  
  Parameters:
  
  hash_table - a #GHashTable
  
  key - the key to remove
  
  Returns:
  
  %TRUE if the key was found and removed from the #GHashTable
- hashTableRemoveAll
  
  public static void hashTableRemoveAll(@Nonnull HashTable hash_table)
  
  Removes all keys and their associated values from a #GHashTable.
  
  If the #GHashTable was created using g_hash_table_new_full(),
  the keys and values are freed using the supplied destroy functions,
  otherwise you have to make sure that any dynamically allocated
  values are freed yourself.
  
  Parameters:
  
  hash_table - a #GHashTable
- hashTableReplace
  
  public static boolean hashTableReplace(@Nonnull HashTable hash_table, @Nullable Pointer key, @Nullable Pointer value)
  
  Inserts a new key and value into a #GHashTable similar to
  g_hash_table_insert(). The difference is that if the key
  already exists in the #GHashTable, it gets replaced by the
  new key. If you supplied a @value_destroy_func when creating
  the #GHashTable, the old value is freed using that function.
  If you supplied a @key_destroy_func when creating the
  #GHashTable, the old key is freed using that function.
  
  Starting from GLib 2.40, this function returns a boolean value to
  indicate whether the newly added value was already in the hash table
  or not.
  
  Parameters:
  
  hash_table - a #GHashTable
  
  key - a key to insert
  
  value - the value to associate with the key
  
  Returns:
  
  %TRUE if the key did not exist yet
- hashTableSize
  
  public static int hashTableSize(@Nonnull HashTable hash_table)
  
  Returns the number of elements contained in the #GHashTable.
  
  Parameters:
  
  hash_table - a #GHashTable
  
  Returns:
  
  the number of key/value pairs in the #GHashTable.
- hashTableSteal
  
  public static boolean hashTableSteal(@Nonnull HashTable hash_table, @Nullable Pointer key)
  
  Removes a key and its associated value from a #GHashTable without
  calling the key and value destroy functions.
  
  Parameters:
  
  hash_table - a #GHashTable
  
  key - the key to remove
  
  Returns:
  
  %TRUE if the key was found and removed from the #GHashTable
- hashTableStealAll
  
  public static void hashTableStealAll(@Nonnull HashTable hash_table)
  
  Removes all keys and their associated values from a #GHashTable
  without calling the key and value destroy functions.
  
  Parameters:
  
  hash_table - a #GHashTable
- hashTableUnref
  
  public static void hashTableUnref(@Nonnull HashTable hash_table)
  
  Atomically decrements the reference count of @hash_table by one.
  If the reference count drops to 0, all keys and values will be
  destroyed, and all memory allocated by the hash table is released.
  This function is MT-safe and may be called from any thread.
  
  Parameters:
  
  hash_table - a valid #GHashTable
- hookDestroy
  
  public static boolean hookDestroy(@Nonnull HookList hook_list, long hook_id)
  
  Destroys a #GHook, given its ID.
  
  Parameters:
  
  hook_list - a #GHookList
  
  hook_id - a hook ID
  
  Returns:
  
  %TRUE if the #GHook was found in the #GHookList and destroyed
- hookDestroyLink
  
  public static void hookDestroyLink(@Nonnull HookList hook_list, @Nonnull Hook hook)
  
  Removes one #GHook from a #GHookList, marking it
  inactive and calling g_hook_unref() on it.
  
  Parameters:
  
  hook_list - a #GHookList
  
  hook - the #GHook to remove
- hookFree
  
  public static void hookFree(@Nonnull HookList hook_list, @Nonnull Hook hook)
  
  Calls the #GHookList @finalize_hook function if it exists,
  and frees the memory allocated for the #GHook.
  
  Parameters:
  
  hook_list - a #GHookList
  
  hook - the #GHook to free
- hookInsertBefore
  
  public static void hookInsertBefore(@Nonnull HookList hook_list, @Nullable Hook sibling, @Nonnull Hook hook)
  
  Inserts a #GHook into a #GHookList, before a given #GHook.
  
  Parameters:
  
  hook_list - a #GHookList
  
  sibling - the #GHook to insert the new #GHook before
  
  hook - the #GHook to insert
- hookPrepend
  
  public static void hookPrepend(@Nonnull HookList hook_list, @Nonnull Hook hook)
  
  Prepends a #GHook on the start of a #GHookList.
  
  Parameters:
  
  hook_list - a #GHookList
  
  hook - the #GHook to add to the start of @hook_list
- hookUnref
  
  public static void hookUnref(@Nonnull HookList hook_list, @Nonnull Hook hook)
  
  Decrements the reference count of a #GHook.
  If the reference count falls to 0, the #GHook is removed
  from the #GHookList and g_hook_free() is called to free it.
  
  Parameters:
  
  hook_list - a #GHookList
  
  hook - the #GHook to unref
- hostnameIsAsciiEncoded
  
  public static boolean hostnameIsAsciiEncoded(@Nonnull Str hostname)
  
  Tests if @hostname contains segments with an ASCII-compatible
  encoding of an Internationalized Domain Name. If this returns
  %TRUE, you should decode the hostname with g_hostname_to_unicode()
  before displaying it to the user.
  
  Note that a hostname might contain a mix of encoded and unencoded
  segments, and so it is possible for g_hostname_is_non_ascii() and
  g_hostname_is_ascii_encoded() to both return %TRUE for a name.
  
  Parameters:
  
  hostname - a hostname
  
  Returns:
  
  %TRUE if @hostname contains any ASCII-encoded segments.
- hostnameIsIpAddress
  
  public static boolean hostnameIsIpAddress(@Nonnull Str hostname)
  
  Tests if @hostname is the string form of an IPv4 or IPv6 address.
  (Eg, "192.168.0.1".)
  
  Since 2.66, IPv6 addresses with a zone-id are accepted (RFC6874).
  
  Parameters:
  
  hostname - a hostname (or IP address in string form)
  
  Returns:
  
  %TRUE if @hostname is an IP address
- hostnameIsNonAscii
  
  public static boolean hostnameIsNonAscii(@Nonnull Str hostname)
  
  Tests if @hostname contains Unicode characters. If this returns
  %TRUE, you need to encode the hostname with g_hostname_to_ascii()
  before using it in non-IDN-aware contexts.
  
  Note that a hostname might contain a mix of encoded and unencoded
  segments, and so it is possible for g_hostname_is_non_ascii() and
  g_hostname_is_ascii_encoded() to both return %TRUE for a name.
  
  Parameters:
  
  hostname - a hostname
  
  Returns:
  
  %TRUE if @hostname contains any non-ASCII characters
- hostnameToAscii
  
  public static Str hostnameToAscii(@Nonnull Str hostname)
  
  Converts @hostname to its canonical ASCII form; an ASCII-only
  string containing no uppercase letters and not ending with a
  trailing dot.
  
  Parameters:
  
  hostname - a valid UTF-8 or ASCII hostname
  
  Returns:
  
  an ASCII hostname, which must be freed, or %NULL if @hostname is in some way invalid.
- hostnameToUnicode
  
  public static Str hostnameToUnicode(@Nonnull Str hostname)
  
  Converts @hostname to its canonical presentation form; a UTF-8
  string in Unicode normalization form C, containing no uppercase
  letters, no forbidden characters, and no ASCII-encoded segments,
  and not ending with a trailing dot.
  
  Of course if @hostname is not an internationalized hostname, then
  the canonical presentation form will be entirely ASCII.
  
  Parameters:
  
  hostname - a valid UTF-8 or ASCII hostname
  
  Returns:
  
  a UTF-8 hostname, which must be freed, or %NULL if @hostname is in some way invalid.
- idleAdd
  
  public static int idleAdd(Glib.OnSourceFunc function, @Nullable Pointer data)
  
  Adds a function to be called whenever there are no higher priority
  events pending to the default main loop. The function is given the
  default idle priority, %G_PRIORITY_DEFAULT_IDLE. If the function
  returns %FALSE it is automatically removed from the list of event
  sources and will not be called again.
  
  See [memory management of sources][mainloop-memory-management] for details
  on how to handle the return value and memory management of @data.
  
  This internally creates a main loop source using g_idle_source_new()
  and attaches it to the global #GMainContext using g_source_attach(), so
  the callback will be invoked in whichever thread is running that main
  context. You can do these steps manually if you need greater control or to
  use a custom main context.
  
  Parameters:
  
  function - function to call
  
  data - data to pass to @function.
  
  Returns:
  
  the ID (greater than 0) of the event source.
- idleAddFull
  
  public static int idleAddFull(int priority, Glib.OnSourceFunc function, @Nullable Pointer data, Glib.OnDestroyNotify notify)
  
  Adds a function to be called whenever there are no higher priority
  events pending.
  
  If the function returns %G_SOURCE_REMOVE or %FALSE it is automatically
  removed from the list of event sources and will not be called again.
  
  See [memory management of sources][mainloop-memory-management] for details
  on how to handle the return value and memory management of @data.
  
  This internally creates a main loop source using g_idle_source_new()
  and attaches it to the global #GMainContext using g_source_attach(), so
  the callback will be invoked in whichever thread is running that main
  context. You can do these steps manually if you need greater control or to
  use a custom main context.
  
  Parameters:
  
  priority - the priority of the idle source. Typically this will be in the range between %G_PRIORITY_DEFAULT_IDLE and %G_PRIORITY_HIGH_IDLE.
  
  function - function to call
  
  data - data to pass to @function
  
  notify - function to call when the idle is removed, or %NULL
  
  Returns:
  
  the ID (greater than 0) of the event source.
- idleAddOnce
  
  public static int idleAddOnce(Glib.OnSourceOnceFunc function, @Nullable Pointer data)
  
  Adds a function to be called whenever there are no higher priority
  events pending to the default main loop. The function is given the
  default idle priority, %G_PRIORITY_DEFAULT_IDLE.
  
  The function will only be called once and then the source will be
  automatically removed from the main context.
  
  This function otherwise behaves like g_idle_add().
  
  Parameters:
  
  function - function to call
  
  data - data to pass to @function
  
  Returns:
  
  the ID (greater than 0) of the event source
- idleRemoveByData
  
  public static boolean idleRemoveByData(@Nullable Pointer data)
  
  Removes the idle function with the given data.
  
  Parameters:
  
  data - the data for the idle source's callback.
  
  Returns:
  
  %TRUE if an idle source was found and removed.
- idleSourceNew
  
  public static Source idleSourceNew()
  
  Creates a new idle source.
  
  The source will not initially be associated with any #GMainContext
  and must be added to one with g_source_attach() before it will be
  executed. Note that the default priority for idle sources is
  %G_PRIORITY_DEFAULT_IDLE, as compared to other sources which
  have a default priority of %G_PRIORITY_DEFAULT.
  
  Returns:
  
  the newly-created idle source
- int64Equal
  
  public static boolean int64Equal(@Nonnull Pointer v1, @Nonnull Pointer v2)
  
  Compares the two #gint64 values being pointed to and returns
  %TRUE if they are equal.
  It can be passed to g_hash_table_new() as the @key_equal_func
  parameter, when using non-%NULL pointers to 64-bit integers as keys in a
  #GHashTable.
  
  Parameters:
  
  v1 - a pointer to a #gint64 key
  
  v2 - a pointer to a #gint64 key to compare with @v1
  
  Returns:
  
  %TRUE if the two keys match.
- int64Hash
  
  public static int int64Hash(@Nonnull Pointer v)
  
  Converts a pointer to a #gint64 to a hash value.
  
  It can be passed to g_hash_table_new() as the @hash_func parameter,
  when using non-%NULL pointers to 64-bit integer values as keys in a
  #GHashTable.
  
  Parameters:
  
  v - a pointer to a #gint64 key
  
  Returns:
  
  a hash value corresponding to the key.
- intEqual
  
  public static boolean intEqual(@Nonnull Pointer v1, @Nonnull Pointer v2)
  
  Compares the two #gint values being pointed to and returns
  %TRUE if they are equal.
  It can be passed to g_hash_table_new() as the @key_equal_func
  parameter, when using non-%NULL pointers to integers as keys in a
  #GHashTable.
  
  Note that this function acts on pointers to #gint, not on #gint
  directly: if your hash table's keys are of the form
  `GINT_TO_POINTER (n)`, use g_direct_equal() instead.
  
  Parameters:
  
  v1 - a pointer to a #gint key
  
  v2 - a pointer to a #gint key to compare with @v1
  
  Returns:
  
  %TRUE if the two keys match.
- intHash
  
  public static int intHash(@Nonnull Pointer v)
  
  Converts a pointer to a #gint to a hash value.
  It can be passed to g_hash_table_new() as the @hash_func parameter,
  when using non-%NULL pointers to integer values as keys in a #GHashTable.
  
  Note that this function acts on pointers to #gint, not on #gint
  directly: if your hash table's keys are of the form
  `GINT_TO_POINTER (n)`, use g_direct_hash() instead.
  
  Parameters:
  
  v - a pointer to a #gint key
  
  Returns:
  
  a hash value corresponding to the key.
- internStaticString
  
  public static Str internStaticString(@Nullable Str string)
  
  Returns a canonical representation for @string. Interned strings
  can be compared for equality by comparing the pointers, instead of
  using strcmp(). g_intern_static_string() does not copy the string,
  therefore @string must not be freed or modified.
  
  This function must not be used before library constructors have finished
  running. In particular, this means it cannot be used to initialize global
  variables in C++.
  
  Parameters:
  
  string - a static string
  
  Returns:
  
  a canonical representation for the string
- internString
  
  public static Str internString(@Nullable Str string)
  
  Returns a canonical representation for @string. Interned strings
  can be compared for equality by comparing the pointers, instead of
  using strcmp().
  
  This function must not be used before library constructors have finished
  running. In particular, this means it cannot be used to initialize global
  variables in C++.
  
  Parameters:
  
  string - a string
  
  Returns:
  
  a canonical representation for the string
- ioAddWatch
  
  public static int ioAddWatch(@Nonnull IOChannel channel, int condition, Glib.OnIOFunc func, @Nullable Pointer user_data)
  
  Adds the #GIOChannel into the default main loop context
  with the default priority.
  
  Parameters:
  
  channel - a #GIOChannel
  
  condition - the condition to watch for
  
  func - the function to call when the condition is satisfied
  
  user_data - user data to pass to @func
  
  Returns:
  
  the event source id
- ioAddWatchFull
  
  public static int ioAddWatchFull(@Nonnull IOChannel channel, int priority, int condition, Glib.OnIOFunc func, @Nullable Pointer user_data, Glib.OnDestroyNotify notify)
  
  Adds the #GIOChannel into the default main loop context
  with the given priority.
  
  This internally creates a main loop source using g_io_create_watch()
  and attaches it to the main loop context with g_source_attach().
  You can do these steps manually if you need greater control.
  
  Parameters:
  
  channel - a #GIOChannel
  
  priority - the priority of the #GIOChannel source
  
  condition - the condition to watch for
  
  func - the function to call when the condition is satisfied
  
  user_data - user data to pass to @func
  
  notify - the function to call when the source is removed
  
  Returns:
  
  the event source id
- ioChannelErrorFromErrno
  
  public static int ioChannelErrorFromErrno(int en)
  
  Converts an `errno` error number to a #GIOChannelError.
  
  Parameters:
  
  en - an `errno` error number, e.g. `EINVAL`
  
  Returns:
  
  a #GIOChannelError error number, e.g. %G_IO_CHANNEL_ERROR_INVAL.
- ioChannelErrorQuark
  
  public static int ioChannelErrorQuark()
  
  Returns:
- ioCreateWatch
  
  public static Source ioCreateWatch(@Nonnull IOChannel channel, int condition)
  
  Creates a #GSource that's dispatched when @condition is met for the
  given @channel. For example, if condition is %G_IO_IN, the source will
  be dispatched when there's data available for reading.
  
  The callback function invoked by the #GSource should be added with
  g_source_set_callback(), but it has type #GIOFunc (not #GSourceFunc).
  
  g_io_add_watch() is a simpler interface to this same functionality, for
  the case where you want to add the source to the default main loop context
  at the default priority.
  
  On Windows, polling a #GSource created to watch a channel for a socket
  puts the socket in non-blocking mode. This is a side-effect of the
  implementation and unavoidable.
  
  Parameters:
  
  channel - a #GIOChannel to watch
  
  condition - conditions to watch for
  
  Returns:
  
  a new #GSource
- keyFileErrorQuark
  
  public static int keyFileErrorQuark()
  
  Returns:
- localeFromUtf8
  
  public static Str localeFromUtf8(@Nonnull Str utf8string, long len, @Nullable Int64 bytes_read, @Nullable Int64 bytes_written) throws AllocationError
  
  Converts a string from UTF-8 to the encoding used for strings by
  the C runtime (usually the same as that used by the operating
  system) in the [current locale][setlocale]. On Windows this means
  the system codepage.
  
  The input string shall not contain nul characters even if the @len
  argument is positive. A nul character found inside the string will result
  in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. Use g_convert() to convert
  input that may contain embedded nul characters.
  
  Parameters:
  
  utf8string - a UTF-8 encoded string
  
  len - the length of the string, or -1 if the string is nul-terminated.
  
  bytes_read - location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will be the byte offset after the last valid input sequence.
  
  bytes_written - the number of bytes stored in the output buffer (not including the terminating nul).
  
  Returns:
  
  A newly-allocated buffer containing the converted string, or %NULL on an error, and error will be set.
  
  Throws:
  
  AllocationError
- localeToUtf8
  
  public static Str localeToUtf8(@Nonnull Str opsysstring, long len, @Nullable Int64 bytes_read, @Nullable Int64 bytes_written) throws AllocationError
  
  Converts a string which is in the encoding used for strings by
  the C runtime (usually the same as that used by the operating
  system) in the [current locale][setlocale] into a UTF-8 string.
  
  If the source encoding is not UTF-8 and the conversion output contains a
  nul character, the error %G_CONVERT_ERROR_EMBEDDED_NUL is set and the
  function returns %NULL.
  If the source encoding is UTF-8, an embedded nul character is treated with
  the %G_CONVERT_ERROR_ILLEGAL_SEQUENCE error for backward compatibility with
  earlier versions of this library. Use g_convert() to produce output that
  may contain embedded nul characters.
  
  Parameters:
  
  opsysstring - a string in the encoding of the current locale. On Windows this means the system codepage.
  
  len - the length of the string, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe)
  
  bytes_read - location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will be the byte offset after the last valid input sequence.
  
  bytes_written - the number of bytes stored in the output buffer (not including the terminating nul).
  
  Returns:
  
  The converted string, or %NULL on an error.
  
  Throws:
  
  AllocationError
- log
  
  public static void log(@Nullable Str log_domain, int log_level, @Nonnull Str format, Object... _elipse)
  
  Logs an error or debugging message.
  
  If the log level has been set as fatal, G_BREAKPOINT() is called
  to terminate the program. See the documentation for G_BREAKPOINT() for
  details of the debugging options this provides.
  
  If g_log_default_handler() is used as the log handler function, a new-line
  character will automatically be appended to @..., and need not be entered
  manually.
  
  If [structured logging is enabled][using-structured-logging] this will
  output via the structured log writer function (see g_log_set_writer_func()).
  
  Parameters:
  
  log_domain - the log domain, usually %G_LOG_DOMAIN, or %NULL for the default
  
  log_level - the log level, either from #GLogLevelFlags or a user-defined level
  
  format - the message format. See the `printf()` documentation
  
  _elipse - the parameters to insert into the format string
- logDefaultHandler
  
  public static void logDefaultHandler(@Nullable Str log_domain, int log_level, @Nullable Str message, @Nullable Pointer unused_data)
  
  The default log handler set up by GLib; g_log_set_default_handler()
  allows to install an alternate default log handler.
  This is used if no log handler has been set for the particular log
  domain and log level combination. It outputs the message to stderr
  or stdout and if the log level is fatal it calls G_BREAKPOINT(). It automatically
  prints a new-line character after the message, so one does not need to be
  manually included in @message.
  
  The behavior of this log handler can be influenced by a number of
  environment variables:
  
  - `G_MESSAGES_PREFIXED`: A :-separated list of log levels for which
  messages should be prefixed by the program name and PID of the
  application.
  
  - `G_MESSAGES_DEBUG`: A space-separated list of log domains for
  which debug and informational messages are printed. By default
  these messages are not printed.
  
  stderr is used for levels %G_LOG_LEVEL_ERROR, %G_LOG_LEVEL_CRITICAL,
  %G_LOG_LEVEL_WARNING and %G_LOG_LEVEL_MESSAGE. stdout is used for
  the rest, unless stderr was requested by
  g_log_writer_default_set_use_stderr().
  
  This has no effect if structured logging is enabled; see
  [Using Structured Logging][using-structured-logging].
  
  Parameters:
  
  log_domain - the log domain of the message, or %NULL for the default "" application domain
  
  log_level - the level of the message
  
  message - the message
  
  unused_data - data passed from g_log() which is unused
- logGetDebugEnabled
  
  public static boolean logGetDebugEnabled()
  
  Return whether debug output from the GLib logging system is enabled.
  
  Note that this should not be used to conditionalise calls to g_debug() or
  other logging functions; it should only be used from %GLogWriterFunc
  implementations.
  
  Note also that the value of this does not depend on `G_MESSAGES_DEBUG`; see
  the docs for g_log_set_debug_enabled().
  
  Returns:
  
  %TRUE if debug output is enabled, %FALSE otherwise
- logRemoveHandler
  
  public static void logRemoveHandler(@Nonnull Str log_domain, int handler_id)
  
  Removes the log handler.
  
  This has no effect if structured logging is enabled; see
  [Using Structured Logging][using-structured-logging].
  
  Parameters:
  
  log_domain - the log domain
  
  handler_id - the id of the handler, which was returned in g_log_set_handler()
- logSetAlwaysFatal
  
  public static int logSetAlwaysFatal(int fatal_mask)
  
  Sets the message levels which are always fatal, in any log domain.
  When a message with any of these levels is logged the program terminates.
  You can only set the levels defined by GLib to be fatal.
  %G_LOG_LEVEL_ERROR is always fatal.
  
  You can also make some message levels fatal at runtime by setting
  the `G_DEBUG` environment variable (see
  [Running GLib Applications](glib-running.html)).
  
  Libraries should not call this function, as it affects all messages logged
  by a process, including those from other libraries.
  
  Structured log messages (using g_log_structured() and
  g_log_structured_array()) are fatal only if the default log writer is used;
  otherwise it is up to the writer function to determine which log messages
  are fatal. See [Using Structured Logging][using-structured-logging].
  
  Parameters:
  
  fatal_mask - the mask containing bits set for each level of error which is to be fatal
  
  Returns:
  
  the old fatal mask
- logSetDebugEnabled
  
  public static void logSetDebugEnabled(boolean enabled)
  
  Enable or disable debug output from the GLib logging system for all domains.
  This value interacts disjunctively with `G_MESSAGES_DEBUG` — if either of
  them would allow a debug message to be outputted, it will be.
  
  Note that this should not be used from within library code to enable debug
  output — it is intended for external use.
  
  Parameters:
  
  enabled - %TRUE to enable debug output, %FALSE otherwise
- logSetFatalMask
  
  public static int logSetFatalMask(@Nonnull Str log_domain, int fatal_mask)
  
  Sets the log levels which are fatal in the given domain.
  %G_LOG_LEVEL_ERROR is always fatal.
  
  This has no effect on structured log messages (using g_log_structured() or
  g_log_structured_array()). To change the fatal behaviour for specific log
  messages, programs must install a custom log writer function using
  g_log_set_writer_func(). See
  [Using Structured Logging][using-structured-logging].
  
  This function is mostly intended to be used with
  %G_LOG_LEVEL_CRITICAL. You should typically not set
  %G_LOG_LEVEL_WARNING, %G_LOG_LEVEL_MESSAGE, %G_LOG_LEVEL_INFO or
  %G_LOG_LEVEL_DEBUG as fatal except inside of test programs.
  
  Parameters:
  
  log_domain - the log domain
  
  fatal_mask - the new fatal mask
  
  Returns:
  
  the old fatal mask for the log domain
- logSetHandler
  
  public static int logSetHandler(@Nullable Str log_domain, int log_levels, Glib.OnLogFunc log_func, @Nullable Pointer user_data)
  Sets the log handler for a domain and a set of log levels.
  
  To handle fatal and recursive messages the @log_levels parameter
  must be combined with the %G_LOG_FLAG_FATAL and %G_LOG_FLAG_RECURSION
  bit flags.
  
  Note that since the %G_LOG_LEVEL_ERROR log level is always fatal, if
  you want to set a handler for this log level you must combine it with
  %G_LOG_FLAG_FATAL.
  
  This has no effect if structured logging is enabled; see
  [Using Structured Logging][using-structured-logging].
  
  Here is an example for adding a log handler for all warning messages
  in the default domain:
  
   g_log_set_handler (NULL, G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, my_log_handler, NULL);
  
  This example adds a log handler for all critical messages from GTK+:
  
   g_log_set_handler ("Gtk", G_LOG_LEVEL_CRITICAL | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, my_log_handler, NULL);
  
  This example adds a log handler for all messages from GLib:
  
   g_log_set_handler ("GLib", G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, my_log_handler, NULL);
  Parameters:
  
  log_domain - the log domain, or %NULL for the default "" application domain
  
  log_levels - the log levels to apply the log handler for. To handle fatal and recursive messages as well, combine the log levels with the %G_LOG_FLAG_FATAL and %G_LOG_FLAG_RECURSION bit flags.
  
  log_func - the log handler function
  
  user_data - data passed to the log handler
  
  Returns:
  
  the id of the new handler
- logSetHandlerFull
  
  public static int logSetHandlerFull(@Nullable Str log_domain, int log_levels, Glib.OnLogFunc log_func, @Nullable Pointer user_data, Glib.OnDestroyNotify destroy)
  
  Like g_log_set_handler(), but takes a destroy notify for the @user_data.
  
  This has no effect if structured logging is enabled; see
  [Using Structured Logging][using-structured-logging].
  
  Parameters:
  
  log_domain - the log domain, or %NULL for the default "" application domain
  
  log_levels - the log levels to apply the log handler for. To handle fatal and recursive messages as well, combine the log levels with the %G_LOG_FLAG_FATAL and %G_LOG_FLAG_RECURSION bit flags.
  
  log_func - the log handler function
  
  user_data - data passed to the log handler
  
  destroy - destroy notify for @user_data, or %NULL
  
  Returns:
  
  the id of the new handler
- logStructured
  
  public static void logStructured(@Nonnull Str log_domain, int log_level, Object... _elipse)
  Log a message with structured data.
  
  The message will be passed through to the log writer set by the application
  using g_log_set_writer_func(). If the message is fatal (i.e. its log level
  is %G_LOG_LEVEL_ERROR), the program will be aborted by calling
  G_BREAKPOINT() at the end of this function. If the log writer returns
  %G_LOG_WRITER_UNHANDLED (failure), no other fallback writers will be tried.
  See the documentation for #GLogWriterFunc for information on chaining
  writers.
  
  The structured data is provided as key–value pairs, where keys are UTF-8
  strings, and values are arbitrary pointers — typically pointing to UTF-8
  strings, but that is not a requirement. To pass binary (non-nul-terminated)
  structured data, use g_log_structured_array(). The keys for structured data
  should follow the [systemd journal
  fields](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html)
  specification. It is suggested that custom keys are namespaced according to
  the code which sets them. For example, custom keys from GLib all have a
  `GLIB_` prefix.
  
  The @log_domain will be converted into a `GLIB_DOMAIN` field. @log_level will
  be converted into a
  [`PRIORITY`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#PRIORITY=)
  field. The format string will have its placeholders substituted for the provided
  values and be converted into a
  [`MESSAGE`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#MESSAGE=)
  field.
  
  Other fields you may commonly want to pass into this function:
  
  * [`MESSAGE_ID`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#MESSAGE_ID=)
  * [`CODE_FILE`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#CODE_FILE=)
  * [`CODE_LINE`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#CODE_LINE=)
  * [`CODE_FUNC`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#CODE_FUNC=)
  * [`ERRNO`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#ERRNO=)
  
  Note that `CODE_FILE`, `CODE_LINE` and `CODE_FUNC` are automatically set by
  the logging macros, G_DEBUG_HERE(), g_message(), g_warning(), g_critical(),
  g_error(), etc, if the symbols `G_LOG_USE_STRUCTURED` is defined before including
  `glib.h`.
  
  For example:
  
   g_log_structured (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "MESSAGE_ID", "06d4df59e6c24647bfe69d2c27ef0b4e", "MY_APPLICATION_CUSTOM_FIELD", "some debug string", "MESSAGE", "This is a debug message about pointer %p and integer %u.", some_pointer, some_integer);
  
  Note that each `MESSAGE_ID` must be [uniquely and randomly
  generated](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#MESSAGE_ID=).
  If adding a `MESSAGE_ID`, consider shipping a [message
  catalog](https://www.freedesktop.org/wiki/Software/systemd/catalog/) with
  your software.
  
  To pass a user data pointer to the log writer function which is specific to
  this logging call, you must use g_log_structured_array() and pass the pointer
  as a field with #GLogField.length set to zero, otherwise it will be
  interpreted as a string.
  
  For example:
  
   const GLogField fields[] = { { "MESSAGE", "This is a debug message.", -1 }, { "MESSAGE_ID", "fcfb2e1e65c3494386b74878f1abf893", -1 }, { "MY_APPLICATION_CUSTOM_FIELD", "some debug string", -1 }, { "MY_APPLICATION_STATE", state_object, 0 }, }; g_log_structured_array (G_LOG_LEVEL_DEBUG, fields, G_N_ELEMENTS (fields));
  
  Note also that, even if no other structured fields are specified, there
  must always be a `MESSAGE` key before the format string. The `MESSAGE`-format
  pair has to be the last of the key-value pairs, and `MESSAGE` is the only
  field for which printf()-style formatting is supported.
  
  The default writer function for `stdout` and `stderr` will automatically
  append a new-line character after the message, so you should not add one
  manually to the format string.
  Parameters:
  
  log_domain - log domain, usually %G_LOG_DOMAIN
  
  log_level - log level, either from #GLogLevelFlags, or a user-defined level
  
  _elipse - key-value pairs of structured data to add to the log entry, followed by the key "MESSAGE", followed by a printf()-style message format, followed by parameters to insert in the format string
- logStructuredStandard
  
  public static void logStructuredStandard(@Nonnull Str log_domain, int log_level, @Nonnull Str file, @Nonnull Str line, @Nonnull Str func, @Nonnull Str message_format, Object... _elipse)
  
  Parameters:
  
  log_domain -
  
  log_level -
  
  file -
  
  line -
  
  func -
  
  message_format -
  
  _elipse -
- logVariant
  
  public static void logVariant(@Nullable Str log_domain, int log_level, @Nonnull Variant fields)
  
  Log a message with structured data, accepting the data within a #GVariant. This
  version is especially useful for use in other languages, via introspection.
  
  The only mandatory item in the @fields dictionary is the "MESSAGE" which must
  contain the text shown to the user.
  
  The values in the @fields dictionary are likely to be of type String
  (%G_VARIANT_TYPE_STRING). Array of bytes (%G_VARIANT_TYPE_BYTESTRING) is also
  supported. In this case the message is handled as binary and will be forwarded
  to the log writer as such. The size of the array should not be higher than
  %G_MAXSSIZE. Otherwise it will be truncated to this size. For other types
  g_variant_print() will be used to convert the value into a string.
  
  For more details on its usage and about the parameters, see g_log_structured().
  
  Parameters:
  
  log_domain - log domain, usually %G_LOG_DOMAIN
  
  log_level - log level, either from #GLogLevelFlags, or a user-defined level
  
  fields - a dictionary (#GVariant of the type %G_VARIANT_TYPE_VARDICT) containing the key-value pairs of message data.
- logWriterDefaultSetUseStderr
  
  public static void logWriterDefaultSetUseStderr(boolean use_stderr)
  
  Configure whether the built-in log functions
  (g_log_default_handler() for the old-style API, and both
  g_log_writer_default() and g_log_writer_standard_streams() for the
  structured API) will output all log messages to `stderr`.
  
  By default, log messages of levels %G_LOG_LEVEL_INFO and
  %G_LOG_LEVEL_DEBUG are sent to `stdout`, and other log messages are
  sent to `stderr`. This is problematic for applications that intend
  to reserve `stdout` for structured output such as JSON or XML.
  
  This function sets global state. It is not thread-aware, and should be
  called at the very start of a program, before creating any other threads
  or creating objects that could create worker threads of their own.
  
  Parameters:
  
  use_stderr - If %TRUE, use `stderr` for log messages that would normally have appeared on `stdout`
- logWriterDefaultWouldDrop
  
  public static boolean logWriterDefaultWouldDrop(int log_level, @Nullable Str log_domain)
  Check whether g_log_writer_default() and g_log_default_handler() would
  ignore a message with the given domain and level.
  
  As with g_log_default_handler(), this function drops debug and informational
  messages unless their log domain (or `all`) is listed in the space-separated
  `G_MESSAGES_DEBUG` environment variable.
  
  This can be used when implementing log writers with the same filtering
  behaviour as the default, but a different destination or output format:
  
   if (g_log_writer_default_would_drop (log_level, log_domain)) return G_LOG_WRITER_HANDLED;
  
  or to skip an expensive computation if it is only needed for a debugging
  message, and `G_MESSAGES_DEBUG` is not set:
  
   if (!g_log_writer_default_would_drop (G_LOG_LEVEL_DEBUG, G_LOG_DOMAIN)) { gchar *result = expensive_computation (my_object); g_debug ("my_object result: %s", result); g_free (result); }
  Parameters:
  
  log_level - log level, either from #GLogLevelFlags, or a user-defined level
  
  log_domain - log domain
  
  Returns:
  
  %TRUE if the log message would be dropped by GLib's default log handlers
- logWriterIsJournald
  
  public static boolean logWriterIsJournald(int output_fd)
  Check whether the given @output_fd file descriptor is a connection to the
  systemd journal, or something else (like a log file or `stdout` or
  `stderr`).
  
  Invalid file descriptors are accepted and return %FALSE, which allows for
  the following construct without needing any additional error handling:
   is_journald = g_log_writer_is_journald (fileno (stderr));
  Parameters:
  
  output_fd - output file descriptor to check
  
  Returns:
  
  %TRUE if @output_fd points to the journal, %FALSE otherwise
- logWriterSupportsColor
  
  public static boolean logWriterSupportsColor(int output_fd)
  
  Check whether the given @output_fd file descriptor supports ANSI color
  escape sequences. If so, they can safely be used when formatting log
  messages.
  
  Parameters:
  
  output_fd - output file descriptor to check
  
  Returns:
  
  %TRUE if ANSI color escapes are supported, %FALSE otherwise
- mainContextDefault
  
  public static MainContext mainContextDefault()
  
  Returns the global default main context. This is the main context
  used for main loop functions when a main loop is not explicitly
  specified, and corresponds to the "main" main loop. See also
  g_main_context_get_thread_default().
  
  Returns:
  
  the global default main context.
- mainContextGetThreadDefault
  
  public static MainContext mainContextGetThreadDefault()
  
  Gets the thread-default #GMainContext for this thread. Asynchronous
  operations that want to be able to be run in contexts other than
  the default one should call this method or
  g_main_context_ref_thread_default() to get a #GMainContext to add
  their #GSources to. (Note that even in single-threaded
  programs applications may sometimes want to temporarily push a
  non-default context, so it is not safe to assume that this will
  always return %NULL if you are running in the default thread.)
  
  If you need to hold a reference on the context, use
  g_main_context_ref_thread_default() instead.
  
  Returns:
  
  the thread-default #GMainContext, or %NULL if the thread-default context is the global default context.
- mainContextRefThreadDefault
  
  public static MainContext mainContextRefThreadDefault()
  
  Gets the thread-default #GMainContext for this thread, as with
  g_main_context_get_thread_default(), but also adds a reference to
  it with g_main_context_ref(). In addition, unlike
  g_main_context_get_thread_default(), if the thread-default context
  is the global default context, this will return that #GMainContext
  (with a ref added to it) rather than returning %NULL.
  
  Returns:
  
  the thread-default #GMainContext. Unref with g_main_context_unref() when you are done with it.
- mainCurrentSource
  
  public static Source mainCurrentSource()
  
  Returns the currently firing source for this thread.
  
  Returns:
  
  The currently firing source or %NULL.
- mainDepth
  
  public static int mainDepth()
  Returns the depth of the stack of calls to
  g_main_context_dispatch() on any #GMainContext in the current thread.
  That is, when called from the toplevel, it gives 0. When
  called from within a callback from g_main_context_iteration()
  (or g_main_loop_run(), etc.) it returns 1. When called from within
  a callback to a recursive call to g_main_context_iteration(),
  it returns 2. And so forth.
  
  This function is useful in a situation like the following:
  Imagine an extremely simple "garbage collected" system.
  
   static GList *free_list; gpointer allocate_memory (gsize size) { gpointer result = g_malloc (size); free_list = g_list_prepend (free_list, result); return result; } void free_allocated_memory (void) { GList *l; for (l = free_list; l; l = l->next); g_free (l->data); g_list_free (free_list); free_list = NULL; } [...] while (TRUE); { g_main_context_iteration (NULL, TRUE); free_allocated_memory(); }
  
  This works from an application, however, if you want to do the same
  thing from a library, it gets more difficult, since you no longer
  control the main loop. You might think you can simply use an idle
  function to make the call to free_allocated_memory(), but that
  doesn't work, since the idle function could be called from a
  recursive callback. This can be fixed by using g_main_depth()
  
   gpointer allocate_memory (gsize size) { FreeListBlock *block = g_new (FreeListBlock, 1); block->mem = g_malloc (size); block->depth = g_main_depth (); free_list = g_list_prepend (free_list, block); return block->mem; } void free_allocated_memory (void) { GList *l; int depth = g_main_depth (); for (l = free_list; l; ); { GList *next = l->next; FreeListBlock *block = l->data; if (block->depth > depth) { g_free (block->mem); g_free (block); free_list = g_list_delete_link (free_list, l); } l = next; } }
  
  There is a temptation to use g_main_depth() to solve
  problems with reentrancy. For instance, while waiting for data
  to be received from the network in response to a menu item,
  the menu item might be selected again. It might seem that
  one could make the menu item's callback return immediately
  and do nothing if g_main_depth() returns a value greater than 1.
  However, this should be avoided since the user then sees selecting
  the menu item do nothing. Furthermore, you'll find yourself adding
  these checks all over your code, since there are doubtless many,
  many things that the user could do. Instead, you can use the
  following techniques:
  
  1. Use gtk_widget_set_sensitive() or modal dialogs to prevent
  the user from interacting with elements while the main
  loop is recursing.
  
  2. Avoid main loop recursion in situations where you can't handle
  arbitrary callbacks. Instead, structure your code so that you
  simply return to the main loop and then get called again when
  there is more work to do.
  Returns:
  
  The main loop recursion level in the current thread
- malloc
  
  public static Pointer malloc(long n_bytes)
  
  Allocates @n_bytes bytes of memory.
  If @n_bytes is 0 it returns %NULL.
  
  If the allocation fails (because the system is out of memory),
  the program is terminated.
  
  Parameters:
  
  n_bytes - the number of bytes to allocate
  
  Returns:
  
  a pointer to the allocated memory
- malloc0
  
  public static Pointer malloc0(long n_bytes)
  
  Allocates @n_bytes bytes of memory, initialized to 0's.
  If @n_bytes is 0 it returns %NULL.
  
  If the allocation fails (because the system is out of memory),
  the program is terminated.
  
  Parameters:
  
  n_bytes - the number of bytes to allocate
  
  Returns:
  
  a pointer to the allocated memory
- malloc0N
  
  public static Pointer malloc0N(long n_blocks, long n_block_bytes)
  
  This function is similar to g_malloc0(), allocating (@n_blocks * @n_block_bytes) bytes,
  but care is taken to detect possible overflow during multiplication.
  
  If the allocation fails (because the system is out of memory),
  the program is terminated.
  
  Parameters:
  
  n_blocks - the number of blocks to allocate
  
  n_block_bytes - the size of each block in bytes
  
  Returns:
  
  a pointer to the allocated memory
- mallocN
  
  public static Pointer mallocN(long n_blocks, long n_block_bytes)
  
  This function is similar to g_malloc(), allocating (@n_blocks * @n_block_bytes) bytes,
  but care is taken to detect possible overflow during multiplication.
  
  If the allocation fails (because the system is out of memory),
  the program is terminated.
  
  Parameters:
  
  n_blocks - the number of blocks to allocate
  
  n_block_bytes - the size of each block in bytes
  
  Returns:
  
  a pointer to the allocated memory
- markupErrorQuark
  
  public static int markupErrorQuark()
  
  Returns:
- markupEscapeText
  
  public static Str markupEscapeText(@Nonnull Str text, long length)
  
  Escapes text so that the markup parser will parse it verbatim.
  Less than, greater than, ampersand, etc. are replaced with the
  corresponding entities. This function would typically be used
  when writing out a file to be parsed with the markup parser.
  
  Note that this function doesn't protect whitespace and line endings
  from being processed according to the XML rules for normalization
  of line endings and attribute values.
  
  Note also that this function will produce character references in
  the range of  ...  for all control sequences
  except for tabstop, newline and carriage return. The character
  references in this range are not valid XML 1.0, but they are
  valid XML 1.1 and will be accepted by the GMarkup parser.
  
  Parameters:
  
  text - some valid UTF-8 text
  
  length - length of @text in bytes, or -1 if the text is nul-terminated
  
  Returns:
  
  a newly allocated string with the escaped text
- markupPrintfEscaped
  
  public static Str markupPrintfEscaped(@Nonnull Str format, Object... _elipse)
  Formats arguments according to @format, escaping
  all string and character arguments in the fashion
  of g_markup_escape_text(). This is useful when you
  want to insert literal strings into XML-style markup
  output, without having to worry that the strings
  might themselves contain markup.
  
   const char *store = "Fortnum & Mason"; const char *item = "Tea"; char *output; output = g_markup_printf_escaped ("<purchase>" "<store>%s</store>" "<item>%s</item>" "</purchase>", store, item);
  Parameters:
  
  format - printf() style format string
  
  _elipse - the arguments to insert in the format string
  
  Returns:
  
  newly allocated result from formatting operation. Free with g_free().
- memdup2
  
  public static Pointer memdup2(@Nullable Pointer mem, long byte_size)
  
  Allocates @byte_size bytes of memory, and copies @byte_size bytes into it
  from @mem. If @mem is %NULL it returns %NULL.
  
  This replaces g_memdup(), which was prone to integer overflows when
  converting the argument from a #gsize to a #guint.
  
  Parameters:
  
  mem - the memory to copy.
  
  byte_size - the number of bytes to copy.
  
  Returns:
  
  a pointer to the newly-allocated copy of the memory, or %NULL if @mem is %NULL.
- mkdirWithParents
  
  public static int mkdirWithParents(@Nonnull Str pathname, int mode)
  
  Create a directory if it doesn't already exist. Create intermediate
  parent directories as needed, too.
  
  Parameters:
  
  pathname - a pathname in the GLib file name encoding
  
  mode - permissions to use for newly created directories
  
  Returns:
  
  0 if the directory already exists, or was successfully created. Returns -1 if an error occurred, with errno set.
- mkdtemp
  
  public static Str mkdtemp(@Nonnull Str tmpl)
  
  Creates a temporary directory. See the mkdtemp() documentation
  on most UNIX-like systems.
  
  The parameter is a string that should follow the rules for
  mkdtemp() templates, i.e. contain the string "XXXXXX".
  g_mkdtemp() is slightly more flexible than mkdtemp() in that the
  sequence does not have to occur at the very end of the template.
  The X string will be modified to form the name of a directory that
  didn't exist.
  The string should be in the GLib file name encoding. Most importantly,
  on Windows it should be in UTF-8.
  
  If you are going to be creating a temporary directory inside the
  directory returned by g_get_tmp_dir(), you might want to use
  g_dir_make_tmp() instead.
  
  Parameters:
  
  tmpl - template directory name
  
  Returns:
  
  A pointer to @tmpl, which has been modified to hold the directory name. In case of errors, %NULL is returned and %errno will be set.
- mkdtempFull
  
  public static Str mkdtempFull(@Nonnull Str tmpl, int mode)
  
  Creates a temporary directory. See the mkdtemp() documentation
  on most UNIX-like systems.
  
  The parameter is a string that should follow the rules for
  mkdtemp() templates, i.e. contain the string "XXXXXX".
  g_mkdtemp_full() is slightly more flexible than mkdtemp() in that the
  sequence does not have to occur at the very end of the template
  and you can pass a @mode. The X string will be modified to form
  the name of a directory that didn't exist. The string should be
  in the GLib file name encoding. Most importantly, on Windows it
  should be in UTF-8.
  
  If you are going to be creating a temporary directory inside the
  directory returned by g_get_tmp_dir(), you might want to use
  g_dir_make_tmp() instead.
  
  Parameters:
  
  tmpl - template directory name
  
  mode - permissions to create the temporary directory with
  
  Returns:
  
  A pointer to @tmpl, which has been modified to hold the directory name. In case of errors, %NULL is returned, and %errno will be set.
- mkstemp
  
  public static int mkstemp(@Nonnull Str tmpl)
  
  Opens a temporary file. See the mkstemp() documentation
  on most UNIX-like systems.
  
  The parameter is a string that should follow the rules for
  mkstemp() templates, i.e. contain the string "XXXXXX".
  g_mkstemp() is slightly more flexible than mkstemp() in that the
  sequence does not have to occur at the very end of the template.
  The X string will be modified to form the name of a file that
  didn't exist. The string should be in the GLib file name encoding.
  Most importantly, on Windows it should be in UTF-8.
  
  Parameters:
  
  tmpl - template filename
  
  Returns:
  
  A file handle (as from open()) to the file opened for reading and writing. The file is opened in binary mode on platforms where there is a difference. The file handle should be closed with close(). In case of errors, -1 is returned and %errno will be set.
- mkstempFull
  
  public static int mkstempFull(@Nonnull Str tmpl, int flags, int mode)
  
  Opens a temporary file. See the mkstemp() documentation
  on most UNIX-like systems.
  
  The parameter is a string that should follow the rules for
  mkstemp() templates, i.e. contain the string "XXXXXX".
  g_mkstemp_full() is slightly more flexible than mkstemp()
  in that the sequence does not have to occur at the very end of the
  template and you can pass a @mode and additional @flags. The X
  string will be modified to form the name of a file that didn't exist.
  The string should be in the GLib file name encoding. Most importantly,
  on Windows it should be in UTF-8.
  
  Parameters:
  
  tmpl - template filename
  
  flags - flags to pass to an open() call in addition to O_EXCL and O_CREAT, which are passed automatically
  
  mode - permissions to create the temporary file with
  
  Returns:
  
  A file handle (as from open()) to the file opened for reading and writing. The file handle should be closed with close(). In case of errors, -1 is returned and %errno will be set.
- numberParserErrorQuark
  
  public static int numberParserErrorQuark()
  
  Returns:
- onErrorQuery
  
  public static void onErrorQuery(@Nonnull Str prg_name)
  Prompts the user with
  `[E]xit, [H]alt, show [S]tack trace or [P]roceed`.
  This function is intended to be used for debugging use only.
  The following example shows how it can be used together with
  the g_log() functions.
  
   #include <glib.h> static void log_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data) { g_log_default_handler (log_domain, log_level, message, user_data); g_on_error_query (MY_PROGRAM_NAME); } int main (int argc, char *argv[]) { g_log_set_handler (MY_LOG_DOMAIN, G_LOG_LEVEL_WARNING | G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL, log_handler, NULL); ...
  
  If "[E]xit" is selected, the application terminates with a call
  to _exit(0).
  
  If "[S]tack" trace is selected, g_on_error_stack_trace() is called.
  This invokes gdb, which attaches to the current process and shows
  a stack trace. The prompt is then shown again.
  
  If "[P]roceed" is selected, the function returns.
  
  This function may cause different actions on non-UNIX platforms.
  
  On Windows consider using the `G_DEBUGGER` environment
  variable (see [Running GLib Applications](glib-running.html)) and
  calling g_on_error_stack_trace() instead.
  Parameters:
  
  prg_name - the program name, needed by gdb for the "[S]tack trace" option. If @prg_name is %NULL, g_get_prgname() is called to get the program name (which will work correctly if gdk_init() or gtk_init() has been called)
- onErrorStackTrace
  
  public static void onErrorStackTrace(@Nonnull Str prg_name)
  
  Invokes gdb, which attaches to the current process and shows a
  stack trace. Called by g_on_error_query() when the "[S]tack trace"
  option is selected. You can get the current process's program name
  with g_get_prgname(), assuming that you have called gtk_init() or
  gdk_init().
  
  This function may cause different actions on non-UNIX platforms.
  
  When running on Windows, this function is *not* called by
  g_on_error_query(). If called directly, it will raise an
  exception, which will crash the program. If the `G_DEBUGGER` environment
  variable is set, a debugger will be invoked to attach and
  handle that exception (see [Running GLib Applications](glib-running.html)).
  
  Parameters:
  
  prg_name - the program name, needed by gdb for the "[S]tack trace" option
- onceInitEnter
  
  public static boolean onceInitEnter(@Nonnull Pointer location)
  Function to be called when starting a critical initialization
  section. The argument @location must point to a static
  0-initialized variable that will be set to a value other than 0 at
  the end of the initialization section. In combination with
  g_once_init_leave() and the unique address @value_location, it can
  be ensured that an initialization section will be executed only once
  during a program's life time, and that concurrent threads are
  blocked until initialization completed. To be used in constructs
  like this:
  
   static gsize initialization_value = 0; if (g_once_init_enter (&initialization_value)) { gsize setup_value = 42; // initialization code here g_once_init_leave (&initialization_value, setup_value); } // use initialization_value here
  
  While @location has a `volatile` qualifier, this is a historical artifact and
  the pointer passed to it should not be `volatile`.
  Parameters:
  
  location - location of a static initializable variable containing 0
  
  Returns:
  
  %TRUE if the initialization section should be entered, %FALSE and blocks otherwise
- onceInitLeave
  
  public static void onceInitLeave(@Nonnull Pointer location, long result)
  
  Counterpart to g_once_init_enter(). Expects a location of a static
  0-initialized initialization variable, and an initialization value
  other than 0. Sets the variable to the initialization value, and
  releases concurrent threads blocking in g_once_init_enter() on this
  initialization variable.
  
  While @location has a `volatile` qualifier, this is a historical artifact and
  the pointer passed to it should not be `volatile`.
  
  Parameters:
  
  location - location of a static initializable variable containing 0
  
  result - new non-0 value for *@value_location
- optionErrorQuark
  
  public static int optionErrorQuark()
  
  Returns:
- pathGetBasename
  
  public static Str pathGetBasename(@Nonnull Str file_name)
  
  Gets the last component of the filename.
  
  If @file_name ends with a directory separator it gets the component
  before the last slash. If @file_name consists only of directory
  separators (and on Windows, possibly a drive letter), a single
  separator is returned. If @file_name is empty, it gets ".".
  
  Parameters:
  
  file_name - the name of the file
  
  Returns:
  
  a newly allocated string containing the last component of the filename
- pathGetDirname
  
  public static Str pathGetDirname(@Nonnull Str file_name)
  
  Gets the directory components of a file name. For example, the directory
  component of `/usr/bin/test` is `/usr/bin`. The directory component of `/`
  is `/`.
  
  If the file name has no directory components "." is returned.
  The returned string should be freed when no longer needed.
  
  Parameters:
  
  file_name - the name of the file
  
  Returns:
  
  the directory components of the file
- pathIsAbsolute
  
  public static boolean pathIsAbsolute(@Nonnull Str file_name)
  
  Returns %TRUE if the given @file_name is an absolute file name.
  Note that this is a somewhat vague concept on Windows.
  
  On POSIX systems, an absolute file name is well-defined. It always
  starts from the single root directory. For example "/usr/local".
  
  On Windows, the concepts of current drive and drive-specific
  current directory introduce vagueness. This function interprets as
  an absolute file name one that either begins with a directory
  separator such as "\Users\tml" or begins with the root on a drive,
  for example "C:\Windows". The first case also includes UNC paths
  such as "\\\\myserver\docs\foo". In all cases, either slashes or
  backslashes are accepted.
  
  Note that a file name relative to the current drive root does not
  truly specify a file uniquely over time and across processes, as
  the current drive is a per-process value and can be changed.
  
  File names relative the current directory on some specific drive,
  such as "D:foo/bar", are not interpreted as absolute by this
  function, but they obviously are not relative to the normal current
  directory as returned by getcwd() or g_get_current_dir()
  either. Such paths should be avoided, or need to be handled using
  Windows-specific code.
  
  Parameters:
  
  file_name - a file name
  
  Returns:
  
  %TRUE if @file_name is absolute
- pathSkipRoot
  
  public static Str pathSkipRoot(@Nonnull Str file_name)
  
  Returns a pointer into @file_name after the root component,
  i.e. after the "/" in UNIX or "C:\" under Windows. If @file_name
  is not an absolute path it returns %NULL.
  
  Parameters:
  
  file_name - a file name
  
  Returns:
  
  a pointer into @file_name after the root component
- patternMatchSimple
  
  public static boolean patternMatchSimple(@Nonnull Str pattern, @Nonnull Str string)
  
  Matches a string against a pattern given as a string. If this
  function is to be called in a loop, it's more efficient to compile
  the pattern once with g_pattern_spec_new() and call
  g_pattern_match_string() repeatedly.
  
  Parameters:
  
  pattern - the UTF-8 encoded pattern
  
  string - the UTF-8 encoded string to match
  
  Returns:
  
  %TRUE if @string matches @pspec
- pointerBitLock
  
  public static void pointerBitLock(@Nonnull Pointer address, int lock_bit)
  
  This is equivalent to g_bit_lock, but working on pointers (or other
  pointer-sized values).
  
  For portability reasons, you may only lock on the bottom 32 bits of
  the pointer.
  
  While @address has a `volatile` qualifier, this is a historical
  artifact and the argument passed to it should not be `volatile`.
  
  Parameters:
  
  address - a pointer to a #gpointer-sized value
  
  lock_bit - a bit value between 0 and 31
- pointerBitTrylock
  
  public static boolean pointerBitTrylock(@Nonnull Pointer address, int lock_bit)
  
  This is equivalent to g_bit_trylock(), but working on pointers (or
  other pointer-sized values).
  
  For portability reasons, you may only lock on the bottom 32 bits of
  the pointer.
  
  While @address has a `volatile` qualifier, this is a historical
  artifact and the argument passed to it should not be `volatile`.
  
  Parameters:
  
  address - a pointer to a #gpointer-sized value
  
  lock_bit - a bit value between 0 and 31
  
  Returns:
  
  %TRUE if the lock was acquired
- pointerBitUnlock
  
  public static void pointerBitUnlock(@Nonnull Pointer address, int lock_bit)
  
  This is equivalent to g_bit_unlock, but working on pointers (or other
  pointer-sized values).
  
  For portability reasons, you may only lock on the bottom 32 bits of
  the pointer.
  
  While @address has a `volatile` qualifier, this is a historical
  artifact and the argument passed to it should not be `volatile`.
  
  Parameters:
  
  address - a pointer to a #gpointer-sized value
  
  lock_bit - a bit value between 0 and 31
- poll
  
  public static int poll(@Nonnull PollFD fds, int nfds, int timeout)
  
  Polls @fds, as with the poll() system call, but portably. (On
  systems that don't have poll(), it is emulated using select().)
  This is used internally by #GMainContext, but it can be called
  directly if you need to block until a file descriptor is ready, but
  don't want to run the full main loop.
  
  Each element of @fds is a #GPollFD describing a single file
  descriptor to poll. The @fd field indicates the file descriptor,
  and the @events field indicates the events to poll for. On return,
  the @revents fields will be filled with the events that actually
  occurred.
  
  On POSIX systems, the file descriptors in @fds can be any sort of
  file descriptor, but the situation is much more complicated on
  Windows. If you need to use g_poll() in code that has to run on
  Windows, the easiest solution is to construct all of your
  #GPollFDs with g_io_channel_win32_make_pollfd().
  
  Parameters:
  
  fds - file descriptors to poll
  
  nfds - the number of file descriptors in @fds
  
  timeout - amount of time to wait, in milliseconds, or -1 to wait forever
  
  Returns:
  
  the number of entries in @fds whose @revents fields were filled in, or 0 if the operation timed out, or -1 on error or if the call was interrupted.
- print
  
  public static void print(@Nonnull Str format, Object... _elipse)
  
  Outputs a formatted message via the print handler.
  The default print handler simply outputs the message to stdout, without
  appending a trailing new-line character. Typically, @format should end with
  its own new-line character.
  
  g_print() should not be used from within libraries for debugging
  messages, since it may be redirected by applications to special
  purpose message windows or even files. Instead, libraries should
  use g_log(), g_log_structured(), or the convenience macros g_message(),
  g_warning() and g_error().
  
  Parameters:
  
  format - the message format. See the printf() documentation
  
  _elipse - the parameters to insert into the format string
- printerr
  
  public static void printerr(@Nonnull Str format, Object... _elipse)
  
  Outputs a formatted message via the error message handler.
  The default handler simply outputs the message to stderr, without appending
  a trailing new-line character. Typically, @format should end with its own
  new-line character.
  
  g_printerr() should not be used from within libraries.
  Instead g_log() or g_log_structured() should be used, or the convenience
  macros g_message(), g_warning() and g_error().
  
  Parameters:
  
  format - the message format. See the printf() documentation
  
  _elipse - the parameters to insert into the format string
- printf
  
  public static int printf(@Nonnull Str format, Object... _elipse)
  
  An implementation of the standard printf() function which supports
  positional parameters, as specified in the Single Unix Specification.
  
  As with the standard printf(), this does not automatically append a trailing
  new-line character to the message, so typically @format should end with its
  own new-line character.
  
  `glib/gprintf.h` must be explicitly included in order to use this function.
  
  Parameters:
  
  format - a standard printf() format string, but notice [string precision pitfalls][string-precision]
  
  _elipse - the arguments to insert in the output.
  
  Returns:
  
  the number of bytes printed.
- qsortWithData
  
  public static void qsortWithData(@Nonnull Pointer pbase, int total_elems, long size, Glib.OnCompareDataFunc compare_func, @Nullable Pointer user_data)
  
  This is just like the standard C qsort() function, but
  the comparison routine accepts a user data argument.
  
  This is guaranteed to be a stable sort since version 2.32.
  
  Parameters:
  
  pbase - start of array to sort
  
  total_elems - elements in the array
  
  size - size of each element
  
  compare_func - function to compare elements
  
  user_data - data to pass to @compare_func
- quarkFromStaticString
  
  public static int quarkFromStaticString(@Nullable Str string)
  
  Gets the #GQuark identifying the given (static) string. If the
  string does not currently have an associated #GQuark, a new #GQuark
  is created, linked to the given string.
  
  Note that this function is identical to g_quark_from_string() except
  that if a new #GQuark is created the string itself is used rather
  than a copy. This saves memory, but can only be used if the string
  will continue to exist until the program terminates. It can be used
  with statically allocated strings in the main program, but not with
  statically allocated memory in dynamically loaded modules, if you
  expect to ever unload the module again (e.g. do not use this
  function in GTK+ theme engines).
  
  This function must not be used before library constructors have finished
  running. In particular, this means it cannot be used to initialize global
  variables in C++.
  
  Parameters:
  
  string - a string
  
  Returns:
  
  the #GQuark identifying the string, or 0 if @string is %NULL
- quarkFromString
  
  public static int quarkFromString(@Nullable Str string)
  
  Gets the #GQuark identifying the given string. If the string does
  not currently have an associated #GQuark, a new #GQuark is created,
  using a copy of the string.
  
  This function must not be used before library constructors have finished
  running. In particular, this means it cannot be used to initialize global
  variables in C++.
  
  Parameters:
  
  string - a string
  
  Returns:
  
  the #GQuark identifying the string, or 0 if @string is %NULL
- quarkToString
  
  public static Str quarkToString(int quark)
  
  Gets the string associated with the given #GQuark.
  
  Parameters:
  
  quark - a #GQuark.
  
  Returns:
  
  the string associated with the #GQuark
- quarkTryString
  
  public static int quarkTryString(@Nullable Str string)
  
  Gets the #GQuark associated with the given string, or 0 if string is
  %NULL or it has no associated #GQuark.
  
  If you want the GQuark to be created if it doesn't already exist,
  use g_quark_from_string() or g_quark_from_static_string().
  
  This function must not be used before library constructors have finished
  running.
  
  Parameters:
  
  string - a string
  
  Returns:
  
  the #GQuark associated with the string, or 0 if @string is %NULL or there is no #GQuark associated with it
- randomDouble
  
  public static double randomDouble()
  
  Returns a random #gdouble equally distributed over the range [0..1).
  
  Returns:
  
  a random number
- randomDoubleRange
  
  public static double randomDoubleRange(double begin, double end)
  
  Returns a random #gdouble equally distributed over the range
  [@begin..@end).
  
  Parameters:
  
  begin - lower closed bound of the interval
  
  end - upper open bound of the interval
  
  Returns:
  
  a random number
- randomInt
  
  public static int randomInt()
  
  Return a random #guint32 equally distributed over the range
  [0..2^32-1].
  
  Returns:
  
  a random number
- randomIntRange
  
  public static int randomIntRange(int begin, int end)
  
  Returns a random #gint32 equally distributed over the range
  [@begin..@end-1].
  
  Parameters:
  
  begin - lower closed bound of the interval
  
  end - upper open bound of the interval
  
  Returns:
  
  a random number
- randomSetSeed
  
  public static void randomSetSeed(int seed)
  
  Sets the seed for the global random number generator, which is used
  by the g_random_* functions, to @seed.
  
  Parameters:
  
  seed - a value to reinitialize the global random number generator
- rcBoxAcquire
  
  public static Pointer rcBoxAcquire(@Nonnull Pointer mem_block)
  
  Acquires a reference on the data pointed by @mem_block.
  
  Parameters:
  
  mem_block - a pointer to reference counted data
  
  Returns:
  
  a pointer to the data, with its reference count increased
- rcBoxAlloc
  
  public static Pointer rcBoxAlloc(long block_size)
  
  Allocates @block_size bytes of memory, and adds reference
  counting semantics to it.
  
  The data will be freed when its reference count drops to
  zero.
  
  The allocated data is guaranteed to be suitably aligned for any
  built-in type.
  
  Parameters:
  
  block_size - the size of the allocation, must be greater than 0
  
  Returns:
  
  a pointer to the allocated memory
- rcBoxAlloc0
  
  public static Pointer rcBoxAlloc0(long block_size)
  
  Allocates @block_size bytes of memory, and adds reference
  counting semantics to it.
  
  The contents of the returned data is set to zero.
  
  The data will be freed when its reference count drops to
  zero.
  
  The allocated data is guaranteed to be suitably aligned for any
  built-in type.
  
  Parameters:
  
  block_size - the size of the allocation, must be greater than 0
  
  Returns:
  
  a pointer to the allocated memory
- rcBoxDup
  
  public static Pointer rcBoxDup(long block_size, @Nonnull Pointer mem_block)
  
  Allocates a new block of data with reference counting
  semantics, and copies @block_size bytes of @mem_block
  into it.
  
  Parameters:
  
  block_size - the number of bytes to copy, must be greater than 0
  
  mem_block - the memory to copy
  
  Returns:
  
  a pointer to the allocated memory
- rcBoxGetSize
  
  public static long rcBoxGetSize(@Nonnull Pointer mem_block)
  
  Retrieves the size of the reference counted data pointed by @mem_block.
  
  Parameters:
  
  mem_block - a pointer to reference counted data
  
  Returns:
  
  the size of the data, in bytes
- rcBoxRelease
  
  public static void rcBoxRelease(@Nonnull Pointer mem_block)
  
  Releases a reference on the data pointed by @mem_block.
  
  If the reference was the last one, it will free the
  resources allocated for @mem_block.
  
  Parameters:
  
  mem_block - a pointer to reference counted data
- rcBoxReleaseFull
  
  public static void rcBoxReleaseFull(@Nonnull Pointer mem_block, Glib.OnDestroyNotify clear_func)
  
  Releases a reference on the data pointed by @mem_block.
  
  If the reference was the last one, it will call @clear_func
  to clear the contents of @mem_block, and then will free the
  resources allocated for @mem_block.
  
  Parameters:
  
  mem_block - a pointer to reference counted data
  
  clear_func - a function to call when clearing the data
- realloc
  
  public static Pointer realloc(@Nullable Pointer mem, long n_bytes)
  
  Reallocates the memory pointed to by @mem, so that it now has space for
  @n_bytes bytes of memory. It returns the new address of the memory, which may
  have been moved. @mem may be %NULL, in which case it's considered to
  have zero-length. @n_bytes may be 0, in which case %NULL will be returned
  and @mem will be freed unless it is %NULL.
  
  If the allocation fails (because the system is out of memory),
  the program is terminated.
  
  Parameters:
  
  mem - the memory to reallocate
  
  n_bytes - new size of the memory in bytes
  
  Returns:
  
  the new address of the allocated memory
- reallocN
  
  public static Pointer reallocN(@Nullable Pointer mem, long n_blocks, long n_block_bytes)
  
  This function is similar to g_realloc(), allocating (@n_blocks * @n_block_bytes) bytes,
  but care is taken to detect possible overflow during multiplication.
  
  If the allocation fails (because the system is out of memory),
  the program is terminated.
  
  Parameters:
  
  mem - the memory to reallocate
  
  n_blocks - the number of blocks to allocate
  
  n_block_bytes - the size of each block in bytes
  
  Returns:
  
  the new address of the allocated memory
- refStringAcquire
  
  public static Str refStringAcquire(@Nonnull Str str)
  
  Acquires a reference on a string.
  
  Parameters:
  
  str - a reference counted string
  
  Returns:
  
  the given string, with its reference count increased
- refStringLength
  
  public static long refStringLength(@Nonnull Str str)
  
  Retrieves the length of @str.
  
  Parameters:
  
  str - a reference counted string
  
  Returns:
  
  the length of the given string, in bytes
- refStringNew
  
  public static Str refStringNew(@Nonnull Str str)
  
  Creates a new reference counted string and copies the contents of @str
  into it.
  
  Parameters:
  
  str - a NUL-terminated string
  
  Returns:
  
  the newly created reference counted string
- refStringNewIntern
  
  public static Str refStringNewIntern(@Nonnull Str str)
  
  Creates a new reference counted string and copies the content of @str
  into it.
  
  If you call this function multiple times with the same @str, or with
  the same contents of @str, it will return a new reference, instead of
  creating a new string.
  
  Parameters:
  
  str - a NUL-terminated string
  
  Returns:
  
  the newly created reference counted string, or a new reference to an existing string
- refStringNewLen
  
  public static Str refStringNewLen(@Nonnull Str str, long len)
  
  Creates a new reference counted string and copies the contents of @str
  into it, up to @len bytes.
  
  Since this function does not stop at nul bytes, it is the caller's
  responsibility to ensure that @str has at least @len addressable bytes.
  
  Parameters:
  
  str - a string
  
  len - length of @str to use, or -1 if @str is nul-terminated
  
  Returns:
  
  the newly created reference counted string
- refStringRelease
  
  public static void refStringRelease(@Nonnull Str str)
  
  Releases a reference on a string; if it was the last reference, the
  resources allocated by the string are freed as well.
  
  Parameters:
  
  str - a reference counted string
- regexCheckReplacement
  
  public static boolean regexCheckReplacement(@Nonnull Str replacement, @Nullable Int has_references) throws AllocationError
  
  Checks whether @replacement is a valid replacement string
  (see g_regex_replace()), i.e. that all escape sequences in
  it are valid.
  
  If @has_references is not %NULL then @replacement is checked
  for pattern references. For instance, replacement text 'foo\n'
  does not contain references and may be evaluated without information
  about actual match, but '\0\1' (whole match followed by first
  subpattern) requires valid #GMatchInfo object.
  
  Parameters:
  
  replacement - the replacement string
  
  has_references - location to store information about references in @replacement or %NULL
  
  Returns:
  
  whether @replacement is a valid replacement string
  
  Throws:
  
  AllocationError
- regexErrorQuark
  
  public static int regexErrorQuark()
  
  Returns:
- regexEscapeNul
  
  public static Str regexEscapeNul(@Nonnull Str string, int length)
  
  Escapes the nul characters in @string to "\x00". It can be used
  to compile a regex with embedded nul characters.
  
  For completeness, @length can be -1 for a nul-terminated string.
  In this case the output string will be of course equal to @string.
  
  Parameters:
  
  string - the string to escape
  
  length - the length of @string
  
  Returns:
  
  a newly-allocated escaped string
- regexEscapeString
  
  public static Str regexEscapeString(@Nonnull Str string, int length)
  
  Escapes the special characters used for regular expressions
  in @string, for instance "a.b*c" becomes "a\.b\*c". This
  function is useful to dynamically generate regular expressions.
  
  @string can contain nul characters that are replaced with "\0",
  in this case remember to specify the correct length of @string
  in @length.
  
  Parameters:
  
  string - the string to escape
  
  length - the length of @string, in bytes, or -1 if @string is nul-terminated
  
  Returns:
  
  a newly-allocated escaped string
- regexMatchSimple
  
  public static boolean regexMatchSimple(@Nonnull Str pattern, @Nonnull Str string, int compile_options, int match_options)
  
  Scans for a match in @string for @pattern.
  
  This function is equivalent to g_regex_match() but it does not
  require to compile the pattern with g_regex_new(), avoiding some
  lines of code when you need just to do a match without extracting
  substrings, capture counts, and so on.
  
  If this function is to be called on the same @pattern more than
  once, it's more efficient to compile the pattern once with
  g_regex_new() and then use g_regex_match().
  
  Parameters:
  
  pattern - the regular expression
  
  string - the string to scan for matches
  
  compile_options - compile options for the regular expression, or 0
  
  match_options - match options, or 0
  
  Returns:
  
  %TRUE if the string matched, %FALSE otherwise
- reloadUserSpecialDirsCache
  
  public static void reloadUserSpecialDirsCache()
  
  Resets the cache used for g_get_user_special_dir(), so
  that the latest on-disk version is used. Call this only
  if you just changed the data on disk yourself.
  
  Due to thread safety issues this may cause leaking of strings
  that were previously returned from g_get_user_special_dir()
  that can't be freed. We ensure to only leak the data for
  the directories that actually changed value though.
- returnIfFailWarning
  
  public static void returnIfFailWarning(@Nullable Str log_domain, @Nonnull Str pretty_function, @Nullable Str expression)
  
  Internal function used to print messages from the public g_return_if_fail()
  and g_return_val_if_fail() macros.
  
  Parameters:
  
  log_domain - log domain
  
  pretty_function - function containing the assertion
  
  expression - expression which failed
- rmdir
  
  public static int rmdir(@Nonnull Str filename)
  
  A wrapper for the POSIX rmdir() function. The rmdir() function
  deletes a directory from the filesystem.
  
  See your C library manual for more details about how rmdir() works
  on your system.
  
  Parameters:
  
  filename - a pathname in the GLib file name encoding (UTF-8 on Windows)
  
  Returns:
  
  0 if the directory was successfully removed, -1 if an error occurred
- sequenceGet
  
  public static Pointer sequenceGet(@Nonnull ch.bailu.gtk.glib.SequenceIter iter)
  
  Returns the data that @iter points to.
  
  Parameters:
  
  iter - a #GSequenceIter
  
  Returns:
  
  the data that @iter points to
- sequenceInsertBefore
  
  public static ch.bailu.gtk.glib.SequenceIter sequenceInsertBefore(@Nonnull ch.bailu.gtk.glib.SequenceIter iter, @Nullable Pointer data)
  
  Inserts a new item just before the item pointed to by @iter.
  
  Parameters:
  
  iter - a #GSequenceIter
  
  data - the data for the new item
  
  Returns:
  
  an iterator pointing to the new item
- sequenceMove
  
  public static void sequenceMove(@Nonnull ch.bailu.gtk.glib.SequenceIter src, @Nonnull ch.bailu.gtk.glib.SequenceIter dest)
  
  Moves the item pointed to by @src to the position indicated by @dest.
  After calling this function @dest will point to the position immediately
  after @src. It is allowed for @src and @dest to point into different
  sequences.
  
  Parameters:
  
  src - a #GSequenceIter pointing to the item to move
  
  dest - a #GSequenceIter pointing to the position to which the item is moved
- sequenceMoveRange
  
  public static void sequenceMoveRange(@Nonnull ch.bailu.gtk.glib.SequenceIter dest, @Nonnull ch.bailu.gtk.glib.SequenceIter begin, @Nonnull ch.bailu.gtk.glib.SequenceIter end)
  
  Inserts the (@begin, @end) range at the destination pointed to by @dest.
  The @begin and @end iters must point into the same sequence. It is
  allowed for @dest to point to a different sequence than the one pointed
  into by @begin and @end.
  
  If @dest is %NULL, the range indicated by @begin and @end is
  removed from the sequence. If @dest points to a place within
  the (@begin, @end) range, the range does not move.
  
  Parameters:
  
  dest - a #GSequenceIter
  
  begin - a #GSequenceIter
  
  end - a #GSequenceIter
- sequenceRangeGetMidpoint
  
  public static ch.bailu.gtk.glib.SequenceIter sequenceRangeGetMidpoint(@Nonnull ch.bailu.gtk.glib.SequenceIter begin, @Nonnull ch.bailu.gtk.glib.SequenceIter end)
  
  Finds an iterator somewhere in the range (@begin, @end). This
  iterator will be close to the middle of the range, but is not
  guaranteed to be exactly in the middle.
  
  The @begin and @end iterators must both point to the same sequence
  and @begin must come before or be equal to @end in the sequence.
  
  Parameters:
  
  begin - a #GSequenceIter
  
  end - a #GSequenceIter
  
  Returns:
  
  a #GSequenceIter pointing somewhere in the (@begin, @end) range
- sequenceRemove
  
  public static void sequenceRemove(@Nonnull ch.bailu.gtk.glib.SequenceIter iter)
  
  Removes the item pointed to by @iter. It is an error to pass the
  end iterator to this function.
  
  If the sequence has a data destroy function associated with it, this
  function is called on the data for the removed item.
  
  Parameters:
  
  iter - a #GSequenceIter
- sequenceRemoveRange
  
  public static void sequenceRemoveRange(@Nonnull ch.bailu.gtk.glib.SequenceIter begin, @Nonnull ch.bailu.gtk.glib.SequenceIter end)
  
  Removes all items in the (@begin, @end) range.
  
  If the sequence has a data destroy function associated with it, this
  function is called on the data for the removed items.
  
  Parameters:
  
  begin - a #GSequenceIter
  
  end - a #GSequenceIter
- sequenceSet
  
  public static void sequenceSet(@Nonnull ch.bailu.gtk.glib.SequenceIter iter, @Nullable Pointer data)
  
  Changes the data for the item pointed to by @iter to be @data. If
  the sequence has a data destroy function associated with it, that
  function is called on the existing data that @iter pointed to.
  
  Parameters:
  
  iter - a #GSequenceIter
  
  data - new data for the item
- sequenceSwap
  
  public static void sequenceSwap(@Nonnull ch.bailu.gtk.glib.SequenceIter a, @Nonnull ch.bailu.gtk.glib.SequenceIter b)
  
  Swaps the items pointed to by @a and @b. It is allowed for @a and @b
  to point into difference sequences.
  
  Parameters:
  
  a - a #GSequenceIter
  
  b - a #GSequenceIter
- setApplicationName
  
  public static void setApplicationName(@Nonnull Str application_name)
  
  Sets a human-readable name for the application. This name should be
  localized if possible, and is intended for display to the user.
  Contrast with g_set_prgname(), which sets a non-localized name.
  g_set_prgname() will be called automatically by gtk_init(),
  but g_set_application_name() will not.
  
  Note that for thread safety reasons, this function can only
  be called once.
  
  The application name will be used in contexts such as error messages,
  or when displaying an application's name in the task list.
  
  Parameters:
  
  application_name - localized name of the application
- setPrgname
  
  public static void setPrgname(@Nonnull Str prgname)
  
  Sets the name of the program. This name should not be localized,
  in contrast to g_set_application_name().
  
  If you are using #GApplication the program name is set in
  g_application_run(). In case of GDK or GTK+ it is set in
  gdk_init(), which is called by gtk_init() and the
  #GtkApplication::startup handler. The program name is found by
  taking the last component of @argv[0].
  
  Since GLib 2.72, this function can be called multiple times
  and is fully thread safe. Prior to GLib 2.72, this function
  could only be called once per process.
  
  Parameters:
  
  prgname - the name of the program.
- setenv
  
  public static boolean setenv(@Nonnull Str variable, @Nonnull Str value, boolean overwrite)
  
  Sets an environment variable. On UNIX, both the variable's name and
  value can be arbitrary byte strings, except that the variable's name
  cannot contain '='. On Windows, they should be in UTF-8.
  
  Note that on some systems, when variables are overwritten, the memory
  used for the previous variables and its value isn't reclaimed.
  
  You should be mindful of the fact that environment variable handling
  in UNIX is not thread-safe, and your program may crash if one thread
  calls g_setenv() while another thread is calling getenv(). (And note
  that many functions, such as gettext(), call getenv() internally.)
  This function is only safe to use at the very start of your program,
  before creating any other threads (or creating objects that create
  worker threads of their own).
  
  If you need to set up the environment for a child process, you can
  use g_get_environ() to get an environment array, modify that with
  g_environ_setenv() and g_environ_unsetenv(), and then pass that
  array directly to execvpe(), g_spawn_async(), or the like.
  
  Parameters:
  
  variable - the environment variable to set, must not contain '='.
  
  value - the value for to set the variable to.
  
  overwrite - whether to change the variable if it already exists.
  
  Returns:
  
  %FALSE if the environment variable couldn't be set.
- shellErrorQuark
  
  public static int shellErrorQuark()
  
  Returns:
- shellQuote
  
  public static Str shellQuote(@Nonnull Str unquoted_string)
  
  Quotes a string so that the shell (/bin/sh) will interpret the
  quoted string to mean @unquoted_string.
  
  If you pass a filename to the shell, for example, you should first
  quote it with this function.
  
  The return value must be freed with g_free().
  
  The quoting style used is undefined (single or double quotes may be
  used).
  
  Parameters:
  
  unquoted_string - a literal string
  
  Returns:
  
  quoted string
- shellUnquote
  
  public static Str shellUnquote(@Nonnull Str quoted_string) throws AllocationError
  
  Unquotes a string as the shell (/bin/sh) would.
  
  This function only handles quotes; if a string contains file globs,
  arithmetic operators, variables, backticks, redirections, or other
  special-to-the-shell features, the result will be different from the
  result a real shell would produce (the variables, backticks, etc.
  will be passed through literally instead of being expanded).
  
  This function is guaranteed to succeed if applied to the result of
  g_shell_quote(). If it fails, it returns %NULL and sets the
  error.
  
  The @quoted_string need not actually contain quoted or escaped text;
  g_shell_unquote() simply goes through the string and unquotes/unescapes
  anything that the shell would. Both single and double quotes are
  handled, as are escapes including escaped newlines.
  
  The return value must be freed with g_free().
  
  Possible errors are in the %G_SHELL_ERROR domain.
  
  Shell quoting rules are a bit strange. Single quotes preserve the
  literal string exactly. escape sequences are not allowed; not even
  `\'` - if you want a `'` in the quoted text, you have to do something
  like `'foo'\''bar'`. Double quotes allow `$`, ```, `"`, `\`, and
  newline to be escaped with backslash. Otherwise double quotes
  preserve things literally.
  
  Parameters:
  
  quoted_string - shell-quoted string
  
  Returns:
  
  an unquoted string
  
  Throws:
  
  AllocationError
- sliceAlloc
  
  public static Pointer sliceAlloc(long block_size)
  
  Allocates a block of memory from the slice allocator.
  
  The block address handed out can be expected to be aligned
  to at least `1 * sizeof (void*)`, though in general slices
  are `2 * sizeof (void*)` bytes aligned; if a `malloc()`
  fallback implementation is used instead, the alignment may
  be reduced in a libc dependent fashion.
  
  Note that the underlying slice allocation mechanism can
  be changed with the [`G_SLICE=always-malloc`][G_SLICE]
  environment variable.
  
  Parameters:
  
  block_size - the number of bytes to allocate
  
  Returns:
  
  a pointer to the allocated memory block, which will be %NULL if and only if @mem_size is 0
- sliceAlloc0
  
  public static Pointer sliceAlloc0(long block_size)
  
  Allocates a block of memory via g_slice_alloc() and initializes
  the returned memory to 0. Note that the underlying slice allocation
  mechanism can be changed with the [`G_SLICE=always-malloc`][G_SLICE]
  environment variable.
  
  Parameters:
  
  block_size - the number of bytes to allocate
  
  Returns:
  
  a pointer to the allocated block, which will be %NULL if and only if @mem_size is 0
- sliceCopy
  
  public static Pointer sliceCopy(long block_size, @Nullable Pointer mem_block)
  
  Allocates a block of memory from the slice allocator
  and copies @block_size bytes into it from @mem_block.
  
  @mem_block must be non-%NULL if @block_size is non-zero.
  
  Parameters:
  
  block_size - the number of bytes to allocate
  
  mem_block - the memory to copy
  
  Returns:
  
  a pointer to the allocated memory block, which will be %NULL if and only if @mem_size is 0
- sliceFree1
  
  public static void sliceFree1(long block_size, @Nullable Pointer mem_block)
  
  Frees a block of memory.
  
  The memory must have been allocated via g_slice_alloc() or
  g_slice_alloc0() and the @block_size has to match the size
  specified upon allocation. Note that the exact release behaviour
  can be changed with the [`G_DEBUG=gc-friendly`][G_DEBUG] environment
  variable, also see [`G_SLICE`][G_SLICE] for related debugging options.
  
  If @mem_block is %NULL, this function does nothing.
  
  Parameters:
  
  block_size - the size of the block
  
  mem_block - a pointer to the block to free
- sliceFreeChainWithOffset
  
  public static void sliceFreeChainWithOffset(long block_size, @Nullable Pointer mem_chain, long next_offset)
  
  Frees a linked list of memory blocks of structure type @type.
  
  The memory blocks must be equal-sized, allocated via
  g_slice_alloc() or g_slice_alloc0() and linked together by a
  @next pointer (similar to #GSList). The offset of the @next
  field in each block is passed as third argument.
  Note that the exact release behaviour can be changed with the
  [`G_DEBUG=gc-friendly`][G_DEBUG] environment variable, also see
  [`G_SLICE`][G_SLICE] for related debugging options.
  
  If @mem_chain is %NULL, this function does nothing.
  
  Parameters:
  
  block_size - the size of the blocks
  
  mem_chain - a pointer to the first block of the chain
  
  next_offset - the offset of the @next field in the blocks
- sliceGetConfig
  
  public static long sliceGetConfig(int ckey)
  
  Parameters:
  
  ckey -
  
  Returns:
- sliceSetConfig
  
  public static void sliceSetConfig(int ckey, long value)
  
  Parameters:
  
  ckey -
  
  value -
- snprintf
  
  public static int snprintf(@Nonnull Str string, long n, @Nonnull Str format, Object... _elipse)
  
  A safer form of the standard sprintf() function. The output is guaranteed
  to not exceed @n characters (including the terminating nul character), so
  it is easy to ensure that a buffer overflow cannot occur.
  
  See also g_strdup_printf().
  
  In versions of GLib prior to 1.2.3, this function may return -1 if the
  output was truncated, and the truncated string may not be nul-terminated.
  In versions prior to 1.3.12, this function returns the length of the output
  string.
  
  The return value of g_snprintf() conforms to the snprintf()
  function as standardized in ISO C99. Note that this is different from
  traditional snprintf(), which returns the length of the output string.
  
  The format string may contain positional parameters, as specified in
  the Single Unix Specification.
  
  Parameters:
  
  string - the buffer to hold the output.
  
  n - the maximum number of bytes to produce (including the terminating nul character).
  
  format - a standard printf() format string, but notice [string precision pitfalls][string-precision]
  
  _elipse - the arguments to insert in the output.
  
  Returns:
  
  the number of bytes which would be produced if the buffer was large enough.
- sourceRemove
  
  public static boolean sourceRemove(int tag)
  
  Removes the source with the given ID from the default main context. You must
  use g_source_destroy() for sources added to a non-default main context.
  
  The ID of a #GSource is given by g_source_get_id(), or will be
  returned by the functions g_source_attach(), g_idle_add(),
  g_idle_add_full(), g_timeout_add(), g_timeout_add_full(),
  g_child_watch_add(), g_child_watch_add_full(), g_io_add_watch(), and
  g_io_add_watch_full().
  
  It is a programmer error to attempt to remove a non-existent source.
  
  More specifically: source IDs can be reissued after a source has been
  destroyed and therefore it is never valid to use this function with a
  source ID which may have already been removed. An example is when
  scheduling an idle to run in another thread with g_idle_add(): the
  idle may already have run and been removed by the time this function
  is called on its (now invalid) source ID. This source ID may have
  been reissued, leading to the operation being performed against the
  wrong source.
  
  Parameters:
  
  tag - the ID of the source to remove.
  
  Returns:
  
  %TRUE if the source was found and removed.
- sourceRemoveByFuncsUserData
  
  public static boolean sourceRemoveByFuncsUserData(@Nonnull SourceFuncs funcs, @Nullable Pointer user_data)
  
  Removes a source from the default main loop context given the
  source functions and user data. If multiple sources exist with the
  same source functions and user data, only one will be destroyed.
  
  Parameters:
  
  funcs - The @source_funcs passed to g_source_new()
  
  user_data - the user data for the callback
  
  Returns:
  
  %TRUE if a source was found and removed.
- sourceRemoveByUserData
  
  public static boolean sourceRemoveByUserData(@Nullable Pointer user_data)
  
  Removes a source from the default main loop context given the user
  data for the callback. If multiple sources exist with the same user
  data, only one will be destroyed.
  
  Parameters:
  
  user_data - the user_data for the callback.
  
  Returns:
  
  %TRUE if a source was found and removed.
- sourceSetNameById
  
  public static void sourceSetNameById(int tag, @Nonnull Str name)
  
  Sets the name of a source using its ID.
  
  This is a convenience utility to set source names from the return
  value of g_idle_add(), g_timeout_add(), etc.
  
  It is a programmer error to attempt to set the name of a non-existent
  source.
  
  More specifically: source IDs can be reissued after a source has been
  destroyed and therefore it is never valid to use this function with a
  source ID which may have already been removed. An example is when
  scheduling an idle to run in another thread with g_idle_add(): the
  idle may already have run and been removed by the time this function
  is called on its (now invalid) source ID. This source ID may have
  been reissued, leading to the operation being performed against the
  wrong source.
  
  Parameters:
  
  tag - a #GSource ID
  
  name - debug name for the source
- spacedPrimesClosest
  
  public static int spacedPrimesClosest(int num)
  
  Gets the smallest prime number from a built-in array of primes which
  is larger than @num. This is used within GLib to calculate the optimum
  size of a #GHashTable.
  
  The built-in array of primes ranges from 11 to 13845163 such that
  each prime is approximately 1.5-2 times the previous prime.
  
  Parameters:
  
  num - a #guint
  
  Returns:
  
  the smallest prime number from a built-in array of primes which is larger than @num
- spawnCheckWaitStatus
  
  public static boolean spawnCheckWaitStatus(int wait_status) throws AllocationError
  
  Set @error if @wait_status indicates the child exited abnormally
  (e.g. with a nonzero exit code, or via a fatal signal).
  
  The g_spawn_sync() and g_child_watch_add() family of APIs return the
  status of subprocesses encoded in a platform-specific way.
  On Unix, this is guaranteed to be in the same format waitpid() returns,
  and on Windows it is guaranteed to be the result of GetExitCodeProcess().
  
  Prior to the introduction of this function in GLib 2.34, interpreting
  @wait_status required use of platform-specific APIs, which is problematic
  for software using GLib as a cross-platform layer.
  
  Additionally, many programs simply want to determine whether or not
  the child exited successfully, and either propagate a #GError or
  print a message to standard error. In that common case, this function
  can be used. Note that the error message in @error will contain
  human-readable information about the wait status.
  
  The @domain and @code of @error have special semantics in the case
  where the process has an "exit code", as opposed to being killed by
  a signal. On Unix, this happens if WIFEXITED() would be true of
  @wait_status. On Windows, it is always the case.
  
  The special semantics are that the actual exit code will be the
  code set in @error, and the domain will be %G_SPAWN_EXIT_ERROR.
  This allows you to differentiate between different exit codes.
  
  If the process was terminated by some means other than an exit
  status (for example if it was killed by a signal), the domain will be
  %G_SPAWN_ERROR and the code will be %G_SPAWN_ERROR_FAILED.
  
  This function just offers convenience; you can of course also check
  the available platform via a macro such as %G_OS_UNIX, and use
  WIFEXITED() and WEXITSTATUS() on @wait_status directly. Do not attempt
  to scan or parse the error message string; it may be translated and/or
  change in future versions of GLib.
  
  Prior to version 2.70, g_spawn_check_exit_status() provides the same
  functionality, although under a misleading name.
  
  Parameters:
  
  wait_status - A platform-specific wait status as returned from g_spawn_sync()
  
  Returns:
  
  %TRUE if child exited successfully, %FALSE otherwise (and @error will be set)
  
  Throws:
  
  AllocationError
- spawnCommandLineAsync
  
  public static boolean spawnCommandLineAsync(@Nonnull Str command_line) throws AllocationError
  
  A simple version of g_spawn_async() that parses a command line with
  g_shell_parse_argv() and passes it to g_spawn_async().
  
  Runs a command line in the background. Unlike g_spawn_async(), the
  %G_SPAWN_SEARCH_PATH flag is enabled, other flags are not. Note
  that %G_SPAWN_SEARCH_PATH can have security implications, so
  consider using g_spawn_async() directly if appropriate. Possible
  errors are those from g_shell_parse_argv() and g_spawn_async().
  
  The same concerns on Windows apply as for g_spawn_command_line_sync().
  
  Parameters:
  
  command_line - a command line
  
  Returns:
  
  %TRUE on success, %FALSE if error is set
  
  Throws:
  
  AllocationError
- spawnErrorQuark
  
  public static int spawnErrorQuark()
  
  Returns:
- spawnExitErrorQuark
  
  public static int spawnExitErrorQuark()
  
  Returns:
- sprintf
  
  public static int sprintf(@Nonnull Str string, @Nonnull Str format, Object... _elipse)
  
  An implementation of the standard sprintf() function which supports
  positional parameters, as specified in the Single Unix Specification.
  
  Note that it is usually better to use g_snprintf(), to avoid the
  risk of buffer overflow.
  
  `glib/gprintf.h` must be explicitly included in order to use this function.
  
  See also g_strdup_printf().
  
  Parameters:
  
  string - A pointer to a memory buffer to contain the resulting string. It is up to the caller to ensure that the allocated buffer is large enough to hold the formatted result
  
  format - a standard printf() format string, but notice [string precision pitfalls][string-precision]
  
  _elipse - the arguments to insert in the output.
  
  Returns:
  
  the number of bytes printed.
- stpcpy
  
  public static Str stpcpy(@Nonnull Str dest, @Nonnull Str src)
  
  Copies a nul-terminated string into the dest buffer, include the
  trailing nul, and return a pointer to the trailing nul byte.
  This is useful for concatenating multiple strings together
  without having to repeatedly scan for the end.
  
  Parameters:
  
  dest - destination buffer.
  
  src - source string.
  
  Returns:
  
  a pointer to trailing nul byte.
- strEqual
  
  public static boolean strEqual(@Nonnull Pointer v1, @Nonnull Pointer v2)
  
  Compares two strings for byte-by-byte equality and returns %TRUE
  if they are equal. It can be passed to g_hash_table_new() as the
  @key_equal_func parameter, when using non-%NULL strings as keys in a
  #GHashTable.
  
  This function is typically used for hash table comparisons, but can be used
  for general purpose comparisons of non-%NULL strings. For a %NULL-safe string
  comparison function, see g_strcmp0().
  
  Parameters:
  
  v1 - a key
  
  v2 - a key to compare with @v1
  
  Returns:
  
  %TRUE if the two keys match
- strHasPrefix
  
  public static boolean strHasPrefix(@Nonnull Str str, @Nonnull Str prefix)
  
  Looks whether the string @str begins with @prefix.
  
  Parameters:
  
  str - a nul-terminated string
  
  prefix - the nul-terminated prefix to look for
  
  Returns:
  
  %TRUE if @str begins with @prefix, %FALSE otherwise.
- strHasSuffix
  
  public static boolean strHasSuffix(@Nonnull Str str, @Nonnull Str suffix)
  
  Looks whether the string @str ends with @suffix.
  
  Parameters:
  
  str - a nul-terminated string
  
  suffix - the nul-terminated suffix to look for
  
  Returns:
  
  %TRUE if @str end with @suffix, %FALSE otherwise.
- strHash
  
  public static int strHash(@Nonnull Pointer v)
  
  Converts a string to a hash value.
  
  This function implements the widely used "djb" hash apparently
  posted by Daniel Bernstein to comp.lang.c some time ago. The 32
  bit unsigned hash value starts at 5381 and for each byte 'c' in
  the string, is updated: `hash = hash * 33 + c`. This function
  uses the signed value of each byte.
  
  It can be passed to g_hash_table_new() as the @hash_func parameter,
  when using non-%NULL strings as keys in a #GHashTable.
  
  Note that this function may not be a perfect fit for all use cases.
  For example, it produces some hash collisions with strings as short
  as 2.
  
  Parameters:
  
  v - a string key
  
  Returns:
  
  a hash value corresponding to the key
- strIsAscii
  
  public static boolean strIsAscii(@Nonnull Str str)
  
  Determines if a string is pure ASCII. A string is pure ASCII if it
  contains no bytes with the high bit set.
  
  Parameters:
  
  str - a string
  
  Returns:
  
  %TRUE if @str is ASCII
- strMatchString
  
  public static boolean strMatchString(@Nonnull Str search_term, @Nonnull Str potential_hit, boolean accept_alternates)
  
  Checks if a search conducted for @search_term should match
  @potential_hit.
  
  This function calls g_str_tokenize_and_fold() on both
  @search_term and @potential_hit. ASCII alternates are never taken
  for @search_term but will be taken for @potential_hit according to
  the value of @accept_alternates.
  
  A hit occurs when each folded token in @search_term is a prefix of a
  folded token from @potential_hit.
  
  Depending on how you're performing the search, it will typically be
  faster to call g_str_tokenize_and_fold() on each string in
  your corpus and build an index on the returned folded tokens, then
  call g_str_tokenize_and_fold() on the search term and
  perform lookups into that index.
  
  As some examples, searching for ‘fred’ would match the potential hit
  ‘Smith, Fred’ and also ‘Frédéric’. Searching for ‘Fréd’ would match
  ‘Frédéric’ but not ‘Frederic’ (due to the one-directional nature of
  accent matching). Searching ‘fo’ would match ‘Foo’ and ‘Bar Foo
  Baz’, but not ‘SFO’ (because no word has ‘fo’ as a prefix).
  
  Parameters:
  
  search_term - the search term from the user
  
  potential_hit - the text that may be a hit
  
  accept_alternates - %TRUE to accept ASCII alternates
  
  Returns:
  
  %TRUE if @potential_hit is a hit
- strToAscii
  
  public static Str strToAscii(@Nonnull Str str, @Nullable Str from_locale)
  
  Transliterate @str to plain ASCII.
  
  For best results, @str should be in composed normalised form.
  
  This function performs a reasonably good set of character
  replacements. The particular set of replacements that is done may
  change by version or even by runtime environment.
  
  If the source language of @str is known, it can used to improve the
  accuracy of the translation by passing it as @from_locale. It should
  be a valid POSIX locale string (of the form
  `language[_territory][.codeset][@modifier]`).
  
  If @from_locale is %NULL then the current locale is used.
  
  If you want to do translation for no specific locale, and you want it
  to be done independently of the currently locale, specify `"C"` for
  @from_locale.
  
  Parameters:
  
  str - a string, in UTF-8
  
  from_locale - the source locale, if known
  
  Returns:
  
  a string in plain ASCII
- strcanon
  
  public static Str strcanon(@Nonnull Str string, @Nonnull Str valid_chars, byte substitutor)
  For each character in @string, if the character is not in @valid_chars,
  replaces the character with @substitutor.
  
  Modifies @string in place, and return @string itself, not a copy. The
  return value is to allow nesting such as:
  
   g_ascii_strup (g_strcanon (str, "abc", '?'))
  
  In order to modify a copy, you may use g_strdup():
  
   reformatted = g_strcanon (g_strdup (const_str), "abc", '?'); ... g_free (reformatted);
  Parameters:
  
  string - a nul-terminated array of bytes
  
  valid_chars - bytes permitted in @string
  
  substitutor - replacement character for disallowed bytes
  
  Returns:
  
  the modified @string
- strchomp
  
  public static Str strchomp(@Nonnull Str string)
  
  Removes trailing whitespace from a string.
  
  This function doesn't allocate or reallocate any memory;
  it modifies @string in place. Therefore, it cannot be used
  on statically allocated strings.
  
  The pointer to @string is returned to allow the nesting of functions.
  
  Also see g_strchug() and g_strstrip().
  
  Parameters:
  
  string - a string to remove the trailing whitespace from
  
  Returns:
  
  @string
- strchug
  
  public static Str strchug(@Nonnull Str string)
  
  Removes leading whitespace from a string, by moving the rest
  of the characters forward.
  
  This function doesn't allocate or reallocate any memory;
  it modifies @string in place. Therefore, it cannot be used on
  statically allocated strings.
  
  The pointer to @string is returned to allow the nesting of functions.
  
  Also see g_strchomp() and g_strstrip().
  
  Parameters:
  
  string - a string to remove the leading whitespace from
  
  Returns:
  
  @string
- strcmp0
  
  public static int strcmp0(@Nullable Str str1, @Nullable Str str2)
  
  Compares @str1 and @str2 like strcmp(). Handles %NULL
  gracefully by sorting it before non-%NULL strings.
  Comparing two %NULL pointers returns 0.
  
  Parameters:
  
  str1 - a C string or %NULL
  
  str2 - another C string or %NULL
  
  Returns:
  
  an integer less than, equal to, or greater than zero, if @str1 is <, == or > than @str2.
- strcompress
  
  public static Str strcompress(@Nonnull Str source)
  
  Replaces all escaped characters with their one byte equivalent.
  
  This function does the reverse conversion of g_strescape().
  
  Parameters:
  
  source - a string to compress
  
  Returns:
  
  a newly-allocated copy of @source with all escaped character compressed
- strconcat
  
  public static Str strconcat(@Nonnull Str string1, Object... _elipse)
  
  Concatenates all of the given strings into one long string. The
  returned string should be freed with g_free() when no longer needed.
  
  The variable argument list must end with %NULL. If you forget the %NULL,
  g_strconcat() will start appending random memory junk to your string.
  
  Note that this function is usually not the right function to use to
  assemble a translated message from pieces, since proper translation
  often requires the pieces to be reordered.
  
  Parameters:
  
  string1 - the first string to add, which must not be %NULL
  
  _elipse - a %NULL-terminated list of strings to append to the string
  
  Returns:
  
  a newly-allocated string containing all the string arguments
- strdelimit
  
  public static Str strdelimit(@Nonnull Str string, @Nullable Str delimiters, byte new_delimiter)
  Converts any delimiter characters in @string to @new_delimiter.
  
  Any characters in @string which are found in @delimiters are
  changed to the @new_delimiter character. Modifies @string in place,
  and returns @string itself, not a copy.
  
  The return value is to allow nesting such as:
  
   g_ascii_strup (g_strdelimit (str, "abc", '?'))
  
  In order to modify a copy, you may use g_strdup():
  
   reformatted = g_strdelimit (g_strdup (const_str), "abc", '?'); ... g_free (reformatted);
  Parameters:
  
  string - the string to convert
  
  delimiters - a string containing the current delimiters, or %NULL to use the standard delimiters defined in %G_STR_DELIMITERS
  
  new_delimiter - the new delimiter character
  
  Returns:
  
  the modified @string
- strdup
  
  public static Str strdup(@Nullable Str str)
  
  Duplicates a string. If @str is %NULL it returns %NULL.
  The returned string should be freed with g_free()
  when no longer needed.
  
  Parameters:
  
  str - the string to duplicate
  
  Returns:
  
  a newly-allocated copy of @str
- strdupPrintf
  
  public static Str strdupPrintf(@Nonnull Str format, Object... _elipse)
  
  Similar to the standard C sprintf() function but safer, since it
  calculates the maximum space required and allocates memory to hold
  the result. The returned string should be freed with g_free() when no
  longer needed.
  
  The returned string is guaranteed to be non-NULL, unless @format
  contains `%lc` or `%ls` conversions, which can fail if no multibyte
  representation is available for the given character.
  
  Parameters:
  
  format - a standard printf() format string, but notice [string precision pitfalls][string-precision]
  
  _elipse - the parameters to insert into the format string
  
  Returns:
  
  a newly-allocated string holding the result
- strerror
  
  public static Str strerror(int errnum)
  Returns a string corresponding to the given error code, e.g. "no
  such process". Unlike strerror(), this always returns a string in
  UTF-8 encoding, and the pointer is guaranteed to remain valid for
  the lifetime of the process.
  
  Note that the string may be translated according to the current locale.
  
  The value of %errno will not be changed by this function. However, it may
  be changed by intermediate function calls, so you should save its value
  as soon as the call returns:
  int saved_errno; ret = read (blah); saved_errno = errno; g_strerror (saved_errno);
  Parameters:
  
  errnum - the system error number. See the standard C %errno documentation
  
  Returns:
  
  a UTF-8 string describing the error code. If the error code is unknown, it returns a string like "Unknown error: <code>".
- strescape
  
  public static Str strescape(@Nonnull Str source, @Nullable Str exceptions)
  
  Escapes the special characters '\b', '\f', '\n', '\r', '\t', '\v', '\'
  and '"' in the string @source by inserting a '\' before
  them. Additionally all characters in the range 0x01-0x1F (everything
  below SPACE) and in the range 0x7F-0xFF (all non-ASCII chars) are
  replaced with a '\' followed by their octal representation.
  Characters supplied in @exceptions are not escaped.
  
  g_strcompress() does the reverse conversion.
  
  Parameters:
  
  source - a string to escape
  
  exceptions - a string of characters not to escape in @source
  
  Returns:
  
  a newly-allocated copy of @source with certain characters escaped. See above.
- stripContext
  
  public static Str stripContext(@Nonnull Str msgid, @Nonnull Str msgval)
  
  An auxiliary function for gettext() support (see Q_()).
  
  Parameters:
  
  msgid - a string
  
  msgval - another string
  
  Returns:
  
  @msgval, unless @msgval is identical to @msgid and contains a '|' character, in which case a pointer to the substring of msgid after the first '|' character is returned.
- strjoin
  
  public static Str strjoin(@Nullable Str separator, Object... _elipse)
  
  Joins a number of strings together to form one long string, with the
  optional @separator inserted between each of them. The returned string
  should be freed with g_free().
  
  Parameters:
  
  separator - a string to insert between each of the strings, or %NULL
  
  _elipse - a %NULL-terminated list of strings to join
  
  Returns:
  
  a newly-allocated string containing all of the strings joined together, with @separator between them
- strlcat
  
  public static long strlcat(@Nonnull Str dest, @Nonnull Str src, long dest_size)
  
  Portability wrapper that calls strlcat() on systems which have it,
  and emulates it otherwise. Appends nul-terminated @src string to @dest,
  guaranteeing nul-termination for @dest. The total size of @dest won't
  exceed @dest_size.
  
  At most @dest_size - 1 characters will be copied. Unlike strncat(),
  @dest_size is the full size of dest, not the space left over. This
  function does not allocate memory. It always nul-terminates (unless
  @dest_size == 0 or there were no nul characters in the @dest_size
  characters of dest to start with).
  
  Caveat: this is supposedly a more secure alternative to strcat() or
  strncat(), but for real security g_strconcat() is harder to mess up.
  
  Parameters:
  
  dest - destination buffer, already containing one nul-terminated string
  
  src - source buffer
  
  dest_size - length of @dest buffer in bytes (not length of existing string inside @dest)
  
  Returns:
  
  size of attempted result, which is MIN (dest_size, strlen (original dest)) + strlen (src), so if retval >= dest_size, truncation occurred.
- strlcpy
  
  public static long strlcpy(@Nonnull Str dest, @Nonnull Str src, long dest_size)
  
  Portability wrapper that calls strlcpy() on systems which have it,
  and emulates strlcpy() otherwise. Copies @src to @dest; @dest is
  guaranteed to be nul-terminated; @src must be nul-terminated;
  @dest_size is the buffer size, not the number of bytes to copy.
  
  At most @dest_size - 1 characters will be copied. Always nul-terminates
  (unless @dest_size is 0). This function does not allocate memory. Unlike
  strncpy(), this function doesn't pad @dest (so it's often faster). It
  returns the size of the attempted result, strlen (src), so if
  @retval >= @dest_size, truncation occurred.
  
  Caveat: strlcpy() is supposedly more secure than strcpy() or strncpy(),
  but if you really want to avoid screwups, g_strdup() is an even better
  idea.
  
  Parameters:
  
  dest - destination buffer
  
  src - source buffer
  
  dest_size - length of @dest in bytes
  
  Returns:
  
  length of @src
- strndup
  
  public static Str strndup(@Nonnull Str str, long n)
  
  Duplicates the first @n bytes of a string, returning a newly-allocated
  buffer @n + 1 bytes long which will always be nul-terminated. If @str
  is less than @n bytes long the buffer is padded with nuls. If @str is
  %NULL it returns %NULL. The returned value should be freed when no longer
  needed.
  
  To copy a number of characters from a UTF-8 encoded string,
  use g_utf8_strncpy() instead.
  
  Parameters:
  
  str - the string to duplicate
  
  n - the maximum number of bytes to copy from @str
  
  Returns:
  
  a newly-allocated buffer containing the first @n bytes of @str, nul-terminated
- strnfill
  
  public static Str strnfill(long length, byte fill_char)
  
  Creates a new string @length bytes long filled with @fill_char.
  The returned string should be freed when no longer needed.
  
  Parameters:
  
  length - the length of the new string
  
  fill_char - the byte to fill the string with
  
  Returns:
  
  a newly-allocated string filled the @fill_char
- strreverse
  
  public static Str strreverse(@Nonnull Str string)
  
  Reverses all of the bytes in a string. For example,
  `g_strreverse ("abcdef")` will result in "fedcba".
  
  Note that g_strreverse() doesn't work on UTF-8 strings
  containing multibyte characters. For that purpose, use
  g_utf8_strreverse().
  
  Parameters:
  
  string - the string to reverse
  
  Returns:
  
  the same pointer passed in as @string
- strrstr
  
  public static Str strrstr(@Nonnull Str haystack, @Nonnull Str needle)
  
  Searches the string @haystack for the last occurrence
  of the string @needle.
  
  Parameters:
  
  haystack - a nul-terminated string
  
  needle - the nul-terminated string to search for
  
  Returns:
  
  a pointer to the found occurrence, or %NULL if not found.
- strrstrLen
  
  public static Str strrstrLen(@Nonnull Str haystack, long haystack_len, @Nonnull Str needle)
  
  Searches the string @haystack for the last occurrence
  of the string @needle, limiting the length of the search
  to @haystack_len.
  
  Parameters:
  
  haystack - a nul-terminated string
  
  haystack_len - the maximum length of @haystack in bytes. A length of -1 can be used to mean "search the entire string", like g_strrstr().
  
  needle - the nul-terminated string to search for
  
  Returns:
  
  a pointer to the found occurrence, or %NULL if not found.
- strsignal
  
  public static Str strsignal(int signum)
  
  Returns a string describing the given signal, e.g. "Segmentation fault".
  You should use this function in preference to strsignal(), because it
  returns a string in UTF-8 encoding, and since not all platforms support
  the strsignal() function.
  
  Parameters:
  
  signum - the signal number. See the `signal` documentation
  
  Returns:
  
  a UTF-8 string describing the signal. If the signal is unknown, it returns "unknown signal (<signum>)".
- strstrLen
  
  public static Str strstrLen(@Nonnull Str haystack, long haystack_len, @Nonnull Str needle)
  
  Searches the string @haystack for the first occurrence
  of the string @needle, limiting the length of the search
  to @haystack_len.
  
  Parameters:
  
  haystack - a nul-terminated string
  
  haystack_len - the maximum length of @haystack in bytes. A length of -1 can be used to mean "search the entire string", like `strstr()`.
  
  needle - the string to search for
  
  Returns:
  
  a pointer to the found occurrence, or %NULL if not found.
- strvGetType
  
  public static long strvGetType()
  
  Returns:
- testAddDataFunc
  
  public static void testAddDataFunc(@Nonnull Str testpath, @Nullable Pointer test_data, Glib.OnTestDataFunc test_func)
  
  Create a new test case, similar to g_test_create_case(). However
  the test is assumed to use no fixture, and test suites are automatically
  created on the fly and added to the root fixture, based on the
  slash-separated portions of @testpath. The @test_data argument
  will be passed as first argument to @test_func.
  
  If @testpath includes the component "subprocess" anywhere in it,
  the test will be skipped by default, and only run if explicitly
  required via the `-p` command-line option or g_test_trap_subprocess().
  
  No component of @testpath may start with a dot (`.`) if the
  %G_TEST_OPTION_ISOLATE_DIRS option is being used; and it is recommended to
  do so even if it isn’t.
  
  Parameters:
  
  testpath - /-separated test case path name for the test.
  
  test_data - Test data argument for the test function.
  
  test_func - The test function to invoke for this test.
- testAddDataFuncFull
  
  public static void testAddDataFuncFull(@Nonnull Str testpath, @Nullable Pointer test_data, Glib.OnTestDataFunc test_func, Glib.OnDestroyNotify data_free_func)
  
  Create a new test case, as with g_test_add_data_func(), but freeing
  @test_data after the test run is complete.
  
  Parameters:
  
  testpath - /-separated test case path name for the test.
  
  test_data - Test data argument for the test function.
  
  test_func - The test function to invoke for this test.
  
  data_free_func - #GDestroyNotify for @test_data.
- testAddFunc
  
  public static void testAddFunc(@Nonnull Str testpath, Glib.OnTestFunc test_func)
  
  Create a new test case, similar to g_test_create_case(). However
  the test is assumed to use no fixture, and test suites are automatically
  created on the fly and added to the root fixture, based on the
  slash-separated portions of @testpath.
  
  If @testpath includes the component "subprocess" anywhere in it,
  the test will be skipped by default, and only run if explicitly
  required via the `-p` command-line option or g_test_trap_subprocess().
  
  No component of @testpath may start with a dot (`.`) if the
  %G_TEST_OPTION_ISOLATE_DIRS option is being used; and it is recommended to
  do so even if it isn’t.
  
  Parameters:
  
  testpath - /-separated test case path name for the test.
  
  test_func - The test function to invoke for this test.
- testAddVtable
  
  public static void testAddVtable(@Nonnull Str testpath, long data_size, @Nullable Pointer test_data, Glib.OnTestFixtureFunc data_setup, Glib.OnTestFixtureFunc data_test, Glib.OnTestFixtureFunc data_teardown)
  
  Parameters:
  
  testpath -
  
  data_size -
  
  test_data -
  
  data_setup -
  
  data_test -
  
  data_teardown -
- testAssertExpectedMessagesInternal
  
  public static void testAssertExpectedMessagesInternal(@Nonnull Str domain, @Nonnull Str file, int line, @Nonnull Str func)
  
  Parameters:
  
  domain -
  
  file -
  
  line -
  
  func -
- testBug
  
  public static void testBug(@Nonnull Str bug_uri_snippet)
  
  This function adds a message to test reports that
  associates a bug URI with a test case.
  
  Bug URIs are constructed from a base URI set with g_test_bug_base()
  and @bug_uri_snippet. If g_test_bug_base() has not been called, it is
  assumed to be the empty string, so a full URI can be provided to
  g_test_bug() instead.
  
  Since GLib 2.70, the base URI is not prepended to @bug_uri_snippet if it
  is already a valid URI.
  
  Parameters:
  
  bug_uri_snippet - Bug specific bug tracker URI or URI portion.
- testBugBase
  
  public static void testBugBase(@Nonnull Str uri_pattern)
  
  Specify the base URI for bug reports.
  
  The base URI is used to construct bug report messages for
  g_test_message() when g_test_bug() is called.
  Calling this function outside of a test case sets the
  default base URI for all test cases. Calling it from within
  a test case changes the base URI for the scope of the test
  case only.
  Bug URIs are constructed by appending a bug specific URI
  portion to @uri_pattern, or by replacing the special string
  `%s` within @uri_pattern if that is present.
  
  If g_test_bug_base() is not called, bug URIs are formed solely
  from the value provided by g_test_bug().
  
  Parameters:
  
  uri_pattern - the base pattern for bug URIs
- testBuildFilename
  
  public static Str testBuildFilename(int file_type, @Nonnull Str first_path, Object... _elipse)
  
  Creates the pathname to a data file that is required for a test.
  
  This function is conceptually similar to g_build_filename() except
  that the first argument has been replaced with a #GTestFileType
  argument.
  
  The data file should either have been distributed with the module
  containing the test (%G_TEST_DIST) or built as part of the build
  system of that module (%G_TEST_BUILT).
  
  In order for this function to work in srcdir != builddir situations,
  the G_TEST_SRCDIR and G_TEST_BUILDDIR environment variables need to
  have been defined. As of 2.38, this is done by the glib.mk
  included in GLib. Please ensure that your copy is up to date before
  using this function.
  
  In case neither variable is set, this function will fall back to
  using the dirname portion of argv[0], possibly removing ".libs".
  This allows for casual running of tests directly from the commandline
  in the srcdir == builddir case and should also support running of
  installed tests, assuming the data files have been installed in the
  same relative path as the test binary.
  
  Parameters:
  
  file_type - the type of file (built vs. distributed)
  
  first_path - the first segment of the pathname
  
  _elipse - %NULL-terminated additional path segments
  
  Returns:
  
  the path of the file, to be freed using g_free()
- testCreateCase
  
  public static ch.bailu.gtk.glib.TestCase testCreateCase(@Nonnull Str test_name, long data_size, @Nullable Pointer test_data, Glib.OnTestFixtureFunc data_setup, Glib.OnTestFixtureFunc data_test, Glib.OnTestFixtureFunc data_teardown)
  
  Create a new #GTestCase, named @test_name.
  
  This API is fairly low level, and calling g_test_add() or g_test_add_func()
  is preferable.
  
  When this test is executed, a fixture structure of size @data_size
  will be automatically allocated and filled with zeros. Then @data_setup is
  called to initialize the fixture. After fixture setup, the actual test
  function @data_test is called. Once the test run completes, the
  fixture structure is torn down by calling @data_teardown and
  after that the memory is automatically released by the test framework.
  
  Splitting up a test run into fixture setup, test function and
  fixture teardown is most useful if the same fixture type is used for
  multiple tests. In this cases, g_test_create_case() will be
  called with the same type of fixture (the @data_size argument), but varying
  @test_name and @data_test arguments.
  
  Parameters:
  
  test_name - the name for the test case
  
  data_size - the size of the fixture data structure
  
  test_data - test data argument for the test functions
  
  data_setup - the function to set up the fixture data
  
  data_test - the actual test function
  
  data_teardown - the function to teardown the fixture data
  
  Returns:
  
  a newly allocated #GTestCase.
- testCreateSuite
  
  public static ch.bailu.gtk.glib.TestSuite testCreateSuite(@Nonnull Str suite_name)
  
  Create a new test suite with the name @suite_name.
  
  Parameters:
  
  suite_name - a name for the suite
  
  Returns:
  
  A newly allocated #GTestSuite instance.
- testExpectMessage
  
  public static void testExpectMessage(@Nullable Str log_domain, int log_level, @Nonnull Str pattern)
  Indicates that a message with the given @log_domain and @log_level,
  with text matching @pattern, is expected to be logged. When this
  message is logged, it will not be printed, and the test case will
  not abort.
  
  This API may only be used with the old logging API (g_log() without
  %G_LOG_USE_STRUCTURED defined). It will not work with the structured logging
  API. See [Testing for Messages][testing-for-messages].
  
  Use g_test_assert_expected_messages() to assert that all
  previously-expected messages have been seen and suppressed.
  
  You can call this multiple times in a row, if multiple messages are
  expected as a result of a single call. (The messages must appear in
  the same order as the calls to g_test_expect_message().)
  
  For example:
  
   // g_main_context_push_thread_default() should fail if the // context is already owned by another thread. g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "assertion*acquired_context*failed"); g_main_context_push_thread_default (bad_context); g_test_assert_expected_messages ();
  
  Note that you cannot use this to test g_error() messages, since
  g_error() intentionally never returns even if the program doesn't
  abort; use g_test_trap_subprocess() in this case.
  
  If messages at %G_LOG_LEVEL_DEBUG are emitted, but not explicitly
  expected via g_test_expect_message() then they will be ignored.
  Parameters:
  
  log_domain - the log domain of the message
  
  log_level - the log level of the message
  
  pattern - a glob-style [pattern][glib-Glob-style-pattern-matching]
- testFail
  
  public static void testFail()
  
  Indicates that a test failed. This function can be called
  multiple times from the same test. You can use this function
  if your test failed in a recoverable way.
  
  Do not use this function if the failure of a test could cause
  other tests to malfunction.
  
  Calling this function will not stop the test from running, you
  need to return from the test function yourself. So you can
  produce additional diagnostic messages or even continue running
  the test.
  
  If not called from inside a test, this function does nothing.
  
  Note that unlike g_test_skip() and g_test_incomplete(), this
  function does not log a message alongside the test failure.
  If details of the test failure are available, either log them with
  g_test_message() before g_test_fail(), or use g_test_fail_printf()
  instead.
- testFailPrintf
  
  public static void testFailPrintf(@Nonnull Str format, Object... _elipse)
  
  Equivalent to g_test_fail(), but also record a message like
  g_test_skip_printf().
  
  Parameters:
  
  format - the format string
  
  _elipse - printf-like arguments to @format
- testFailed
  
  public static boolean testFailed()
  
  Returns whether a test has already failed. This will
  be the case when g_test_fail(), g_test_incomplete()
  or g_test_skip() have been called, but also if an
  assertion has failed.
  
  This can be useful to return early from a test if
  continuing after a failed assertion might be harmful.
  
  The return value of this function is only meaningful
  if it is called from inside a test function.
  
  Returns:
  
  %TRUE if the test has failed
- testGetDir
  
  public static Str testGetDir(int file_type)
  
  Gets the pathname of the directory containing test files of the type
  specified by @file_type.
  
  This is approximately the same as calling g_test_build_filename("."),
  but you don't need to free the return value.
  
  Parameters:
  
  file_type - the type of file (built vs. distributed)
  
  Returns:
  
  the path of the directory, owned by GLib
- testGetFilename
  
  public static Str testGetFilename(int file_type, @Nonnull Str first_path, Object... _elipse)
  
  Gets the pathname to a data file that is required for a test.
  
  This is the same as g_test_build_filename() with two differences.
  The first difference is that you must only use this function from within
  a testcase function. The second difference is that you need not free
  the return value — it will be automatically freed when the testcase
  finishes running.
  
  It is safe to use this function from a thread inside of a testcase
  but you must ensure that all such uses occur before the main testcase
  function returns (ie: it is best to ensure that all threads have been
  joined).
  
  Parameters:
  
  file_type - the type of file (built vs. distributed)
  
  first_path - the first segment of the pathname
  
  _elipse - %NULL-terminated additional path segments
  
  Returns:
  
  the path, automatically freed at the end of the testcase
- testGetPath
  
  public static Str testGetPath()
  
  Gets the test path for the test currently being run.
  
  In essence, it will be the same string passed as the first argument to
  e.g. g_test_add() when the test was added.
  
  This function returns a valid string only within a test function.
  
  Returns:
  
  the test path for the test currently being run
- testGetRoot
  
  public static ch.bailu.gtk.glib.TestSuite testGetRoot()
  
  Get the toplevel test suite for the test path API.
  
  Returns:
  
  the toplevel #GTestSuite
- testIncomplete
  
  public static void testIncomplete(@Nullable Str msg)
  
  Indicates that a test failed because of some incomplete
  functionality. This function can be called multiple times
  from the same test.
  
  Calling this function will not stop the test from running, you
  need to return from the test function yourself. So you can
  produce additional diagnostic messages or even continue running
  the test.
  
  If not called from inside a test, this function does nothing.
  
  Parameters:
  
  msg - explanation
- testIncompletePrintf
  
  public static void testIncompletePrintf(@Nonnull Str format, Object... _elipse)
  
  Equivalent to g_test_incomplete(), but the explanation is formatted
  as if by g_strdup_printf().
  
  Parameters:
  
  format - the format string
  
  _elipse - printf-like arguments to @format
- testLogSetFatalHandler
  
  public static void testLogSetFatalHandler(Glib.OnTestLogFatalFunc log_func, @Nullable Pointer user_data)
  
  Installs a non-error fatal log handler which can be
  used to decide whether log messages which are counted
  as fatal abort the program.
  
  The use case here is that you are running a test case
  that depends on particular libraries or circumstances
  and cannot prevent certain known critical or warning
  messages. So you install a handler that compares the
  domain and message to precisely not abort in such a case.
  
  Note that the handler is reset at the beginning of
  any test case, so you have to set it inside each test
  function which needs the special behavior.
  
  This handler has no effect on g_error messages.
  
  This handler also has no effect on structured log messages (using
  g_log_structured() or g_log_structured_array()). To change the fatal
  behaviour for specific log messages, programs must install a custom log
  writer function using g_log_set_writer_func().See
  [Using Structured Logging][using-structured-logging].
  
  Parameters:
  
  log_func - the log handler function.
  
  user_data - data passed to the log handler.
- testLogTypeName
  
  public static Str testLogTypeName(int log_type)
  
  Parameters:
  
  log_type -
  
  Returns:
- testMaximizedResult
  
  public static void testMaximizedResult(double maximized_quantity, @Nonnull Str format, Object... _elipse)
  
  Report the result of a performance or measurement test.
  The test should generally strive to maximize the reported
  quantities (larger values are better than smaller ones),
  this and @maximized_quantity can determine sorting
  order for test result reports.
  
  Parameters:
  
  maximized_quantity - the reported value
  
  format - the format string of the report message
  
  _elipse - arguments to pass to the printf() function
- testMessage
  
  public static void testMessage(@Nonnull Str format, Object... _elipse)
  
  Add a message to the test report.
  
  Parameters:
  
  format - the format string
  
  _elipse - printf-like arguments to @format
- testMinimizedResult
  
  public static void testMinimizedResult(double minimized_quantity, @Nonnull Str format, Object... _elipse)
  
  Report the result of a performance or measurement test.
  The test should generally strive to minimize the reported
  quantities (smaller values are better than larger ones),
  this and @minimized_quantity can determine sorting
  order for test result reports.
  
  Parameters:
  
  minimized_quantity - the reported value
  
  format - the format string of the report message
  
  _elipse - arguments to pass to the printf() function
- testQueueDestroy
  
  public static void testQueueDestroy(Glib.OnDestroyNotify destroy_func, @Nullable Pointer destroy_data)
  
  This function enqueus a callback @destroy_func to be executed
  during the next test case teardown phase. This is most useful
  to auto destruct allocated test resources at the end of a test run.
  Resources are released in reverse queue order, that means enqueueing
  callback A before callback B will cause B() to be called before
  A() during teardown.
  
  Parameters:
  
  destroy_func - Destroy callback for teardown phase.
  
  destroy_data - Destroy callback data.
- testQueueFree
  
  public static void testQueueFree(@Nullable Pointer gfree_pointer)
  
  Enqueue a pointer to be released with g_free() during the next
  teardown phase. This is equivalent to calling g_test_queue_destroy()
  with a destroy callback of g_free().
  
  Parameters:
  
  gfree_pointer - the pointer to be stored.
- testRandDouble
  
  public static double testRandDouble()
  
  Get a reproducible random floating point number,
  see g_test_rand_int() for details on test case random numbers.
  
  Returns:
  
  a random number from the seeded random number generator.
- testRandDoubleRange
  
  public static double testRandDoubleRange(double range_start, double range_end)
  
  Get a reproducible random floating pointer number out of a specified range,
  see g_test_rand_int() for details on test case random numbers.
  
  Parameters:
  
  range_start - the minimum value returned by this function
  
  range_end - the minimum value not returned by this function
  
  Returns:
  
  a number with @range_start <= number < @range_end.
- testRandInt
  
  public static int testRandInt()
  
  Get a reproducible random integer number.
  
  The random numbers generated by the g_test_rand_*() family of functions
  change with every new test program start, unless the --seed option is
  given when starting test programs.
  
  For individual test cases however, the random number generator is
  reseeded, to avoid dependencies between tests and to make --seed
  effective for all test cases.
  
  Returns:
  
  a random number from the seeded random number generator.
- testRandIntRange
  
  public static int testRandIntRange(int begin, int end)
  
  Get a reproducible random integer number out of a specified range,
  see g_test_rand_int() for details on test case random numbers.
  
  Parameters:
  
  begin - the minimum value returned by this function
  
  end - the smallest value not to be returned by this function
  
  Returns:
  
  a number with @begin <= number < @end.
- testRun
  
  public static int testRun()
  
  Runs all tests under the toplevel suite which can be retrieved
  with g_test_get_root(). Similar to g_test_run_suite(), the test
  cases to be run are filtered according to test path arguments
  (`-p testpath` and `-s testpath`) as parsed by g_test_init().
  g_test_run_suite() or g_test_run() may only be called once in a
  program.
  
  In general, the tests and sub-suites within each suite are run in
  the order in which they are defined. However, note that prior to
  GLib 2.36, there was a bug in the `g_test_add_*`
  functions which caused them to create multiple suites with the same
  name, meaning that if you created tests "/foo/simple",
  "/bar/simple", and "/foo/using-bar" in that order, they would get
  run in that order (since g_test_run() would run the first "/foo"
  suite, then the "/bar" suite, then the second "/foo" suite). As of
  2.36, this bug is fixed, and adding the tests in that order would
  result in a running order of "/foo/simple", "/foo/using-bar",
  "/bar/simple". If this new ordering is sub-optimal (because it puts
  more-complicated tests before simpler ones, making it harder to
  figure out exactly what has failed), you can fix it by changing the
  test paths to group tests by suite in a way that will result in the
  desired running order. Eg, "/simple/foo", "/simple/bar",
  "/complex/foo-using-bar".
  
  However, you should never make the actual result of a test depend
  on the order that tests are run in. If you need to ensure that some
  particular code runs before or after a given test case, use
  g_test_add(), which lets you specify setup and teardown functions.
  
  If all tests are skipped or marked as incomplete (expected failures),
  this function will return 0 if producing TAP output, or 77 (treated
  as "skip test" by Automake) otherwise.
  
  Returns:
  
  0 on success, 1 on failure (assuming it returns at all), 0 or 77 if all tests were skipped with g_test_skip() and/or g_test_incomplete()
- testRunSuite
  
  public static int testRunSuite(@Nonnull ch.bailu.gtk.glib.TestSuite suite)
  
  Execute the tests within @suite and all nested #GTestSuites.
  The test suites to be executed are filtered according to
  test path arguments (`-p testpath` and `-s testpath`) as parsed by
  g_test_init(). See the g_test_run() documentation for more
  information on the order that tests are run in.
  
  g_test_run_suite() or g_test_run() may only be called once
  in a program.
  
  Parameters:
  
  suite - a #GTestSuite
  
  Returns:
  
  0 on success
- testSetNonfatalAssertions
  
  public static void testSetNonfatalAssertions()
  
  Changes the behaviour of the various `g_assert_*()` macros,
  g_test_assert_expected_messages() and the various
  `g_test_trap_assert_*()` macros to not abort to program, but instead
  call g_test_fail() and continue. (This also changes the behavior of
  g_test_fail() so that it will not cause the test program to abort
  after completing the failed test.)
  
  Note that the g_assert_not_reached() and g_assert() macros are not
  affected by this.
  
  This function can only be called after g_test_init().
- testSkip
  
  public static void testSkip(@Nullable Str msg)
  
  Indicates that a test was skipped.
  
  Calling this function will not stop the test from running, you
  need to return from the test function yourself. So you can
  produce additional diagnostic messages or even continue running
  the test.
  
  If not called from inside a test, this function does nothing.
  
  Parameters:
  
  msg - explanation
- testSkipPrintf
  
  public static void testSkipPrintf(@Nonnull Str format, Object... _elipse)
  
  Equivalent to g_test_skip(), but the explanation is formatted
  as if by g_strdup_printf().
  
  Parameters:
  
  format - the format string
  
  _elipse - printf-like arguments to @format
- testSubprocess
  
  public static boolean testSubprocess()
  
  Returns %TRUE (after g_test_init() has been called) if the test
  program is running under g_test_trap_subprocess().
  
  Returns:
  
  %TRUE if the test program is running under g_test_trap_subprocess().
- testSummary
  
  public static void testSummary(@Nonnull Str summary)
  Set the summary for a test, which describes what the test checks, and how it
  goes about checking it. This may be included in test report output, and is
  useful documentation for anyone reading the source code or modifying a test
  in future. It must be a single line.
  
  This should be called at the top of a test function.
  
  For example:
   static void test_array_sort (void) { g_test_summary ("Test my_array_sort() sorts the array correctly and stably, " "including testing zero length and one-element arrays."); … }
  Parameters:
  
  summary - One or two sentences summarising what the test checks, and how it checks it.
- testTimerElapsed
  
  public static double testTimerElapsed()
  
  Get the number of seconds since the last start of the timer with
  g_test_timer_start().
  
  Returns:
  
  the time since the last start of the timer in seconds, as a double
- testTimerLast
  
  public static double testTimerLast()
  
  Report the last result of g_test_timer_elapsed().
  
  Returns:
  
  the last result of g_test_timer_elapsed(), as a double
- testTimerStart
  
  public static void testTimerStart()
  
  Start a timing test. Call g_test_timer_elapsed() when the task is supposed
  to be done. Call this function again to restart the timer.
- testTrapAssertions
  
  public static void testTrapAssertions(@Nonnull Str domain, @Nonnull Str file, int line, @Nonnull Str func, long assertion_flags, @Nonnull Str pattern)
  
  Parameters:
  
  domain -
  
  file -
  
  line -
  
  func -
  
  assertion_flags -
  
  pattern -
- testTrapHasPassed
  
  public static boolean testTrapHasPassed()
  
  Check the result of the last g_test_trap_subprocess() call.
  
  Returns:
  
  %TRUE if the last test subprocess terminated successfully.
- testTrapReachedTimeout
  
  public static boolean testTrapReachedTimeout()
  
  Check the result of the last g_test_trap_subprocess() call.
  
  Returns:
  
  %TRUE if the last test subprocess got killed due to a timeout.
- testTrapSubprocess
  
  public static void testTrapSubprocess(@Nullable Str test_path, long usec_timeout, int test_flags)
  Respawns the test program to run only @test_path in a subprocess.
  This can be used for a test case that might not return, or that
  might abort.
  
  If @test_path is %NULL then the same test is re-run in a subprocess.
  You can use g_test_subprocess() to determine whether the test is in
  a subprocess or not.
  
  @test_path can also be the name of the parent test, followed by
  "`/subprocess/`" and then a name for the specific subtest (or just
  ending with "`/subprocess`" if the test only has one child test);
  tests with names of this form will automatically be skipped in the
  parent process.
  
  If @usec_timeout is non-0, the test subprocess is aborted and
  considered failing if its run time exceeds it.
  
  The subprocess behavior can be configured with the
  #GTestSubprocessFlags flags.
  
  You can use methods such as g_test_trap_assert_passed(),
  g_test_trap_assert_failed(), and g_test_trap_assert_stderr() to
  check the results of the subprocess. (But note that
  g_test_trap_assert_stdout() and g_test_trap_assert_stderr()
  cannot be used if @test_flags specifies that the child should
  inherit the parent stdout/stderr.)
  
  If your `main ()` needs to behave differently in
  the subprocess, you can call g_test_subprocess() (after calling
  g_test_init()) to see whether you are in a subprocess.
  
  The following example tests that calling
  `my_object_new(1000000)` will abort with an error
  message.
  
   static void test_create_large_object (void) { if (g_test_subprocess ()) { my_object_new (1000000); return; } // Reruns this same test in a subprocess g_test_trap_subprocess (NULL, 0, G_TEST_SUBPROCESS_DEFAULT); g_test_trap_assert_failed (); g_test_trap_assert_stderr ("*ERROR*too large*"); } int main (int argc, char **argv) { g_test_init (&argc, &argv, NULL); g_test_add_func ("/myobject/create_large_object", test_create_large_object); return g_test_run (); }
  Parameters:
  
  test_path - Test to run in a subprocess
  
  usec_timeout - Timeout for the subprocess test in micro seconds.
  
  test_flags - Flags to modify subprocess behaviour.
- threadErrorQuark
  
  public static int threadErrorQuark()
  
  Returns:
- threadExit
  
  public static void threadExit(@Nullable Pointer retval)
  
  Terminates the current thread.
  
  If another thread is waiting for us using g_thread_join() then the
  waiting thread will be woken up and get @retval as the return value
  of g_thread_join().
  
  Calling g_thread_exit() with a parameter @retval is equivalent to
  returning @retval from the function @func, as given to g_thread_new().
  
  You must only call g_thread_exit() from a thread that you created
  yourself with g_thread_new() or related APIs. You must not call
  this function from a thread created with another threading library
  or or from within a #GThreadPool.
  
  Parameters:
  
  retval - the return value of this thread
- threadPoolGetMaxIdleTime
  
  public static int threadPoolGetMaxIdleTime()
  
  This function will return the maximum @interval that a
  thread will wait in the thread pool for new tasks before
  being stopped.
  
  If this function returns 0, threads waiting in the thread
  pool for new work are not stopped.
  
  Returns:
  
  the maximum @interval (milliseconds) to wait for new tasks in the thread pool before stopping the thread
- threadPoolGetMaxUnusedThreads
  
  public static int threadPoolGetMaxUnusedThreads()
  
  Returns the maximal allowed number of unused threads.
  
  Returns:
  
  the maximal number of unused threads
- threadPoolGetNumUnusedThreads
  
  public static int threadPoolGetNumUnusedThreads()
  
  Returns the number of currently unused threads.
  
  Returns:
  
  the number of currently unused threads
- threadPoolSetMaxIdleTime
  
  public static void threadPoolSetMaxIdleTime(int interval)
  
  This function will set the maximum @interval that a thread
  waiting in the pool for new tasks can be idle for before
  being stopped. This function is similar to calling
  g_thread_pool_stop_unused_threads() on a regular timeout,
  except this is done on a per thread basis.
  
  By setting @interval to 0, idle threads will not be stopped.
  
  The default value is 15000 (15 seconds).
  
  Parameters:
  
  interval - the maximum @interval (in milliseconds) a thread can be idle
- threadPoolSetMaxUnusedThreads
  
  public static void threadPoolSetMaxUnusedThreads(int max_threads)
  
  Sets the maximal number of unused threads to @max_threads.
  If @max_threads is -1, no limit is imposed on the number
  of unused threads.
  
  The default value is 2.
  
  Parameters:
  
  max_threads - maximal number of unused threads
- threadPoolStopUnusedThreads
  
  public static void threadPoolStopUnusedThreads()
  
  Stops all currently unused threads. This does not change the
  maximal number of unused threads. This function can be used to
  regularly stop all unused threads e.g. from g_timeout_add().
- threadSelf
  
  public static Thread threadSelf()
  
  This function returns the #GThread corresponding to the
  current thread. Note that this function does not increase
  the reference count of the returned struct.
  
  This function will return a #GThread even for threads that
  were not created by GLib (i.e. those created by other threading
  APIs). This may be useful for thread identification purposes
  (i.e. comparisons) but you must not use GLib functions (such
  as g_thread_join()) on these threads.
  
  Returns:
  
  the #GThread representing the current thread
- threadYield
  
  public static void threadYield()
  
  Causes the calling thread to voluntarily relinquish the CPU, so
  that other threads can run.
  
  This function is often used as a method to make busy wait less evil.
- timeoutAdd
  
  public static int timeoutAdd(int interval, Glib.OnSourceFunc function, @Nullable Pointer data)
  
  Sets a function to be called at regular intervals, with the default
  priority, %G_PRIORITY_DEFAULT.
  
  The given @function is called repeatedly until it returns %G_SOURCE_REMOVE
  or %FALSE, at which point the timeout is automatically destroyed and the
  function will not be called again. The first call to the function will be
  at the end of the first @interval.
  
  Note that timeout functions may be delayed, due to the processing of other
  event sources. Thus they should not be relied on for precise timing.
  After each call to the timeout function, the time of the next
  timeout is recalculated based on the current time and the given interval
  (it does not try to 'catch up' time lost in delays).
  
  See [memory management of sources][mainloop-memory-management] for details
  on how to handle the return value and memory management of @data.
  
  If you want to have a timer in the "seconds" range and do not care
  about the exact time of the first call of the timer, use the
  g_timeout_add_seconds() function; this function allows for more
  optimizations and more efficient system power usage.
  
  This internally creates a main loop source using g_timeout_source_new()
  and attaches it to the global #GMainContext using g_source_attach(), so
  the callback will be invoked in whichever thread is running that main
  context. You can do these steps manually if you need greater control or to
  use a custom main context.
  
  It is safe to call this function from any thread.
  
  The interval given is in terms of monotonic time, not wall clock
  time. See g_get_monotonic_time().
  
  Parameters:
  
  interval - the time between calls to the function, in milliseconds (1/1000ths of a second)
  
  function - function to call
  
  data - data to pass to @function
  
  Returns:
  
  the ID (greater than 0) of the event source.
- timeoutAddFull
  
  public static int timeoutAddFull(int priority, int interval, Glib.OnSourceFunc function, @Nullable Pointer data, Glib.OnDestroyNotify notify)
  
  Sets a function to be called at regular intervals, with the given
  priority. The function is called repeatedly until it returns
  %FALSE, at which point the timeout is automatically destroyed and
  the function will not be called again. The @notify function is
  called when the timeout is destroyed. The first call to the
  function will be at the end of the first @interval.
  
  Note that timeout functions may be delayed, due to the processing of other
  event sources. Thus they should not be relied on for precise timing.
  After each call to the timeout function, the time of the next
  timeout is recalculated based on the current time and the given interval
  (it does not try to 'catch up' time lost in delays).
  
  See [memory management of sources][mainloop-memory-management] for details
  on how to handle the return value and memory management of @data.
  
  This internally creates a main loop source using g_timeout_source_new()
  and attaches it to the global #GMainContext using g_source_attach(), so
  the callback will be invoked in whichever thread is running that main
  context. You can do these steps manually if you need greater control or to
  use a custom main context.
  
  The interval given is in terms of monotonic time, not wall clock time.
  See g_get_monotonic_time().
  
  Parameters:
  
  priority - the priority of the timeout source. Typically this will be in the range between %G_PRIORITY_DEFAULT and %G_PRIORITY_HIGH.
  
  interval - the time between calls to the function, in milliseconds (1/1000ths of a second)
  
  function - function to call
  
  data - data to pass to @function
  
  notify - function to call when the timeout is removed, or %NULL
  
  Returns:
  
  the ID (greater than 0) of the event source.
- timeoutAddOnce
  
  public static int timeoutAddOnce(int interval, Glib.OnSourceOnceFunc function, @Nullable Pointer data)
  
  Sets a function to be called after @interval milliseconds have elapsed,
  with the default priority, %G_PRIORITY_DEFAULT.
  
  The given @function is called once and then the source will be automatically
  removed from the main context.
  
  This function otherwise behaves like g_timeout_add().
  
  Parameters:
  
  interval - the time after which the function will be called, in milliseconds (1/1000ths of a second)
  
  function - function to call
  
  data - data to pass to @function
  
  Returns:
  
  the ID (greater than 0) of the event source
- timeoutAddSeconds
  
  public static int timeoutAddSeconds(int interval, Glib.OnSourceFunc function, @Nullable Pointer data)
  
  Sets a function to be called at regular intervals with the default
  priority, %G_PRIORITY_DEFAULT.
  
  The function is called repeatedly until it returns %G_SOURCE_REMOVE
  or %FALSE, at which point the timeout is automatically destroyed
  and the function will not be called again.
  
  This internally creates a main loop source using
  g_timeout_source_new_seconds() and attaches it to the main loop context
  using g_source_attach(). You can do these steps manually if you need
  greater control. Also see g_timeout_add_seconds_full().
  
  It is safe to call this function from any thread.
  
  Note that the first call of the timer may not be precise for timeouts
  of one second. If you need finer precision and have such a timeout,
  you may want to use g_timeout_add() instead.
  
  See [memory management of sources][mainloop-memory-management] for details
  on how to handle the return value and memory management of @data.
  
  The interval given is in terms of monotonic time, not wall clock
  time. See g_get_monotonic_time().
  
  Parameters:
  
  interval - the time between calls to the function, in seconds
  
  function - function to call
  
  data - data to pass to @function
  
  Returns:
  
  the ID (greater than 0) of the event source.
- timeoutAddSecondsFull
  
  public static int timeoutAddSecondsFull(int priority, int interval, Glib.OnSourceFunc function, @Nullable Pointer data, Glib.OnDestroyNotify notify)
  
  Sets a function to be called at regular intervals, with @priority.
  
  The function is called repeatedly until it returns %G_SOURCE_REMOVE
  or %FALSE, at which point the timeout is automatically destroyed and
  the function will not be called again.
  
  Unlike g_timeout_add(), this function operates at whole second granularity.
  The initial starting point of the timer is determined by the implementation
  and the implementation is expected to group multiple timers together so that
  they fire all at the same time. To allow this grouping, the @interval to the
  first timer is rounded and can deviate up to one second from the specified
  interval. Subsequent timer iterations will generally run at the specified
  interval.
  
  Note that timeout functions may be delayed, due to the processing of other
  event sources. Thus they should not be relied on for precise timing.
  After each call to the timeout function, the time of the next
  timeout is recalculated based on the current time and the given @interval
  
  See [memory management of sources][mainloop-memory-management] for details
  on how to handle the return value and memory management of @data.
  
  If you want timing more precise than whole seconds, use g_timeout_add()
  instead.
  
  The grouping of timers to fire at the same time results in a more power
  and CPU efficient behavior so if your timer is in multiples of seconds
  and you don't require the first timer exactly one second from now, the
  use of g_timeout_add_seconds() is preferred over g_timeout_add().
  
  This internally creates a main loop source using
  g_timeout_source_new_seconds() and attaches it to the main loop context
  using g_source_attach(). You can do these steps manually if you need
  greater control.
  
  It is safe to call this function from any thread.
  
  The interval given is in terms of monotonic time, not wall clock
  time. See g_get_monotonic_time().
  
  Parameters:
  
  priority - the priority of the timeout source. Typically this will be in the range between %G_PRIORITY_DEFAULT and %G_PRIORITY_HIGH.
  
  interval - the time between calls to the function, in seconds
  
  function - function to call
  
  data - data to pass to @function
  
  notify - function to call when the timeout is removed, or %NULL
  
  Returns:
  
  the ID (greater than 0) of the event source.
- timeoutSourceNew
  
  public static Source timeoutSourceNew(int interval)
  
  Creates a new timeout source.
  
  The source will not initially be associated with any #GMainContext
  and must be added to one with g_source_attach() before it will be
  executed.
  
  The interval given is in terms of monotonic time, not wall clock
  time. See g_get_monotonic_time().
  
  Parameters:
  
  interval - the timeout interval in milliseconds.
  
  Returns:
  
  the newly-created timeout source
- timeoutSourceNewSeconds
  
  public static Source timeoutSourceNewSeconds(int interval)
  
  Creates a new timeout source.
  
  The source will not initially be associated with any #GMainContext
  and must be added to one with g_source_attach() before it will be
  executed.
  
  The scheduling granularity/accuracy of this timeout source will be
  in seconds.
  
  The interval given is in terms of monotonic time, not wall clock time.
  See g_get_monotonic_time().
  
  Parameters:
  
  interval - the timeout interval in seconds
  
  Returns:
  
  the newly-created timeout source
- tryMalloc
  
  public static Pointer tryMalloc(long n_bytes)
  
  Attempts to allocate @n_bytes, and returns %NULL on failure.
  Contrast with g_malloc(), which aborts the program on failure.
  
  Parameters:
  
  n_bytes - number of bytes to allocate.
  
  Returns:
  
  the allocated memory, or %NULL.
- tryMalloc0
  
  public static Pointer tryMalloc0(long n_bytes)
  
  Attempts to allocate @n_bytes, initialized to 0's, and returns %NULL on
  failure. Contrast with g_malloc0(), which aborts the program on failure.
  
  Parameters:
  
  n_bytes - number of bytes to allocate
  
  Returns:
  
  the allocated memory, or %NULL
- tryMalloc0N
  
  public static Pointer tryMalloc0N(long n_blocks, long n_block_bytes)
  
  This function is similar to g_try_malloc0(), allocating (@n_blocks * @n_block_bytes) bytes,
  but care is taken to detect possible overflow during multiplication.
  
  Parameters:
  
  n_blocks - the number of blocks to allocate
  
  n_block_bytes - the size of each block in bytes
  
  Returns:
  
  the allocated memory, or %NULL
- tryMallocN
  
  public static Pointer tryMallocN(long n_blocks, long n_block_bytes)
  
  This function is similar to g_try_malloc(), allocating (@n_blocks * @n_block_bytes) bytes,
  but care is taken to detect possible overflow during multiplication.
  
  Parameters:
  
  n_blocks - the number of blocks to allocate
  
  n_block_bytes - the size of each block in bytes
  
  Returns:
  
  the allocated memory, or %NULL.
- tryRealloc
  
  public static Pointer tryRealloc(@Nullable Pointer mem, long n_bytes)
  
  Attempts to realloc @mem to a new size, @n_bytes, and returns %NULL
  on failure. Contrast with g_realloc(), which aborts the program
  on failure.
  
  If @mem is %NULL, behaves the same as g_try_malloc().
  
  Parameters:
  
  mem - previously-allocated memory, or %NULL.
  
  n_bytes - number of bytes to allocate.
  
  Returns:
  
  the allocated memory, or %NULL.
- tryReallocN
  
  public static Pointer tryReallocN(@Nullable Pointer mem, long n_blocks, long n_block_bytes)
  
  This function is similar to g_try_realloc(), allocating (@n_blocks * @n_block_bytes) bytes,
  but care is taken to detect possible overflow during multiplication.
  
  Parameters:
  
  mem - previously-allocated memory, or %NULL.
  
  n_blocks - the number of blocks to allocate
  
  n_block_bytes - the size of each block in bytes
  
  Returns:
  
  the allocated memory, or %NULL.
- unicharBreakType
  
  public static int unicharBreakType(byte c)
  
  Determines the break type of @c. @c should be a Unicode character
  (to derive a character from UTF-8 encoded text, use
  g_utf8_get_char()). The break type is used to find word and line
  breaks ("text boundaries"), Pango implements the Unicode boundary
  resolution algorithms and normally you would use a function such
  as pango_break() instead of caring about break types yourself.
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  the break type of @c
- unicharCombiningClass
  
  public static int unicharCombiningClass(byte uc)
  
  Determines the canonical combining class of a Unicode character.
  
  Parameters:
  
  uc - a Unicode character
  
  Returns:
  
  the combining class of the character
- unicharDigitValue
  
  public static int unicharDigitValue(byte c)
  
  Determines the numeric value of a character as a decimal
  digit.
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  If @c is a decimal digit (according to g_unichar_isdigit()), its numeric value. Otherwise, -1.
- unicharGetScript
  
  public static int unicharGetScript(byte ch)
  
  Looks up the #GUnicodeScript for a particular character (as defined
  by Unicode Standard Annex \#24). No check is made for @ch being a
  valid Unicode character; if you pass in invalid character, the
  result is undefined.
  
  This function is equivalent to pango_script_for_unichar() and the
  two are interchangeable.
  
  Parameters:
  
  ch - a Unicode character
  
  Returns:
  
  the #GUnicodeScript for the character.
- unicharIsalnum
  
  public static boolean unicharIsalnum(byte c)
  
  Determines whether a character is alphanumeric.
  Given some UTF-8 text, obtain a character value
  with g_utf8_get_char().
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if @c is an alphanumeric character
- unicharIsalpha
  
  public static boolean unicharIsalpha(byte c)
  
  Determines whether a character is alphabetic (i.e. a letter).
  Given some UTF-8 text, obtain a character value with
  g_utf8_get_char().
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if @c is an alphabetic character
- unicharIscntrl
  
  public static boolean unicharIscntrl(byte c)
  
  Determines whether a character is a control character.
  Given some UTF-8 text, obtain a character value with
  g_utf8_get_char().
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if @c is a control character
- unicharIsdefined
  
  public static boolean unicharIsdefined(byte c)
  
  Determines if a given character is assigned in the Unicode
  standard.
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if the character has an assigned value
- unicharIsdigit
  
  public static boolean unicharIsdigit(byte c)
  
  Determines whether a character is numeric (i.e. a digit). This
  covers ASCII 0-9 and also digits in other languages/scripts. Given
  some UTF-8 text, obtain a character value with g_utf8_get_char().
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if @c is a digit
- unicharIsgraph
  
  public static boolean unicharIsgraph(byte c)
  
  Determines whether a character is printable and not a space
  (returns %FALSE for control characters, format characters, and
  spaces). g_unichar_isprint() is similar, but returns %TRUE for
  spaces. Given some UTF-8 text, obtain a character value with
  g_utf8_get_char().
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if @c is printable unless it's a space
- unicharIslower
  
  public static boolean unicharIslower(byte c)
  
  Determines whether a character is a lowercase letter.
  Given some UTF-8 text, obtain a character value with
  g_utf8_get_char().
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if @c is a lowercase letter
- unicharIsmark
  
  public static boolean unicharIsmark(byte c)
  
  Determines whether a character is a mark (non-spacing mark,
  combining mark, or enclosing mark in Unicode speak).
  Given some UTF-8 text, obtain a character value
  with g_utf8_get_char().
  
  Note: in most cases where isalpha characters are allowed,
  ismark characters should be allowed to as they are essential
  for writing most European languages as well as many non-Latin
  scripts.
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if @c is a mark character
- unicharIsprint
  
  public static boolean unicharIsprint(byte c)
  
  Determines whether a character is printable.
  Unlike g_unichar_isgraph(), returns %TRUE for spaces.
  Given some UTF-8 text, obtain a character value with
  g_utf8_get_char().
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if @c is printable
- unicharIspunct
  
  public static boolean unicharIspunct(byte c)
  
  Determines whether a character is punctuation or a symbol.
  Given some UTF-8 text, obtain a character value with
  g_utf8_get_char().
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if @c is a punctuation or symbol character
- unicharIsspace
  
  public static boolean unicharIsspace(byte c)
  
  Determines whether a character is a space, tab, or line separator
  (newline, carriage return, etc.). Given some UTF-8 text, obtain a
  character value with g_utf8_get_char().
  
  (Note: don't use this to do word breaking; you have to use
  Pango or equivalent to get word breaking right, the algorithm
  is fairly complex.)
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if @c is a space character
- unicharIstitle
  
  public static boolean unicharIstitle(byte c)
  
  Determines if a character is titlecase. Some characters in
  Unicode which are composites, such as the DZ digraph
  have three case variants instead of just two. The titlecase
  form is used at the beginning of a word where only the
  first letter is capitalized. The titlecase form of the DZ
  digraph is U+01F2 LATIN CAPITAL LETTTER D WITH SMALL LETTER Z.
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if the character is titlecase
- unicharIsupper
  
  public static boolean unicharIsupper(byte c)
  
  Determines if a character is uppercase.
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if @c is an uppercase character
- unicharIswide
  
  public static boolean unicharIswide(byte c)
  
  Determines if a character is typically rendered in a double-width
  cell.
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if the character is wide
- unicharIswideCjk
  
  public static boolean unicharIswideCjk(byte c)
  
  Determines if a character is typically rendered in a double-width
  cell under legacy East Asian locales. If a character is wide according to
  g_unichar_iswide(), then it is also reported wide with this function, but
  the converse is not necessarily true. See the
  [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
  for details.
  
  If a character passes the g_unichar_iswide() test then it will also pass
  this test, but not the other way around. Note that some characters may
  pass both this test and g_unichar_iszerowidth().
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if the character is wide in legacy East Asian locales
- unicharIsxdigit
  
  public static boolean unicharIsxdigit(byte c)
  
  Determines if a character is a hexadecimal digit.
  
  Parameters:
  
  c - a Unicode character.
  
  Returns:
  
  %TRUE if the character is a hexadecimal digit
- unicharIszerowidth
  
  public static boolean unicharIszerowidth(byte c)
  
  Determines if a given character typically takes zero width when rendered.
  The return value is %TRUE for all non-spacing and enclosing marks
  (e.g., combining accents), format characters, zero-width
  space, but not U+00AD SOFT HYPHEN.
  
  A typical use of this function is with one of g_unichar_iswide() or
  g_unichar_iswide_cjk() to determine the number of cells a string occupies
  when displayed on a grid display (terminals). However, note that not all
  terminals support zero-width rendering of zero-width marks.
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  %TRUE if the character has zero width
- unicharToUtf8
  
  public static int unicharToUtf8(byte c, @Nullable Str outbuf)
  
  Converts a single character to UTF-8.
  
  Parameters:
  
  c - a Unicode character code
  
  outbuf - output buffer, must have at least 6 bytes of space. If %NULL, the length will be computed and returned and nothing will be written to @outbuf.
  
  Returns:
  
  number of bytes written
- unicharTolower
  
  public static byte unicharTolower(byte c)
  
  Converts a character to lower case.
  
  Parameters:
  
  c - a Unicode character.
  
  Returns:
  
  the result of converting @c to lower case. If @c is not an upperlower or titlecase character, or has no lowercase equivalent @c is returned unchanged.
- unicharTotitle
  
  public static byte unicharTotitle(byte c)
  
  Converts a character to the titlecase.
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  the result of converting @c to titlecase. If @c is not an uppercase or lowercase character, @c is returned unchanged.
- unicharToupper
  
  public static byte unicharToupper(byte c)
  
  Converts a character to uppercase.
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  the result of converting @c to uppercase. If @c is not a lowercase or titlecase character, or has no upper case equivalent @c is returned unchanged.
- unicharType
  
  public static int unicharType(byte c)
  
  Classifies a Unicode character by type.
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  the type of the character.
- unicharValidate
  
  public static boolean unicharValidate(byte ch)
  
  Checks whether @ch is a valid Unicode character. Some possible
  integer values of @ch will not be valid. 0 is considered a valid
  character, though it's normally a string terminator.
  
  Parameters:
  
  ch - a Unicode character
  
  Returns:
  
  %TRUE if @ch is a valid Unicode character
- unicharXdigitValue
  
  public static int unicharXdigitValue(byte c)
  
  Determines the numeric value of a character as a hexadecimal
  digit.
  
  Parameters:
  
  c - a Unicode character
  
  Returns:
  
  If @c is a hex digit (according to g_unichar_isxdigit()), its numeric value. Otherwise, -1.
- unicodeScriptFromIso15924
  
  public static int unicodeScriptFromIso15924(int iso15924)
  
  Looks up the Unicode script for @iso15924. ISO 15924 assigns four-letter
  codes to scripts. For example, the code for Arabic is 'Arab'.
  This function accepts four letter codes encoded as a @guint32 in a
  big-endian fashion. That is, the code expected for Arabic is
  0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc).
  
  See
  [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html)
  for details.
  
  Parameters:
  
  iso15924 - a Unicode script
  
  Returns:
  
  the Unicode script for @iso15924, or of %G_UNICODE_SCRIPT_INVALID_CODE if @iso15924 is zero and %G_UNICODE_SCRIPT_UNKNOWN if @iso15924 is unknown.
- unicodeScriptToIso15924
  
  public static int unicodeScriptToIso15924(int script)
  
  Looks up the ISO 15924 code for @script. ISO 15924 assigns four-letter
  codes to scripts. For example, the code for Arabic is 'Arab'. The
  four letter codes are encoded as a @guint32 by this function in a
  big-endian fashion. That is, the code returned for Arabic is
  0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc).
  
  See
  [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html)
  for details.
  
  Parameters:
  
  script - a Unicode script
  
  Returns:
  
  the ISO 15924 code for @script, encoded as an integer, of zero if @script is %G_UNICODE_SCRIPT_INVALID_CODE or ISO 15924 code 'Zzzz' (script code for UNKNOWN) if @script is not understood.
- unixErrorQuark
  
  public static int unixErrorQuark()
  
  Returns:
- unixFdAdd
  
  public static int unixFdAdd(int fd, int condition, Glib.OnUnixFDSourceFunc function, @Nullable Pointer user_data)
  
  Sets a function to be called when the IO condition, as specified by
  @condition becomes true for @fd.
  
  @function will be called when the specified IO condition becomes
  %TRUE. The function is expected to clear whatever event caused the
  IO condition to become true and return %TRUE in order to be notified
  when it happens again. If @function returns %FALSE then the watch
  will be cancelled.
  
  The return value of this function can be passed to g_source_remove()
  to cancel the watch at any time that it exists.
  
  The source will never close the fd -- you must do it yourself.
  
  Parameters:
  
  fd - a file descriptor
  
  condition - IO conditions to watch for on @fd
  
  function - a #GUnixFDSourceFunc
  
  user_data - data to pass to @function
  
  Returns:
  
  the ID (greater than 0) of the event source
- unixFdAddFull
  
  public static int unixFdAddFull(int priority, int fd, int condition, Glib.OnUnixFDSourceFunc function, @Nullable Pointer user_data, Glib.OnDestroyNotify notify)
  
  Sets a function to be called when the IO condition, as specified by
  @condition becomes true for @fd.
  
  This is the same as g_unix_fd_add(), except that it allows you to
  specify a non-default priority and a provide a #GDestroyNotify for
  @user_data.
  
  Parameters:
  
  priority - the priority of the source
  
  fd - a file descriptor
  
  condition - IO conditions to watch for on @fd
  
  function - a #GUnixFDSourceFunc
  
  user_data - data to pass to @function
  
  notify - function to call when the idle is removed, or %NULL
  
  Returns:
  
  the ID (greater than 0) of the event source
- unixFdSourceNew
  
  public static Source unixFdSourceNew(int fd, int condition)
  
  Creates a #GSource to watch for a particular IO condition on a file
  descriptor.
  
  The source will never close the fd -- you must do it yourself.
  
  Parameters:
  
  fd - a file descriptor
  
  condition - IO conditions to watch for on @fd
  
  Returns:
  
  the newly created #GSource
- unixOpenPipe
  
  public static boolean unixOpenPipe(@Nonnull Int fds, int flags) throws AllocationError
  
  Similar to the UNIX pipe() call, but on modern systems like Linux
  uses the pipe2() system call, which atomically creates a pipe with
  the configured flags. The only supported flag currently is
  %FD_CLOEXEC. If for example you want to configure %O_NONBLOCK, that
  must still be done separately with fcntl().
  
  This function does not take %O_CLOEXEC, it takes %FD_CLOEXEC as if
  for fcntl(); these are different on Linux/glibc.
  
  Parameters:
  
  fds - Array of two integers
  
  flags - Bitfield of file descriptor flags, as for fcntl()
  
  Returns:
  
  %TRUE on success, %FALSE if not (and errno will be set).
  
  Throws:
  
  AllocationError
- unixSetFdNonblocking
  
  public static boolean unixSetFdNonblocking(int fd, boolean nonblock) throws AllocationError
  
  Control the non-blocking state of the given file descriptor,
  according to @nonblock. On most systems this uses %O_NONBLOCK, but
  on some older ones may use %O_NDELAY.
  
  Parameters:
  
  fd - A file descriptor
  
  nonblock - If %TRUE, set the descriptor to be non-blocking
  
  Returns:
  
  %TRUE if successful
  
  Throws:
  
  AllocationError
- unixSignalAdd
  
  public static int unixSignalAdd(int signum, Glib.OnSourceFunc handler, @Nullable Pointer user_data)
  
  A convenience function for g_unix_signal_source_new(), which
  attaches to the default #GMainContext. You can remove the watch
  using g_source_remove().
  
  Parameters:
  
  signum - Signal number
  
  handler - Callback
  
  user_data - Data for @handler
  
  Returns:
  
  An ID (greater than 0) for the event source
- unixSignalAddFull
  
  public static int unixSignalAddFull(int priority, int signum, Glib.OnSourceFunc handler, @Nullable Pointer user_data, Glib.OnDestroyNotify notify)
  
  A convenience function for g_unix_signal_source_new(), which
  attaches to the default #GMainContext. You can remove the watch
  using g_source_remove().
  
  Parameters:
  
  priority - the priority of the signal source. Typically this will be in the range between %G_PRIORITY_DEFAULT and %G_PRIORITY_HIGH.
  
  signum - Signal number
  
  handler - Callback
  
  user_data - Data for @handler
  
  notify - #GDestroyNotify for @handler
  
  Returns:
  
  An ID (greater than 0) for the event source
- unixSignalSourceNew
  
  public static Source unixSignalSourceNew(int signum)
  
  Create a #GSource that will be dispatched upon delivery of the UNIX
  signal @signum. In GLib versions before 2.36, only `SIGHUP`, `SIGINT`,
  `SIGTERM` can be monitored. In GLib 2.36, `SIGUSR1` and `SIGUSR2`
  were added. In GLib 2.54, `SIGWINCH` was added.
  
  Note that unlike the UNIX default, all sources which have created a
  watch will be dispatched, regardless of which underlying thread
  invoked g_unix_signal_source_new().
  
  For example, an effective use of this function is to handle `SIGTERM`
  cleanly; flushing any outstanding files, and then calling
  g_main_loop_quit(). It is not safe to do any of this from a regular
  UNIX signal handler; such a handler may be invoked while malloc() or
  another library function is running, causing reentrancy issues if the
  handler attempts to use those functions. None of the GLib/GObject
  API is safe against this kind of reentrancy.
  
  The interaction of this source when combined with native UNIX
  functions like sigprocmask() is not defined.
  
  The source will not initially be associated with any #GMainContext
  and must be added to one with g_source_attach() before it will be
  executed.
  
  Parameters:
  
  signum - A signal number
  
  Returns:
  
  A newly created #GSource
- unlink
  
  public static int unlink(@Nonnull Str filename)
  
  A wrapper for the POSIX unlink() function. The unlink() function
  deletes a name from the filesystem. If this was the last link to the
  file and no processes have it opened, the diskspace occupied by the
  file is freed.
  
  See your C library manual for more details about unlink(). Note
  that on Windows, it is in general not possible to delete files that
  are open to some process, or mapped into memory.
  
  Parameters:
  
  filename - a pathname in the GLib file name encoding (UTF-8 on Windows)
  
  Returns:
  
  0 if the name was successfully deleted, -1 if an error occurred
- unsetenv
  
  public static void unsetenv(@Nonnull Str variable)
  
  Removes an environment variable from the environment.
  
  Note that on some systems, when variables are overwritten, the
  memory used for the previous variables and its value isn't reclaimed.
  
  You should be mindful of the fact that environment variable handling
  in UNIX is not thread-safe, and your program may crash if one thread
  calls g_unsetenv() while another thread is calling getenv(). (And note
  that many functions, such as gettext(), call getenv() internally.) This
  function is only safe to use at the very start of your program, before
  creating any other threads (or creating objects that create worker
  threads of their own).
  
  If you need to set up the environment for a child process, you can
  use g_get_environ() to get an environment array, modify that with
  g_environ_setenv() and g_environ_unsetenv(), and then pass that
  array directly to execvpe(), g_spawn_async(), or the like.
  
  Parameters:
  
  variable - the environment variable to remove, must not contain '='
- uriBuild
  
  public static Uri uriBuild(int flags, @Nonnull Str scheme, @Nullable Str userinfo, @Nullable Str host, int port, @Nonnull Str path, @Nullable Str query, @Nullable Str fragment)
  
  Creates a new #GUri from the given components according to @flags.
  
  See also g_uri_build_with_user(), which allows specifying the
  components of the "userinfo" separately.
  
  Parameters:
  
  flags - flags describing how to build the #GUri
  
  scheme - the URI scheme
  
  userinfo - the userinfo component, or %NULL
  
  host - the host component, or %NULL
  
  port - the port, or `-1`
  
  path - the path component
  
  query - the query component, or %NULL
  
  fragment - the fragment, or %NULL
  
  Returns:
  
  a new #GUri
- uriBuildWithUser
  
  public static Uri uriBuildWithUser(int flags, @Nonnull Str scheme, @Nullable Str user, @Nullable Str password, @Nullable Str auth_params, @Nullable Str host, int port, @Nonnull Str path, @Nullable Str query, @Nullable Str fragment)
  
  Creates a new #GUri from the given components according to @flags
  (%G_URI_FLAGS_HAS_PASSWORD is added unconditionally). The @flags must be
  coherent with the passed values, in particular use `%`-encoded values with
  %G_URI_FLAGS_ENCODED.
  
  In contrast to g_uri_build(), this allows specifying the components
  of the ‘userinfo’ field separately. Note that @user must be non-%NULL
  if either @password or @auth_params is non-%NULL.
  
  Parameters:
  
  flags - flags describing how to build the #GUri
  
  scheme - the URI scheme
  
  user - the user component of the userinfo, or %NULL
  
  password - the password component of the userinfo, or %NULL
  
  auth_params - the auth params of the userinfo, or %NULL
  
  host - the host component, or %NULL
  
  port - the port, or `-1`
  
  path - the path component
  
  query - the query component, or %NULL
  
  fragment - the fragment, or %NULL
  
  Returns:
  
  a new #GUri
- uriErrorQuark
  
  public static int uriErrorQuark()
  
  Returns:
- uriEscapeString
  
  public static Str uriEscapeString(@Nonnull Str unescaped, @Nullable Str reserved_chars_allowed, boolean allow_utf8)
  
  Escapes a string for use in a URI.
  
  Normally all characters that are not "unreserved" (i.e. ASCII
  alphanumerical characters plus dash, dot, underscore and tilde) are
  escaped. But if you specify characters in @reserved_chars_allowed
  they are not escaped. This is useful for the "reserved" characters
  in the URI specification, since those are allowed unescaped in some
  portions of a URI.
  
  Parameters:
  
  unescaped - the unescaped input string.
  
  reserved_chars_allowed - a string of reserved characters that are allowed to be used, or %NULL.
  
  allow_utf8 - %TRUE if the result can include UTF-8 characters.
  
  Returns:
  
  an escaped version of @unescaped. The returned string should be freed when no longer needed.
- uriIsValid
  
  public static boolean uriIsValid(@Nonnull Str uri_string, int flags) throws AllocationError
  
  Parses @uri_string according to @flags, to determine whether it is a valid
  [absolute URI][relative-absolute-uris], i.e. it does not need to be resolved
  relative to another URI using g_uri_parse_relative().
  
  If it’s not a valid URI, an error is returned explaining how it’s invalid.
  
  See g_uri_split(), and the definition of #GUriFlags, for more
  information on the effect of @flags.
  
  Parameters:
  
  uri_string - a string containing an absolute URI
  
  flags - flags for parsing @uri_string
  
  Returns:
  
  %TRUE if @uri_string is a valid absolute URI, %FALSE on error.
  
  Throws:
  
  AllocationError
- uriJoin
  
  public static Str uriJoin(int flags, @Nullable Str scheme, @Nullable Str userinfo, @Nullable Str host, int port, @Nonnull Str path, @Nullable Str query, @Nullable Str fragment)
  
  Joins the given components together according to @flags to create
  an absolute URI string. @path may not be %NULL (though it may be the empty
  string).
  
  When @host is present, @path must either be empty or begin with a slash (`/`)
  character. When @host is not present, @path cannot begin with two slash
  characters (`//`). See
  [RFC 3986, section 3](https://tools.ietf.org/html/rfc3986#section-3).
  
  See also g_uri_join_with_user(), which allows specifying the
  components of the ‘userinfo’ separately.
  
  %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set
  in @flags.
  
  Parameters:
  
  flags - flags describing how to build the URI string
  
  scheme - the URI scheme, or %NULL
  
  userinfo - the userinfo component, or %NULL
  
  host - the host component, or %NULL
  
  port - the port, or `-1`
  
  path - the path component
  
  query - the query component, or %NULL
  
  fragment - the fragment, or %NULL
  
  Returns:
  
  an absolute URI string
- uriJoinWithUser
  
  public static Str uriJoinWithUser(int flags, @Nullable Str scheme, @Nullable Str user, @Nullable Str password, @Nullable Str auth_params, @Nullable Str host, int port, @Nonnull Str path, @Nullable Str query, @Nullable Str fragment)
  
  Joins the given components together according to @flags to create
  an absolute URI string. @path may not be %NULL (though it may be the empty
  string).
  
  In contrast to g_uri_join(), this allows specifying the components
  of the ‘userinfo’ separately. It otherwise behaves the same.
  
  %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set
  in @flags.
  
  Parameters:
  
  flags - flags describing how to build the URI string
  
  scheme - the URI scheme, or %NULL
  
  user - the user component of the userinfo, or %NULL
  
  password - the password component of the userinfo, or %NULL
  
  auth_params - the auth params of the userinfo, or %NULL
  
  host - the host component, or %NULL
  
  port - the port, or `-1`
  
  path - the path component
  
  query - the query component, or %NULL
  
  fragment - the fragment, or %NULL
  
  Returns:
  
  an absolute URI string
- uriParse
  
  public static Uri uriParse(@Nonnull Str uri_string, int flags) throws AllocationError
  
  Parses @uri_string according to @flags. If the result is not a
  valid [absolute URI][relative-absolute-uris], it will be discarded, and an
  error returned.
  
  Parameters:
  
  uri_string - a string representing an absolute URI
  
  flags - flags describing how to parse @uri_string
  
  Returns:
  
  a new #GUri, or NULL on error.
  
  Throws:
  
  AllocationError
- uriParseParams
  
  public static HashTable uriParseParams(@Nonnull Str params, long length, @Nonnull Str separators, int flags) throws AllocationError
  
  Many URI schemes include one or more attribute/value pairs as part of the URI
  value. This method can be used to parse them into a hash table. When an
  attribute has multiple occurrences, the last value is the final returned
  value. If you need to handle repeated attributes differently, use
  #GUriParamsIter.
  
  The @params string is assumed to still be `%`-encoded, but the returned
  values will be fully decoded. (Thus it is possible that the returned values
  may contain `=` or @separators, if the value was encoded in the input.)
  Invalid `%`-encoding is treated as with the %G_URI_FLAGS_PARSE_RELAXED
  rules for g_uri_parse(). (However, if @params is the path or query string
  from a #GUri that was parsed without %G_URI_FLAGS_PARSE_RELAXED and
  %G_URI_FLAGS_ENCODED, then you already know that it does not contain any
  invalid encoding.)
  
  %G_URI_PARAMS_WWW_FORM is handled as documented for g_uri_params_iter_init().
  
  If %G_URI_PARAMS_CASE_INSENSITIVE is passed to @flags, attributes will be
  compared case-insensitively, so a params string `attr=123&Attr=456` will only
  return a single attribute–value pair, `Attr=456`. Case will be preserved in
  the returned attributes.
  
  If @params cannot be parsed (for example, it contains two @separators
  characters in a row), then @error is set and %NULL is returned.
  
  Parameters:
  
  params - a `%`-encoded string containing `attribute=value` parameters
  
  length - the length of @params, or `-1` if it is nul-terminated
  
  separators - the separator byte character set between parameters. (usually `&`, but sometimes `;` or both `&;`). Note that this function works on bytes not characters, so it can't be used to delimit UTF-8 strings for anything but ASCII characters. You may pass an empty set, in which case no splitting will occur.
  
  flags - flags to modify the way the parameters are handled.
  
  Returns:
  
  A hash table of attribute/value pairs, with both names and values fully-decoded; or %NULL on error.
  
  Throws:
  
  AllocationError
- uriParseScheme
  
  public static Str uriParseScheme(@Nonnull Str uri)
  Gets the scheme portion of a URI string.
  [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) decodes the scheme
  as:
  URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
  
  Common schemes include `file`, `https`, `svn+ssh`, etc.
  Parameters:
  
  uri - a valid URI.
  
  Returns:
  
  The ‘scheme’ component of the URI, or %NULL on error. The returned string should be freed when no longer needed.
- uriPeekScheme
  
  public static Str uriPeekScheme(@Nonnull Str uri)
  Gets the scheme portion of a URI string.
  [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) decodes the scheme
  as:
  URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
  
  Common schemes include `file`, `https`, `svn+ssh`, etc.
  
  Unlike g_uri_parse_scheme(), the returned scheme is normalized to
  all-lowercase and does not need to be freed.
  Parameters:
  
  uri - a valid URI.
  
  Returns:
  
  The ‘scheme’ component of the URI, or %NULL on error. The returned string is normalized to all-lowercase, and interned via g_intern_string(), so it does not need to be freed.
- uriResolveRelative
  
  public static Str uriResolveRelative(@Nullable Str base_uri_string, @Nonnull Str uri_ref, int flags) throws AllocationError
  
  Parses @uri_ref according to @flags and, if it is a
  [relative URI][relative-absolute-uris], resolves it relative to
  @base_uri_string. If the result is not a valid absolute URI, it will be
  discarded, and an error returned.
  
  (If @base_uri_string is %NULL, this just returns @uri_ref, or
  %NULL if @uri_ref is invalid or not absolute.)
  
  Parameters:
  
  base_uri_string - a string representing a base URI
  
  uri_ref - a string representing a relative or absolute URI
  
  flags - flags describing how to parse @uri_ref
  
  Returns:
  
  the resolved URI string, or NULL on error.
  
  Throws:
  
  AllocationError
- uriUnescapeBytes
  
  public static Bytes uriUnescapeBytes(@Nonnull Str escaped_string, long length, @Nullable Str illegal_characters) throws AllocationError
  
  Unescapes a segment of an escaped string as binary data.
  
  Note that in contrast to g_uri_unescape_string(), this does allow
  nul bytes to appear in the output.
  
  If any of the characters in @illegal_characters appears as an escaped
  character in @escaped_string, then that is an error and %NULL will be
  returned. This is useful if you want to avoid for instance having a slash
  being expanded in an escaped path element, which might confuse pathname
  handling.
  
  Parameters:
  
  escaped_string - A URI-escaped string
  
  length - the length (in bytes) of @escaped_string to escape, or `-1` if it is nul-terminated.
  
  illegal_characters - a string of illegal characters not to be allowed, or %NULL.
  
  Returns:
  
  an unescaped version of @escaped_string or %NULL on error (if decoding failed, using %G_URI_ERROR_FAILED error code). The returned #GBytes should be unreffed when no longer needed.
  
  Throws:
  
  AllocationError
- uriUnescapeSegment
  
  public static Str uriUnescapeSegment(@Nullable Str escaped_string, @Nullable Str escaped_string_end, @Nullable Str illegal_characters)
  
  Unescapes a segment of an escaped string.
  
  If any of the characters in @illegal_characters or the NUL
  character appears as an escaped character in @escaped_string, then
  that is an error and %NULL will be returned. This is useful if you
  want to avoid for instance having a slash being expanded in an
  escaped path element, which might confuse pathname handling.
  
  Note: `NUL` byte is not accepted in the output, in contrast to
  g_uri_unescape_bytes().
  
  Parameters:
  
  escaped_string - A string, may be %NULL
  
  escaped_string_end - Pointer to end of @escaped_string, may be %NULL
  
  illegal_characters - An optional string of illegal characters not to be allowed, may be %NULL
  
  Returns:
  
  an unescaped version of @escaped_string, or %NULL on error. The returned string should be freed when no longer needed. As a special case if %NULL is given for @escaped_string, this function will return %NULL.
- uriUnescapeString
  
  public static Str uriUnescapeString(@Nonnull Str escaped_string, @Nullable Str illegal_characters)
  
  Unescapes a whole escaped string.
  
  If any of the characters in @illegal_characters or the NUL
  character appears as an escaped character in @escaped_string, then
  that is an error and %NULL will be returned. This is useful if you
  want to avoid for instance having a slash being expanded in an
  escaped path element, which might confuse pathname handling.
  
  Parameters:
  
  escaped_string - an escaped string to be unescaped.
  
  illegal_characters - a string of illegal characters not to be allowed, or %NULL.
  
  Returns:
  
  an unescaped version of @escaped_string. The returned string should be freed when no longer needed.
- usleep
  
  public static void usleep(long microseconds)
  
  Pauses the current thread for the given number of microseconds.
  
  There are 1 million microseconds per second (represented by the
  %G_USEC_PER_SEC macro). g_usleep() may have limited precision,
  depending on hardware and operating system; don't rely on the exact
  length of the sleep.
  
  Parameters:
  
  microseconds - number of microseconds to pause
- utf8Casefold
  
  public static Str utf8Casefold(@Nonnull Str str, long len)
  
  Converts a string into a form that is independent of case. The
  result will not correspond to any particular case, but can be
  compared for equality or ordered with the results of calling
  g_utf8_casefold() on other strings.
  
  Note that calling g_utf8_casefold() followed by g_utf8_collate() is
  only an approximation to the correct linguistic case insensitive
  ordering, though it is a fairly good one. Getting this exactly
  right would require a more sophisticated collation function that
  takes case sensitivity into account. GLib does not currently
  provide such a function.
  
  Parameters:
  
  str - a UTF-8 encoded string
  
  len - length of @str, in bytes, or -1 if @str is nul-terminated.
  
  Returns:
  
  a newly allocated string, that is a case independent form of @str.
- utf8Collate
  
  public static int utf8Collate(@Nonnull Str str1, @Nonnull Str str2)
  
  Compares two strings for ordering using the linguistically
  correct rules for the [current locale][setlocale].
  When sorting a large number of strings, it will be significantly
  faster to obtain collation keys with g_utf8_collate_key() and
  compare the keys with strcmp() when sorting instead of sorting
  the original strings.
  
  If the two strings are not comparable due to being in different collation
  sequences, the result is undefined. This can happen if the strings are in
  different language scripts, for example.
  
  Parameters:
  
  str1 - a UTF-8 encoded string
  
  str2 - a UTF-8 encoded string
  
  Returns:
  
  < 0 if @str1 compares before @str2, 0 if they compare equal, > 0 if @str1 compares after @str2.
- utf8CollateKey
  
  public static Str utf8CollateKey(@Nonnull Str str, long len)
  
  Converts a string into a collation key that can be compared
  with other collation keys produced by the same function using
  strcmp().
  
  The results of comparing the collation keys of two strings
  with strcmp() will always be the same as comparing the two
  original keys with g_utf8_collate().
  
  Note that this function depends on the [current locale][setlocale].
  
  Parameters:
  
  str - a UTF-8 encoded string.
  
  len - length of @str, in bytes, or -1 if @str is nul-terminated.
  
  Returns:
  
  a newly allocated string. This string should be freed with g_free() when you are done with it.
- utf8CollateKeyForFilename
  
  public static Str utf8CollateKeyForFilename(@Nonnull Str str, long len)
  
  Converts a string into a collation key that can be compared
  with other collation keys produced by the same function using strcmp().
  
  In order to sort filenames correctly, this function treats the dot '.'
  as a special case. Most dictionary orderings seem to consider it
  insignificant, thus producing the ordering "event.c" "eventgenerator.c"
  "event.h" instead of "event.c" "event.h" "eventgenerator.c". Also, we
  would like to treat numbers intelligently so that "file1" "file10" "file5"
  is sorted as "file1" "file5" "file10".
  
  Note that this function depends on the [current locale][setlocale].
  
  Parameters:
  
  str - a UTF-8 encoded string.
  
  len - length of @str, in bytes, or -1 if @str is nul-terminated.
  
  Returns:
  
  a newly allocated string. This string should be freed with g_free() when you are done with it.
- utf8FindNextChar
  
  public static Str utf8FindNextChar(@Nonnull Str p, @Nullable Str end)
  
  Finds the start of the next UTF-8 character in the string after @p.
  
  @p does not have to be at the beginning of a UTF-8 character. No check
  is made to see if the character found is actually valid other than
  it starts with an appropriate byte.
  
  If @end is %NULL, the return value will never be %NULL: if the end of the
  string is reached, a pointer to the terminating nul byte is returned. If
  @end is non-%NULL, the return value will be %NULL if the end of the string
  is reached.
  
  Parameters:
  
  p - a pointer to a position within a UTF-8 encoded string
  
  end - a pointer to the byte following the end of the string, or %NULL to indicate that the string is nul-terminated
  
  Returns:
  
  a pointer to the found character or %NULL if @end is set and is reached
- utf8FindPrevChar
  
  public static Str utf8FindPrevChar(@Nonnull Str str, @Nonnull Str p)
  
  Given a position @p with a UTF-8 encoded string @str, find the start
  of the previous UTF-8 character starting before @p. Returns %NULL if no
  UTF-8 characters are present in @str before @p.
  
  @p does not have to be at the beginning of a UTF-8 character. No check
  is made to see if the character found is actually valid other than
  it starts with an appropriate byte.
  
  Parameters:
  
  str - pointer to the beginning of a UTF-8 encoded string
  
  p - pointer to some position within @str
  
  Returns:
  
  a pointer to the found character or %NULL.
- utf8GetChar
  
  public static byte utf8GetChar(@Nonnull Str p)
  
  Converts a sequence of bytes encoded as UTF-8 to a Unicode character.
  
  If @p does not point to a valid UTF-8 encoded character, results
  are undefined. If you are not sure that the bytes are complete
  valid Unicode characters, you should use g_utf8_get_char_validated()
  instead.
  
  Parameters:
  
  p - a pointer to Unicode character encoded as UTF-8
  
  Returns:
  
  the resulting character
- utf8GetCharValidated
  
  public static byte utf8GetCharValidated(@Nonnull Str p, long max_len)
  
  Convert a sequence of bytes encoded as UTF-8 to a Unicode character.
  This function checks for incomplete characters, for invalid characters
  such as characters that are out of the range of Unicode, and for
  overlong encodings of valid characters.
  
  Note that g_utf8_get_char_validated() returns (gunichar)-2 if
  @max_len is positive and any of the bytes in the first UTF-8 character
  sequence are nul.
  
  Parameters:
  
  p - a pointer to Unicode character encoded as UTF-8
  
  max_len - the maximum number of bytes to read, or -1 if @p is nul-terminated
  
  Returns:
  
  the resulting character. If @p points to a partial sequence at the end of a string that could begin a valid character (or if @max_len is zero), returns (gunichar)-2; otherwise, if @p does not point to a valid UTF-8 encoded Unicode character, returns (gunichar)-1.
- utf8MakeValid
  
  public static Str utf8MakeValid(@Nonnull Str str, long len)
  
  If the provided string is valid UTF-8, return a copy of it. If not,
  return a copy in which bytes that could not be interpreted as valid Unicode
  are replaced with the Unicode replacement character (U+FFFD).
  
  For example, this is an appropriate function to use if you have received
  a string that was incorrectly declared to be UTF-8, and you need a valid
  UTF-8 version of it that can be logged or displayed to the user, with the
  assumption that it is close enough to ASCII or UTF-8 to be mostly
  readable as-is.
  
  Parameters:
  
  str - string to coerce into UTF-8
  
  len - the maximum length of @str to use, in bytes. If @len < 0, then the string is nul-terminated.
  
  Returns:
  
  a valid UTF-8 string whose content resembles @str
- utf8Normalize
  
  public static Str utf8Normalize(@Nonnull Str str, long len, int mode)
  
  Converts a string into canonical form, standardizing
  such issues as whether a character with an accent
  is represented as a base character and combining
  accent or as a single precomposed character. The
  string has to be valid UTF-8, otherwise %NULL is
  returned. You should generally call g_utf8_normalize()
  before comparing two Unicode strings.
  
  The normalization mode %G_NORMALIZE_DEFAULT only
  standardizes differences that do not affect the
  text content, such as the above-mentioned accent
  representation. %G_NORMALIZE_ALL also standardizes
  the "compatibility" characters in Unicode, such
  as SUPERSCRIPT THREE to the standard forms
  (in this case DIGIT THREE). Formatting information
  may be lost but for most text operations such
  characters should be considered the same.
  
  %G_NORMALIZE_DEFAULT_COMPOSE and %G_NORMALIZE_ALL_COMPOSE
  are like %G_NORMALIZE_DEFAULT and %G_NORMALIZE_ALL,
  but returned a result with composed forms rather
  than a maximally decomposed form. This is often
  useful if you intend to convert the string to
  a legacy encoding or pass it to a system with
  less capable Unicode handling.
  
  Parameters:
  
  str - a UTF-8 encoded string.
  
  len - length of @str, in bytes, or -1 if @str is nul-terminated.
  
  mode - the type of normalization to perform.
  
  Returns:
  
  a newly allocated string, that is the normalized form of @str, or %NULL if @str is not valid UTF-8.
- utf8OffsetToPointer
  
  public static Str utf8OffsetToPointer(@Nonnull Str str, long offset)
  
  Converts from an integer character offset to a pointer to a position
  within the string.
  
  Since 2.10, this function allows to pass a negative @offset to
  step backwards. It is usually worth stepping backwards from the end
  instead of forwards if @offset is in the last fourth of the string,
  since moving forward is about 3 times faster than moving backward.
  
  Note that this function doesn't abort when reaching the end of @str.
  Therefore you should be sure that @offset is within string boundaries
  before calling that function. Call g_utf8_strlen() when unsure.
  This limitation exists as this function is called frequently during
  text rendering and therefore has to be as fast as possible.
  
  Parameters:
  
  str - a UTF-8 encoded string
  
  offset - a character offset within @str
  
  Returns:
  
  the resulting pointer
- utf8PointerToOffset
  
  public static long utf8PointerToOffset(@Nonnull Str str, @Nonnull Str pos)
  
  Converts from a pointer to position within a string to an integer
  character offset.
  
  Since 2.10, this function allows @pos to be before @str, and returns
  a negative offset in this case.
  
  Parameters:
  
  str - a UTF-8 encoded string
  
  pos - a pointer to a position within @str
  
  Returns:
  
  the resulting character offset
- utf8PrevChar
  
  public static Str utf8PrevChar(@Nonnull Str p)
  
  Finds the previous UTF-8 character in the string before @p.
  
  @p does not have to be at the beginning of a UTF-8 character. No check
  is made to see if the character found is actually valid other than
  it starts with an appropriate byte. If @p might be the first
  character of the string, you must use g_utf8_find_prev_char() instead.
  
  Parameters:
  
  p - a pointer to a position within a UTF-8 encoded string
  
  Returns:
  
  a pointer to the found character
- utf8Strchr
  
  public static Str utf8Strchr(@Nonnull Str p, long len, byte c)
  
  Finds the leftmost occurrence of the given Unicode character
  in a UTF-8 encoded string, while limiting the search to @len bytes.
  If @len is -1, allow unbounded search.
  
  Parameters:
  
  p - a nul-terminated UTF-8 encoded string
  
  len - the maximum length of @p
  
  c - a Unicode character
  
  Returns:
  
  %NULL if the string does not contain the character, otherwise, a pointer to the start of the leftmost occurrence of the character in the string.
- utf8Strdown
  
  public static Str utf8Strdown(@Nonnull Str str, long len)
  
  Converts all Unicode characters in the string that have a case
  to lowercase. The exact manner that this is done depends
  on the current locale, and may result in the number of
  characters in the string changing.
  
  Parameters:
  
  str - a UTF-8 encoded string
  
  len - length of @str, in bytes, or -1 if @str is nul-terminated.
  
  Returns:
  
  a newly allocated string, with all characters converted to lowercase.
- utf8Strlen
  
  public static long utf8Strlen(@Nonnull Str p, long max)
  
  Computes the length of the string in characters, not including
  the terminating nul character. If the @max'th byte falls in the
  middle of a character, the last (partial) character is not counted.
  
  Parameters:
  
  p - pointer to the start of a UTF-8 encoded string
  
  max - the maximum number of bytes to examine. If @max is less than 0, then the string is assumed to be nul-terminated. If @max is 0, @p will not be examined and may be %NULL. If @max is greater than 0, up to @max bytes are examined
  
  Returns:
  
  the length of the string in characters
- utf8Strncpy
  
  public static Str utf8Strncpy(@Nonnull Str dest, @Nonnull Str src, long n)
  
  Like the standard C strncpy() function, but copies a given number
  of characters instead of a given number of bytes. The @src string
  must be valid UTF-8 encoded text. (Use g_utf8_validate() on all
  text before trying to use UTF-8 utility functions with it.)
  
  Note you must ensure @dest is at least 4 * @n + 1 to fit the
  largest possible UTF-8 characters
  
  Parameters:
  
  dest - buffer to fill with characters from @src
  
  src - UTF-8 encoded string
  
  n - character count
  
  Returns:
  
  @dest
- utf8Strrchr
  
  public static Str utf8Strrchr(@Nonnull Str p, long len, byte c)
  
  Find the rightmost occurrence of the given Unicode character
  in a UTF-8 encoded string, while limiting the search to @len bytes.
  If @len is -1, allow unbounded search.
  
  Parameters:
  
  p - a nul-terminated UTF-8 encoded string
  
  len - the maximum length of @p
  
  c - a Unicode character
  
  Returns:
  
  %NULL if the string does not contain the character, otherwise, a pointer to the start of the rightmost occurrence of the character in the string.
- utf8Strreverse
  
  public static Str utf8Strreverse(@Nonnull Str str, long len)
  
  Reverses a UTF-8 string. @str must be valid UTF-8 encoded text.
  (Use g_utf8_validate() on all text before trying to use UTF-8
  utility functions with it.)
  
  This function is intended for programmatic uses of reversed strings.
  It pays no attention to decomposed characters, combining marks, byte
  order marks, directional indicators (LRM, LRO, etc) and similar
  characters which might need special handling when reversing a string
  for display purposes.
  
  Note that unlike g_strreverse(), this function returns
  newly-allocated memory, which should be freed with g_free() when
  no longer needed.
  
  Parameters:
  
  str - a UTF-8 encoded string
  
  len - the maximum length of @str to use, in bytes. If @len < 0, then the string is nul-terminated.
  
  Returns:
  
  a newly-allocated string which is the reverse of @str
- utf8Strup
  
  public static Str utf8Strup(@Nonnull Str str, long len)
  
  Converts all Unicode characters in the string that have a case
  to uppercase. The exact manner that this is done depends
  on the current locale, and may result in the number of
  characters in the string increasing. (For instance, the
  German ess-zet will be changed to SS.)
  
  Parameters:
  
  str - a UTF-8 encoded string
  
  len - length of @str, in bytes, or -1 if @str is nul-terminated.
  
  Returns:
  
  a newly allocated string, with all characters converted to uppercase.
- utf8Substring
  
  public static Str utf8Substring(@Nonnull Str str, long start_pos, long end_pos)
  
  Copies a substring out of a UTF-8 encoded string.
  The substring will contain @end_pos - @start_pos characters.
  
  Since GLib 2.72, `-1` can be passed to @end_pos to indicate the
  end of the string.
  
  Parameters:
  
  str - a UTF-8 encoded string
  
  start_pos - a character offset within @str
  
  end_pos - another character offset within @str, or `-1` to indicate the end of the string
  
  Returns:
  
  a newly allocated copy of the requested substring. Free with g_free() when no longer needed.
- uuidStringIsValid
  
  public static boolean uuidStringIsValid(@Nonnull Str str)
  
  Parses the string @str and verify if it is a UUID.
  
  The function accepts the following syntax:
  
  - simple forms (e.g. `f81d4fae-7dec-11d0-a765-00a0c91e6bf6`)
  
  Note that hyphens are required within the UUID string itself,
  as per the aforementioned RFC.
  
  Parameters:
  
  str - a string representing a UUID
  
  Returns:
  
  %TRUE if @str is a valid UUID, %FALSE otherwise.
- uuidStringRandom
  
  public static Str uuidStringRandom()
  
  Generates a random UUID (RFC 4122 version 4) as a string. It has the same
  randomness guarantees as #GRand, so must not be used for cryptographic
  purposes such as key generation, nonces, salts or one-time pads.
  
  Returns:
  
  A string that should be freed with g_free().
- variantGetGtype
  
  public static long variantGetGtype()
  
  Returns:
- variantIsObjectPath
  
  public static boolean variantIsObjectPath(@Nonnull Str string)
  
  Determines if a given string is a valid D-Bus object path. You
  should ensure that a string is a valid D-Bus object path before
  passing it to g_variant_new_object_path().
  
  A valid object path starts with `/` followed by zero or more
  sequences of characters separated by `/` characters. Each sequence
  must contain only the characters `[A-Z][a-z][0-9]_`. No sequence
  (including the one following the final `/` character) may be empty.
  
  Parameters:
  
  string - a normal C nul-terminated string
  
  Returns:
  
  %TRUE if @string is a D-Bus object path
- variantIsSignature
  
  public static boolean variantIsSignature(@Nonnull Str string)
  
  Determines if a given string is a valid D-Bus type signature. You
  should ensure that a string is a valid D-Bus type signature before
  passing it to g_variant_new_signature().
  
  D-Bus type signatures consist of zero or more definite #GVariantType
  strings in sequence.
  
  Parameters:
  
  string - a normal C nul-terminated string
  
  Returns:
  
  %TRUE if @string is a D-Bus type signature
- variantParseErrorPrintContext
  
  public static Str variantParseErrorPrintContext(@Nonnull Error error, @Nonnull Str source_str)
  Pretty-prints a message showing the context of a #GVariant parse
  error within the string for which parsing was attempted.
  
  The resulting string is suitable for output to the console or other
  monospace media where newlines are treated in the usual way.
  
  The message will typically look something like one of the following:
  
  unterminated string constant: (1, 2, 3, 'abc ^^^^
  
  or
  
  unable to find a common type: [1, 2, 3, 'str'] ^ ^^^^^
  
  The format of the message may change in a future version.
  
  @error must have come from a failed attempt to g_variant_parse() and
  @source_str must be exactly the same string that caused the error.
  If @source_str was not nul-terminated when you passed it to
  g_variant_parse() then you must add nul termination before using this
  function.
  Parameters:
  
  error - a #GError from the #GVariantParseError domain
  
  source_str - the string that was given to the parser
  
  Returns:
  
  the printed message
- variantParseErrorQuark
  
  public static int variantParseErrorQuark()
  
  Returns:
- variantTypeChecked
  
  public static VariantType variantTypeChecked(@Nonnull Str arg0)
  
  Parameters:
  
  arg0 -
  
  Returns:
- variantTypeStringGetDepth
  
  public static long variantTypeStringGetDepth(@Nonnull Str type_string)
  
  Parameters:
  
  type_string -
  
  Returns:
- variantTypeStringIsValid
  
  public static boolean variantTypeStringIsValid(@Nonnull Str type_string)
  
  Checks if @type_string is a valid GVariant type string. This call is
  equivalent to calling g_variant_type_string_scan() and confirming
  that the following character is a nul terminator.
  
  Parameters:
  
  type_string - a pointer to any string
  
  Returns:
  
  %TRUE if @type_string is exactly one valid type string Since 2.24
- warnMessage
  
  public static void warnMessage(@Nullable Str domain, @Nonnull Str file, int line, @Nonnull Str func, @Nullable Str warnexpr)
  
  Internal function used to print messages from the public g_warn_if_reached()
  and g_warn_if_fail() macros.
  
  Parameters:
  
  domain - log domain
  
  file - file containing the warning
  
  line - line number of the warning
  
  func - function containing the warning
  
  warnexpr - expression which failed

Class Glib

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class ch.bailu.gtk.type.Type

Methods inherited from class java.lang.Object

Constructor Details

Glib

Method Details

getClassHandler

access

alignedAlloc

alignedAlloc0

alignedFree

asciiDigitValue

asciiDtostr

asciiFormatd

asciiStrcasecmp

asciiStrdown

asciiStrncasecmp

asciiStrup

asciiTolower

asciiToupper

asciiXdigitValue

assertionMessage

assertionMessageCmpstr

assertionMessageCmpstrv

assertionMessageError

assertionMessageExpr

atomicIntCompareAndExchangeFull

atomicIntExchange

atomicPointerAdd

atomicPointerAnd

atomicPointerCompareAndExchange

atomicPointerCompareAndExchangeFull

atomicPointerExchange

atomicPointerGet

atomicPointerOr

atomicPointerSet

atomicPointerXor

atomicRcBoxAcquire

atomicRcBoxAlloc

atomicRcBoxAlloc0

atomicRcBoxDup

atomicRcBoxGetSize

atomicRcBoxRelease

atomicRcBoxReleaseFull

base64EncodeClose

bitNthLsf

bitNthMsf

bitStorage

bookmarkFileErrorQuark

buildFilename

buildPath

byteArrayFreeToBytes

byteArrayNew

byteArrayUnref

canonicalizeFilename

chdir

checkVersion

checksumTypeGetLength

clearError

close

computeChecksumForBytes

computeChecksumForString

computeHmacForBytes

convert

convertErrorQuark

convertWithFallback

datasetDestroy

datasetForeach

datasetIdGetData

datasetIdRemoveNoNotify

datasetIdSetDataFull

dateStrftime

dateValidJulian

dateValidMonth

dateValidWeekday

dcgettext

dgettext