Class Glib


public class Glib extends Package
  • Nested Class Summary

    Nested Classes
    Modifier and Type
    Class
    Description
    static interface 
     
    static interface 
     
    static interface 
     
    static interface 
     
    static interface 
     
    static interface 
     
    static interface 
     
    static interface 
     
    static interface 
     
    static interface 
     
    static interface 
     
    static interface 
     
  • Constructor Summary

    Constructors
    Constructor
    Description
     
  • 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
    Frees the memory allocated by g_aligned_alloc().
    static int
    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
    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
    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
    Compares @atomic to @oldval and, if equal, sets it to @newval.
    static boolean
    Compares @atomic to @oldval and, if equal, sets it to @newval.
    static Pointer
    Sets the @atomic to @newval and returns the old value from @atomic.
    static Pointer
    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
    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
    Retrieves the size of the reference counted data pointed by @mem_block.
    static void
    Atomically releases a reference on the data pointed by @mem_block.
    static void
    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
     
    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
    Transfers the data from the #GByteArray into a new immutable #GBytes.
    static ByteArray
    Creates a new #GByteArray with a reference count of 1.
    static void
    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
    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
     
    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
    Compares two #gpointer arguments and returns %TRUE if they are equal.
    static int
    Converts a gpointer to a hash value.
    static Str
    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
    Compares the two #gdouble values being pointed to and returns
    %TRUE if they are equal.
    static int
    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
     
    static Str
    Returns the display basename for the particular filename, guaranteed
    to be valid UTF-8.
    static Str
    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
    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
    Frees the memory pointed to by @mem.
    static Str
    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 Str
    Gets the character set for the current locale.
    static boolean
    Obtains the character set used by the console attached to the process,
    which is suitable for printing output to the terminal.
    static Str
    Gets the current directory.
    static Str
    getenv(Str variable)
    Returns the value of an environment variable.
    static Str
    Gets the current user's home directory.
    static Str
    Return a name for the machine.
    static long
    Queries the system monotonic time.
    static int
    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
    Gets the name of the program.
    static Str
    Gets the real name of the user.
    static long
    Queries the system wall-clock time.
    static Str
    Gets the directory to use for temporary files.
    static Str
    Returns a base directory in which to store non-essential, cached
    data specific to particular user.
    static Str
    Returns a base directory in which to store user-specific application
    configuration information such as user preferences and settings.
    static Str
    Returns a base directory in which to access application data such
    as icons that is customized for a particular user.
    static Str
    Gets the user name of the current user.
    static Str
    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
    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
    Checks if @key is in @hash_table.
    static void
    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
    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
    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
    Removes all keys and their associated values from a #GHashTable
    without calling the key and value destroy functions.
    static void
    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
    Tests if @hostname contains segments with an ASCII-compatible
    encoding of an Internationalized Domain Name.
    static boolean
    Tests if @hostname is the string form of an IPv4 or IPv6 address.
    static boolean
    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
    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
    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
    Adds a function to be called whenever there are no higher priority
    events pending to the default main loop.
    static boolean
    Removes the idle function with the given data.
    static Source
    Creates a new idle source.
    static boolean
    Compares the two #gint64 values being pointed to and returns
    %TRUE if they are equal.
    static int
    Converts a pointer to a #gint64 to a hash value.
    static boolean
    Compares the two #gint values being pointed to and returns
    %TRUE if they are equal.
    static Str
    Returns a canonical representation for @string.
    static Str
    internString(Str string)
    Returns a canonical representation for @string.
    static int
    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
    Converts an `errno` error number to a #GIOChannelError.
    static int
     
    static Source
    ioCreateWatch(IOChannel channel, int condition)
    Creates a #GSource that's dispatched when @condition is met for the
    given @channel.
    static int
     
    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
    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.
    Returns the global default main context.
    Gets the thread-default #GMainContext for this thread.
    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
    Returns the currently firing source for this thread.
    static int
    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
     
    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
     
    static boolean
    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
    Invokes gdb, which attaches to the current process and shows a
    stack trace.
    static int
     
    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
    Gets the #GQuark identifying the given (static) string.
    static int
    Gets the #GQuark identifying the given string.
    static Str
    quarkToString(int quark)
    Gets the string associated with the given #GQuark.
    static int
    Gets the #GQuark associated with the given string, or 0 if string is
    %NULL or it has no associated #GQuark.
    static double
    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
    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
    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
    Acquires a reference on a string.
    static long
    Retrieves the length of @str.
    static Str
    Creates a new reference counted string and copies the contents of @str
    into it.
    static 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
    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
     
    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
    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
     
    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
    Removes a source from the default main loop context given the
    source functions and user data.
    static boolean
    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
    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
     
    static int
     
    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
    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
    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
    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
     
    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
    Indicates that a test failed.
    static boolean
    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
    Gets the test path for the test currently being run.
    static ch.bailu.gtk.glib.TestSuite
    Get the toplevel test suite for the test path API.
    static void
    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
    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
    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
    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
    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
    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
    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
    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
    Get the number of seconds since the last start of the timer with
    g_test_timer_start().
    static double
    Report the last result of g_test_timer_elapsed().
    static void
    Start a timing test.
    static void
    testTrapAssertions(Str domain, Str file, int line, Str func, long assertion_flags, Str pattern)
     
    static boolean
    Check the result of the last g_test_trap_subprocess() call.
    static boolean
    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
     
    static void
    Terminates the current thread.
    static int
    This function will return the maximum @interval that a
    thread will wait in the thread pool for new tasks before
    being stopped.
    static int
    Returns the maximal allowed number of unused threads.
    static int
    Returns the number of currently unused threads.
    static void
    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
    Sets the maximal number of unused threads to @max_threads.
    static void
    Stops all currently unused threads.
    static Thread
    This function returns the #GThread corresponding to the
    current thread.
    static void
    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
    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
    Determines the break type of @c.
    static int
    Determines the canonical combining class of a Unicode character.
    static int
    Determines the numeric value of a character as a decimal
    digit.
    static int
    Looks up the #GUnicodeScript for a particular character (as defined
    by Unicode Standard Annex \#24).
    static boolean
    Determines whether a character is alphanumeric.
    static boolean
    Determines whether a character is alphabetic (i.e. a letter).
    static boolean
    Determines whether a character is a control character.
    static boolean
    Determines if a given character is assigned in the Unicode
    standard.
    static boolean
    Determines whether a character is numeric (i.e. a digit).
    static boolean
    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
    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
    Determines whether a character is printable.
    static boolean
    Determines whether a character is punctuation or a symbol.
    static boolean
    Determines whether a character is a space, tab, or line separator
    (newline, carriage return, etc.).
    static boolean
    Determines if a character is titlecase.
    static boolean
    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
    Determines if a character is typically rendered in a double-width
    cell under legacy East Asian locales.
    static boolean
    Determines if a character is a hexadecimal digit.
    static boolean
    Determines if a given character typically takes zero width when rendered.
    static byte
    Converts a character to lower case.
    static byte
    Converts a character to the titlecase.
    static byte
    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
    Determines the numeric value of a character as a hexadecimal
    digit.
    static int
    Looks up the Unicode script for @iso15924.
    static int
    Looks up the ISO 15924 code for @script.
    static int
     
    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
     
    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
    Gets the scheme portion of a URI string.
    static Str
    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
    Converts a string into a collation key that can be compared
    with other collation keys produced by the same function using strcmp().
    static Str
    Finds the start of the next UTF-8 character in the string after @p.
    static Str
    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
    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
    Converts from a pointer to position within a string to an integer
    character offset.
    static Str
    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
    Parses the string @str and verify if it is a UUID.
    static Str
    Generates a random UUID (RFC 4122 version 4) as a string.
    static long
     
    static boolean
    Determines if a given string is a valid D-Bus object path.
    static boolean
    Determines if a given string is a valid D-Bus type signature.
    static Str
    Pretty-prints a message showing the context of a #GVariant parse
    error within the string for which parsing was attempted.
    static int
     
     
    static long
     
    static boolean
    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!
      <!-- language="C" -->
        // 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:
      <!-- language="C" -->
       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+:
      <!-- language="C" -->
       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:
      <!-- language="C" -->
       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:
      <!-- language="C" -->
       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:
      <!-- language="C" -->
       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:
      <!-- language="C" -->
         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:
      <!-- language="C" -->
         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:
      <!-- language="C" -->
         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.
      <!-- language="C" -->
       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()
      <!-- language="C" -->
       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 &#x1; ... &#x1f; 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.
      <!-- language="C" -->
       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.
      <!-- language="C" -->
       #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:
      <!-- language="C" -->
         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:
      <!-- language="C" -->
         g_ascii_strup (g_strcanon (str, "abc", '?'))
       


      In order to modify a copy, you may use g_strdup():
      <!-- language="C" -->
         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:
      <!-- language="C" -->
         g_ascii_strup (g_strdelimit (str, "abc", '?'))
       


      In order to modify a copy, you may use g_strdup():
      <!-- language="C" -->
         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:
      <!-- language="C" -->
         // 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:
      <!-- language="C" -->
       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.
      <!-- language="C" -->
         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