[1236:7] extends: object
Specifies the type of function which is called just after an extended error
instance is created and its fields filled. It should only initialize the
fields in the private data, which can be received with the generated
*_get_private() function. Normally, it is better to use
G_DEFINE_EXTENDED_ERROR(), as it already takes care of getting the private
data from @error.
GLibErrorInitFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (error)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[4373:14] static extends: object
Generated low-level function wrappers for namespace GLib.
getLib ()
access (string 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().
filename is a pathname in the GLib file name encoding (UTF-8 on Windows).mode is as in access().zero if the pathname refers to an existing file system object that has all the tested permissions, or -1 otherwise or on error..aligned_alloc (int n_blocks, int n_block_bytes, int alignment)
This function is similar to g_malloc(), allocating (@n_blocks *
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_sized() or g_aligned_free().n_blocks is the number of blocks to allocate.n_block_bytes is the size of each block in bytes.alignment is the alignment to be enforced, which must be a positive power of 2 and a multiple of sizeof(void*).the allocated memory.aligned_alloc0 (int n_blocks, int n_block_bytes, int alignment)
This function is similar to g_aligned_alloc(), but it will also clear the allocated memory before returning it.
n_blocks is the number of blocks to allocate.n_block_bytes is the size of each block in bytes.alignment is the alignment to be enforced, which must be a positive power of 2 and a multiple of sizeof(void*).the allocated, cleared memory.aligned_free (mem)
Frees the memory allocated by g_aligned_alloc().
mem is the memory to deallocate.None.aligned_free_sized (mem, int alignment, int size)
Frees the memory pointed to by @mem, assuming it is has the given @size and @alignment. If @mem is %NULL this is a no-op (and @size is ignored). It is an error if @size doesn’t match the size, or @alignment doesn’t match the alignment, passed when @mem was allocated. @size and @alignment are passed to this function to allow optimizations in the allocator. If you don’t know either of them, use g_aligned_free() instead.
mem is the memory to free.alignment is alignment of @mem.size is size of @mem, in bytes.None.array_new_take (data, int len, bool clear, int element_size)
Creates a new
GArraywith @data as array data, @len as length and a reference count of 1. This avoids having to copy the data manually, when it can just be inherited. After this call, @data belongs to theGArrayand may no longer be modified by the caller. The memory of @data has to be dynamically allocated and will eventually be freed with [func@GLib.free]. In case the elements need to be cleared when the array is freed, use [func@GLib.Array.set_clear_func] to set a [callback@GLib.DestroyNotify] function to perform such task. Do not use it if @len or @element_size are greater thanG_MAXUINT.GArraystores the length of its data inguint, which may be shorter thangsize.
data is an array of elements of @element_size.len is the number of elements in @data.clear is if true, GArray elements should be automatically cleared to 0 when they are allocated.element_size is the size of each element in bytes.The new #GArray.array_new_take_zero_terminated (data, bool clear, int element_size)
Creates a new
GArraywith @data as array data, computing the length of it and setting the reference count to 1. This avoids having to copy the data manually, when it can just be inherited. After this call, @data belongs to theGArrayand may no longer be modified by the caller. The memory of @data has to be dynamically allocated and will eventually be freed with [func@GLib.free]. The length is calculated by iterating through @data until the firstNULLelement is found. In case the elements need to be cleared when the array is freed, use [func@GLib.Array.set_clear_func] to set a [callback@GLib.DestroyNotify] function to perform such task. Do not use it if @data length or
are greater than G_MAXUINT. GArray stores the length of its data in guint, which may be shorter than gsize.data is an array of elements of @element_size, NULL terminated.clear is if true, GArray elements should be automatically cleared to 0 when they are allocated.element_size is the size of each element in bytes.The new GArray.ascii_digit_value (int c)
Determines the numeric value of a character as a decimal digit. If the character is not a decimal digit according to [func@GLib.ascii_isdigit],
-1is returned. Differs from [func@GLib.unichar_digit_value] because it takes a char, so there's no worry about sign extension if characters are signed.
c is an ASCII character.the numerical value of @c if it is a decimal digit, -1 otherwise.ascii_dtostr (string buffer, int buf_len, double d)
Converts a
gdoubleto a string, using the '.' as decimal point. This function generates enough precision that converting the string back using [func@GLib.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 [const@GLib.ASCII_DTOSTR_BUF_SIZE] bytes, including the terminating nul character, which is always added.
buffer is a buffer to place the resulting string in.buf_len is the length of the buffer.d is the value to convert.the pointer to the buffer with the converted string.ascii_formatd (string buffer, int buf_len, string format, double d)
Converts a
gdoubleto a string, using the '.' as decimal point. To format the number you pass in aprintf()-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 agdoubleargument. The returned buffer is guaranteed to be nul-terminated. If you just want to want to serialize the value into a string, use [func@GLib.ascii_dtostr].
buffer is a buffer to place the resulting string in.buf_len is the length of the buffer.format is the printf()-style format to use for the code to use for converting.d is the value to convert.the pointer to the buffer with the converted string.ascii_strcasecmp (string s1, string 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.
s1 is string to compare with @s2.s2 is string to compare with @s1.0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2.ascii_strdown (string str, int len)
Converts all upper case ASCII letters to lower case ASCII letters, with semantics that exactly match [func@GLib.ascii_tolower].
str is a string.len is length of @str in bytes, or -1 if @str is nul-terminated.a newly-allocated string, with all the upper case characters in @str converted to lower case. (Note that this is unlike the old [func@GLib.strdown], which modified the string in place.).ascii_string_to_signed (string str, int base, int min, int max)
A convenience function for converting a string to a signed number. This function assumes that @str contains only a number of the given @base that is within inclusive bounds limited by @min and @max. If this is true, then the converted number is stored in @out_num. An empty string is not a valid input. A string with leading or trailing whitespace is also an invalid input. @base can be between 2 and 36 inclusive. Hexadecimal numbers must not be prefixed with "0x" or "0X". Such a problem does not exist for octal numbers, since they were usually prefixed with a zero which does not change the value of the parsed number. Parsing failures result in an error with the
G_NUMBER_PARSER_ERRORdomain. If the input is invalid, the error code will be [error@GLib.NumberParserError.INVALID]. If the parsed number is out of bounds - [error@GLib.NumberParserError.OUT_OF_BOUNDS]. See [func@GLib.ascii_strtoll] if you have more complex needs such as parsing a string which starts with a number, but then has other characters.
str is a string to convert.base is base of a parsed number.min is a lower bound (inclusive).max is an upper bound (inclusive).out_num is a return location for a number.true if @str was a number, false otherwise.ascii_string_to_unsigned (string str, int base, int min, int max)
A convenience function for converting a string to an unsigned number. This function assumes that @str contains only a number of the given @base that is within inclusive bounds limited by @min and @max. If this is true, then the converted number is stored in @out_num. An empty string is not a valid input. A string with leading or trailing whitespace is also an invalid input. A string with a leading sign (
-or+) is not a valid input for the unsigned parser. @base can be between 2 and 36 inclusive. Hexadecimal numbers must not be prefixed with "0x" or "0X". Such a problem does not exist for octal numbers, since they were usually prefixed with a zero which does not change the value of the parsed number. Parsing failures result in an error with theG_NUMBER_PARSER_ERRORdomain. If the input is invalid, the error code will be [error@GLib.NumberParserError.INVALID]. If the parsed number is out of bounds - [error@GLib.NumberParserError.OUT_OF_BOUNDS]. See [func@GLib.ascii_strtoull] if you have more complex needs such as parsing a string which starts with a number, but then has other characters.
str is a string.base is base of a parsed number.min is a lower bound (inclusive).max is an upper bound (inclusive).out_num is a return location for a number.true if @str was a number, false otherwise.ascii_strncasecmp (string s1, string s2, int 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
strncasecmp()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 [func@GLib.ascii_strcasecmp] applies: Use this function only on strings known to be in encodings where bytes corresponding to ASCII letters always represent themselves.
s1 is string to compare with @s2.s2 is string to compare with @s1.n is number of characters to compare.0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2.ascii_strtod (string nptr)
Converts a string to a floating point value. This function behaves like the standard
strtod()function does in the C locale. It does this without actually changing the current locale, since that would not be thread-safe. A limitation of the implementation is that this function will still accept localized versions of infinities and NANs. This function is typically used when reading configuration files or other non-user input that should be locale independent. To handle input from the user you should normally use the locale-sensitive systemstrtod()function. To convert from a gdouble to a string in a locale-insensitive way, use [func@GLib.ascii_dtostr]. If the correct value would cause overflow, plus or minusHUGE_VALis returned (according to the sign of the value), andERANGEis stored inerrno. If the correct value would cause underflow, zero is returned andERANGEis stored inerrno. This function resetserrnobefore callingstrtod()so that you can reliably detect overflow and underflow.
nptr is the string to convert to a numeric value.endptr is if non-NULL, it returns the character after the last character used in the conversion.the converted value.ascii_strtoll (string nptr, int base)
Converts a string to a
gint64value. This function behaves like the standardstrtoll()function does in the C locale. It does this without actually changing the current locale, since that would not be thread-safe. This function is typically used when reading configuration files or other non-user input that should be locale independent. To handle input from the user you should normally use the locale-sensitive systemstrtoll()function. If the correct value would cause overflow, [const@GLib.MAXINT64] or [const@GLib.MININT64] is returned, andERANGEis stored inerrno. If the base is outside the valid range, zero is returned, andEINVALis stored inerrno. If the string conversion fails, zero is returned, and @endptr returns @nptr (if @endptr is non-NULL).
nptr is the string to convert to a numeric value.endptr is if non-NULL, it returns the character after the last character used in the conversion.base is to be used for the conversion, 2..36 or 0.the converted value, or zero on error.ascii_strtoull (string nptr, int base)
Converts a string to a
guint64value. This function behaves like the standardstrtoull()function does in the C locale. It does this without actually changing the current locale, since that would not be thread-safe. Note that input with a leading minus sign (-) is accepted, and will return the negation of the parsed number, unless that would overflow aguint64. Critically, this means you cannot assume that a short fixed length input will result in a low return value, as the input could have a leading-. This function is typically used when reading configuration files or other non-user input that should be locale independent. To handle input from the user you should normally use the locale-sensitive systemstrtoull()function. If the correct value would cause overflow, [const@GLib.MAXUINT64] is returned, andERANGEis stored inerrno. If the base is outside the valid range, zero is returned, andEINVALis stored inerrno. If the string conversion fails, zero is returned, and @endptr returns @nptr (if @endptr is non-NULL).
nptr is the string to convert to a numeric value.endptr is if non-NULL, it returns the character after the last character used in the conversion.base is to be used for the conversion, 2..36 or 0.the converted value, or zero on error.ascii_strup (string str, int len)
Converts all lower case ASCII letters to upper case ASCII letters, with semantics that exactly match [func@GLib.ascii_toupper].
str is a string.len is length of @str in bytes, or -1 if @str is nul-terminated.a newly-allocated string, with all the lower case characters in @str converted to upper case. (Note that this is unlike the old [func@GLib.strup], which modified the string in place.).ascii_tolower (int c)
Convert a character to ASCII lower case. If the character is not an ASCII upper case letter, it is returned unchanged. 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 onEOFbut no need to worry about casting togucharbefore passing a possibly non-ASCII character in.
c is any character.the result of the conversion.ascii_toupper (int c)
Convert a character to ASCII upper case. If the character is not an ASCII lower case letter, it is returned unchanged. 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 onEOFbut no need to worry about casting togucharbefore passing a possibly non-ASCII character in.
c is any character.the result of the conversion.ascii_xdigit_value (int c)
Determines the numeric value of a character as a hexadecimal digit. If the character is not a hex digit according to [func@GLib.ascii_isxdigit],
-1is returned. Differs from [func@GLib.unichar_xdigit_value] because it takes a char, so there's no worry about sign extension if characters are signed. Differs from [func@GLib.unichar_xdigit_value] because it takes a char, so there's no worry about sign extension if characters are signed.
c is an ASCII character.the numerical value of @c if it is a hex digit, -1 otherwise.assert_warning (string log_domain, string file, int line, string pretty_function, string expression)
Generated wrapper for GIR function
assert_warning. Native symbol:g_assert_warning.
None.assertion_message (string domain, string file, int line, string func, string message)
Generated wrapper for GIR function
assertion_message. Native symbol:g_assertion_message.
None.assertion_message_cmpint (string domain, string file, int line, string func, string expr, int arg1, string cmp, int arg2, int numtype)
Generated wrapper for GIR function
assertion_message_cmpint. Native symbol:g_assertion_message_cmpint.
None.assertion_message_cmpstr (string domain, string file, int line, string func, string expr, string arg1, string cmp, string arg2)
Generated wrapper for GIR function
assertion_message_cmpstr. Native symbol:g_assertion_message_cmpstr.
None.assertion_message_cmpstrv (string domain, string file, int line, string func, string expr, string arg1, string arg2, int first_wrong_idx)
Generated wrapper for GIR function
assertion_message_cmpstrv. Native symbol:g_assertion_message_cmpstrv.
None.assertion_message_expr (string domain, string file, int line, string func, string expr)
Internal function used to print messages from the public g_assert() and g_assert_not_reached() macros.
domain is log domain.file is file containing the assertion.line is line number of the assertion.func is function containing the assertion.expr is expression which failed.None.async_queue_new ()
Creates a new asynchronous queue.
a new #GAsyncQueue. Free with g_async_queue_unref().async_queue_new_full (object item_free_func)
Creates a new asynchronous queue and sets up a destroy notify function that is used to free any remaining queue items when the queue is destroyed after the final unref.
item_free_func is function to free queue elements.a new #GAsyncQueue. Free with g_async_queue_unref().atexit (object func)
Specifies a function to be called at normal program termination. Since GLib 2.8.2, on Windows g_atexit() actually is a preprocessor macro that maps to a call to the atexit() function in the C library. This means that in case the code that calls g_atexit(), i.e. atexit(), is in a DLL, the function will be called when the DLL is detached from the program. This typically makes more sense than that the function is called when the GLib DLL is detached, which happened earlier when g_atexit() was a function in the GLib DLL. The behaviour of atexit() in the context of dynamically loaded modules is not formally specified and varies wildly. On POSIX systems, calling g_atexit() (or atexit()) in a dynamically loaded module which is unloaded before the program terminates might well cause a crash at program exit. Some POSIX systems implement atexit() like Windows, and have each dynamically loaded module maintain an own atexit chain that is called when the module is unloaded. On other POSIX systems, before a dynamically loaded module is unloaded, the registered atexit functions (if any) residing in that module are called, regardless where the code that registered them resided. This is presumably the most robust approach. As can be seen from the above, for portability it's best to avoid calling g_atexit() (or atexit()) except in the main executable of a program.
func is the function to call on normal program termination..None.atomic_int_add (atomic, int 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. Before version 2.30, this function did not return a value (but g_atomic_int_exchange_and_add() did, and had the same meaning). While
has a volatile qualifier, this is a historical artifact and the pointer passed to it should not be volatile.atomic is a pointer to a #gint or #guint.val is the value to add.the value of @atomic before the add, signed.atomic_int_and (atomic, int val)
Performs an atomic bitwise 'and' of the value of @atomic and @val, storing the result back in @atomic. This call acts as a full compiler and hardware memory barrier. Think of this operation as an atomic version of
{ tmp = *atomic; *atomic &= val; return tmp; }. While @atomic has avolatilequalifier, this is a historical artifact and the pointer passed to it should not bevolatile.
atomic is a pointer to a #gint or #guint.val is the value to 'and'.the value of @atomic before the operation, unsigned.atomic_int_compare_and_exchange (atomic, int oldval, int 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
has a volatile qualifier, this is a historical artifact and the pointer passed to it should not be volatile.atomic is a pointer to a #gint or #guint.oldval is the value to compare with.newval is the value to conditionally replace with.%TRUE if the exchange took place.atomic_int_compare_and_exchange_full (atomic, int oldval, int newval)
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
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()atomic is a pointer to a #gint or #guint.oldval is the value to compare with.newval is the value to conditionally replace with.preval is the contents of @atomic before this operation.%TRUE if the exchange took place.atomic_int_dec_and_test (atomic)
Decrements the value of @atomic by 1. Think of this operation as an atomic version of
{ *atomic -= 1; return (*atomic == 0); }. This call acts as a full compiler and hardware memory barrier. While @atomic has avolatilequalifier, this is a historical artifact and the pointer passed to it should not bevolatile.
atomic is a pointer to a #gint or #guint.%TRUE if the resultant value is zero.atomic_int_exchange (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.
atomic is a pointer to a #gint or #guint.newval is the value to replace with.the value of @atomic before the exchange, signed.atomic_int_exchange_and_add (atomic, int val)
This function existed before g_atomic_int_add() returned the prior value of the integer (which it now does). It is retained only for compatibility reasons. Don't use this function in new code.
atomic is a pointer to a #gint.val is the value to add.the value of @atomic before the add, signed.atomic_int_get (atomic)
Gets the current value of @atomic. This call acts as a full compiler and hardware memory barrier. While @atomic has a
volatilequalifier, this is a historical artifact and the pointer passed to it should not bevolatile.
atomic is a pointer to a #gint or #guint.the value of the integer.atomic_int_inc (atomic)
Increments the value of @atomic by 1. Think of this operation as an atomic version of
{ *atomic += 1; }. This call acts as a full compiler and hardware memory barrier. While @atomic has avolatilequalifier, this is a historical artifact and the pointer passed to it should not bevolatile.
atomic is a pointer to a #gint or #guint.None.atomic_int_or (atomic, int 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 avolatilequalifier, this is a historical artifact and the pointer passed to it should not bevolatile.
atomic is a pointer to a #gint or #guint.val is the value to 'or'.the value of @atomic before the operation, unsigned.atomic_int_set (atomic, int newval)
Sets the value of @atomic to @newval. This call acts as a full compiler and hardware memory barrier. While @atomic has a
volatilequalifier, this is a historical artifact and the pointer passed to it should not bevolatile.
atomic is a pointer to a #gint or #guint.newval is a new value to store.None.atomic_int_xor (atomic, int 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 avolatilequalifier, this is a historical artifact and the pointer passed to it should not bevolatile.
atomic is a pointer to a #gint or #guint.val is the value to 'xor'.the value of @atomic before the operation, unsigned.atomic_pointer_add (atomic, int 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
has a volatile qualifier, this is a historical artifact and the pointer passed to it should not be volatile. In GLib 2.80, the return type was changed from #gssize to #gintptr to add support for platforms with 128-bit pointers. This should not affect existing code.atomic is a pointer to a #gpointer-sized value.val is the value to add.the value of @atomic before the add, signed.atomic_pointer_and (atomic, int 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 avolatilequalifier, this is a historical artifact and the pointer passed to it should not bevolatile. In GLib 2.80, the return type was changed from #gsize to #guintptr to add support for platforms with 128-bit pointers. This should not affect existing code.
atomic is a pointer to a #gpointer-sized value.val is the value to 'and'.the value of @atomic before the operation, unsigned.atomic_pointer_compare_and_exchange (atomic, oldval, 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
has a volatile qualifier, this is a historical artifact and the pointer passed to it should not be volatile.atomic is a pointer to a #gpointer-sized value.oldval is the value to compare with.newval is the value to conditionally replace with.%TRUE if the exchange took place.atomic_pointer_compare_and_exchange_full (atomic, oldval, newval)
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
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()atomic is a pointer to a #gpointer-sized value.oldval is the value to compare with.newval is the value to conditionally replace with.preval is the contents of @atomic before this operation.%TRUE if the exchange took place.atomic_pointer_exchange (atomic, 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.
atomic is a pointer to a #gpointer-sized value.newval is the value to replace with.the value of @atomic before the exchange.atomic_pointer_get (atomic)
Gets the current value of @atomic. This call acts as a full compiler and hardware memory barrier. While @atomic has a
volatilequalifier, this is a historical artifact and the pointer passed to it should not bevolatile.
atomic is a pointer to a #gpointer-sized value.the value of the pointer.atomic_pointer_or (atomic, int 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 avolatilequalifier, this is a historical artifact and the pointer passed to it should not bevolatile. In GLib 2.80, the return type was changed from #gsize to #guintptr to add support for platforms with 128-bit pointers. This should not affect existing code.
atomic is a pointer to a #gpointer-sized value.val is the value to 'or'.the value of @atomic before the operation, unsigned.atomic_pointer_set (atomic, newval)
Sets the value of @atomic to @newval. This call acts as a full compiler and hardware memory barrier. While @atomic has a
volatilequalifier, this is a historical artifact and the pointer passed to it should not bevolatile.
atomic is a pointer to a #gpointer-sized value.newval is a new value to store.None.atomic_pointer_xor (atomic, int 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 avolatilequalifier, this is a historical artifact and the pointer passed to it should not bevolatile. In GLib 2.80, the return type was changed from #gsize to #guintptr to add support for platforms with 128-bit pointers. This should not affect existing code.
atomic is a pointer to a #gpointer-sized value.val is the value to 'xor'.the value of @atomic before the operation, unsigned.atomic_rc_box_acquire (mem_block)
Atomically acquires a reference on the data pointed by @mem_block.
mem_block is a pointer to reference counted data.a pointer to the data, with its reference count increased.atomic_rc_box_alloc (int 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.
block_size is the size of the allocation, must be greater than 0.a pointer to the allocated memory.atomic_rc_box_alloc0 (int 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.
block_size is the size of the allocation, must be greater than 0.a pointer to the allocated memory.atomic_rc_box_dup (int block_size, mem_block)
Allocates a new block of data with atomic reference counting semantics, and copies @block_size bytes of @mem_block into it.
block_size is the number of bytes to copy, must be greater than 0.mem_block is the memory to copy.a pointer to the allocated memory.atomic_rc_box_get_size (mem_block)
Retrieves the size of the reference counted data pointed by @mem_block.
mem_block is a pointer to reference counted data.the size of the data, in bytes.atomic_rc_box_release (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 is a pointer to reference counted data.None.atomic_rc_box_release_full (mem_block, object 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
Note that implementing weak references via @clear_func is not thread-safe: clearing a pointer to the memory from the callback can race with another thread trying to access it as @mem_block already has a reference count of 0 when the callback is called and will be freed.mem_block is a pointer to reference counted data.clear_func is a function to call when clearing the data.None.atomic_ref_count_compare (int arc, int val)
Atomically compares the current value of @arc with @val.
arc is the address of an atomic reference count variable.val is the value to compare.%TRUE if the reference count is the same as the given value.atomic_ref_count_dec (int arc)
Atomically decreases the reference count. If %TRUE is returned, the reference count reached 0. After this point, @arc is an undefined state and must be reinitialized with g_atomic_ref_count_init() to be used again.
arc is the address of an atomic reference count variable.%TRUE if the reference count reached 0, and %FALSE otherwise.atomic_ref_count_inc (int arc)
Atomically increases the reference count.
arc is the address of an atomic reference count variable.None.atomic_ref_count_init ()
Initializes a reference count variable to 1.
arc is the address of an atomic reference count variable.None.base64_decode (string text)
Decode a sequence of Base-64 encoded text into binary data. Note that the returned binary data is not necessarily zero-terminated, so it should not be used as a character string.
text is zero-terminated string with base64 text to decode.out_len is The length of the decoded data is written here.newly allocated buffer containing the binary data that @text represents. The returned buffer must be freed with g_free()..base64_decode_inplace (int out_len)
Decode a sequence of Base-64 encoded text into binary data by overwriting the input data.
text is zero-terminated string with base64 text to decode.out_len is The length of the decoded data is written here.The binary data that @text responds. This pointer is the same as the input @text..base64_decode_step (string in, int state, int save)
Incrementally decode a sequence of binary data from its Base-64 stringified representation. By calling this function multiple times you can convert data in chunks to avoid having to have the full encoded data in memory. The output buffer must be large enough to fit all the data that will be written to it. Since base64 encodes 3 bytes in 4 chars you need at least: (@len / 4) * 3 + 3 bytes (+ 3 may be needed in case of non-zero state). FRAGILE:
inmust be ASCII base64 - itslenis passed as the string's character count (the byte count for ASCII) and the output buffer is over-allocated to that length, then sliced to the bytes actually decoded. Non-ASCII input would mis-size the call.
in is base-64 encoded input data.len is max length of @in data to decode.out is output buffer.state is Saved state between steps, initialize to 0.save is Saved state between steps, initialize to 0.The number of bytes of output that was written.base64_encode (list data)
Encode a sequence of binary data into its Base-64 stringified representation.
data is the binary data to encode.len is the length of @data.a newly allocated, zero-terminated Base-64 encoded string representingThe returned string must be freed with g_free()..base64_encode_close (bool break_lines, int state, 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.
break_lines is whether to break long lines.out is pointer to destination buffer.state is Saved state from g_base64_encode_step().save is Saved state from g_base64_encode_step().The number of bytes of output that was written.base64_encode_step (list in, bool break_lines, int state, int save)
Incrementally encode a sequence of binary data into its Base-64 stringified representation. By calling this function multiple times you can convert data in chunks to avoid having to have the full encoded data in memory. When all of the data has been converted you must call g_base64_encode_close() to flush the saved state. The output buffer must be large enough to fit all the data that will be written to it. Due to the way base64 encodes you will need at least: (@len / 3 + 1) * 4 + 4 bytes (+ 4 may be needed in case of non-zero state). If you enable line-breaking you will need at least: ((@len / 3 + 1) * 4 + 4) / 76 + 1 bytes of extra space. @break_lines is typically used when putting base64-encoded data in emails. It breaks the lines at 76 columns instead of putting all of the text on the same line. This avoids problems with long lines in the email system. Note however that it breaks the lines with
LFcharacters, notCR LFsequences, so the result cannot be passed directly to SMTP or certain other protocols.
in is the binary data to encode.len is the length of @in.break_lines is whether to break long lines.out is pointer to destination buffer.state is Saved state between steps, initialize to 0.save is Saved state between steps, initialize to 0.The number of bytes of output that was written.basename (string file_name)
Gets the name of the file without any leading directory components. It returns a pointer into the given file name string.
file_name is the name of the file.the name of the file without any leading directory components.bit_lock (address, int lock_bit)
Sets the indicated @lock_bit in @address. If the bit is already set, this call will block until g_bit_unlock() unsets the corresponding bit. Attempting to lock on two different bits within the same integer is not supported and will very probably cause deadlocks. The value of the bit that is set is (1u << @bit). If @bit is not between 0 and 31 then the result is undefined. This function accesses @address atomically. All other accesses to @address must be atomic in order for this function to work reliably. While @address has a
volatilequalifier, this is a historical artifact and the argument passed to it should not bevolatile.
address is a pointer to an integer.lock_bit is a bit value between 0 and 31.None.bit_lock_and_get (address, int lock_bit)
Sets the indicated @lock_bit in @address and atomically returns the new value. This is like [func@GLib.bit_lock], except it can atomically return the new value at @address (right after obtaining the lock). Thus the value returned in @out_val always has the @lock_bit set.
address is a pointer to an integer.lock_bit is a bit value between 0 and 31.out_val is return location for the new value of the integer.None.bit_nth_lsf (int 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.
mask is a #gulong containing flags.nth_bit is the index of the bit to start the search from.the index of the first bit set which is higher than @nth_bit, or -1 if no higher bits are set.bit_nth_msf (int 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.
mask is a #gulong containing flags.nth_bit is the index of the bit to start the search from.the index of the first bit set which is lower than @nth_bit, or -1 if no lower bits are set.bit_storage (int number)
Gets the number of bits used to hold @number, e.g. if @number is 4, 3 bits are needed.
number is a #guint.the number of bits used to hold @number.bit_trylock (address, int lock_bit)
Sets the indicated @lock_bit in @address, returning %TRUE if successful. If the bit is already set, returns %FALSE immediately. Attempting to lock on two different bits within the same integer is not supported. The value of the bit that is set is (1u << @bit). If @bit is not between 0 and 31 then the result is undefined. This function accesses @address atomically. All other accesses to @address must be atomic in order for this function to work reliably. While @address has a
volatilequalifier, this is a historical artifact and the argument passed to it should not bevolatile.
address is a pointer to an integer.lock_bit is a bit value between 0 and 31.%TRUE if the lock was acquired.bit_unlock (address, int lock_bit)
Clears the indicated @lock_bit in @address. If another thread is currently blocked in g_bit_lock() on this same bit then it will be woken up. This function accesses @address atomically. All other accesses to
must be atomic in order for this function to work reliably. While @address has a volatile qualifier, this is a historical artifact and the argument passed to it should not be volatile.address is a pointer to an integer.lock_bit is a bit value between 0 and 31.None.bit_unlock_and_set (address, int lock_bit, int new_val, int preserve_mask)
This is like [func@GLib.bit_unlock] but also atomically sets @address to
If @preserve_mask is not zero, then the @preserve_mask bits will be preserved in @address and are not set to @val. Note that the @lock_bit bit will always be unset regardless of @val, @preserve_mask and the currently set value in @address.address is a pointer to an integer.lock_bit is a bit value between 0 and 31.new_val is the new value to set.preserve_mask is mask for bits from @address to preserve.None.blow_chunks ()
Generated wrapper for GIR function
blow_chunks. Native symbol:g_blow_chunks.
None.build_filename (string first_element, list varargs)
Creates a filename from a series of elements using the correct separator for the current platform. 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. If you are building a path programmatically you may want to use #GPathBuf instead.
first_element is the first element in the path.... is remaining elements in path, terminated by %NULL.the newly allocated path.build_filenamev (list args)
Creates a filename from a vector of elements using the correct separator for the current platform. This function behaves exactly like g_build_filename(), but takes the path elements as a string array, instead of varargs. This function is mainly meant for language bindings. If you are building a path programmatically you may want to use #GPathBuf instead.
args is %NULL-terminated array of strings containing the path elements..the newly allocated path.build_path (string separator, string first_element, list varargs)
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, thenABABAhas 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.
separator is a string used to separate the elements of the path..first_element is the first element in the path.... is remaining elements in path, terminated by %NULL.the newly allocated path.build_pathv (string separator, list args)
Behaves exactly like g_build_path(), but takes the path elements as a string array, instead of variadic arguments. This function is mainly meant for language bindings.
separator is a string used to separate the elements of the path..args is %NULL-terminated array of strings containing the path elements..a newly-allocated string that must be freed with g_free()..byte_array_append (list array, list data)
Adds the given bytes to the end of the
GByteArray. The array will grow in size automatically if necessary.
array is a byte array.data is the byte data to be added.len is the number of bytes to add.The GByteArray.byte_array_free (list array, bool free_segment)
Frees the memory allocated by the
GByteArray. If @free_segment is true it frees the actual byte data. If the reference count of @array is greater than one, theGByteArraywrapper is preserved but the size of
will be set to zero.array is a byte array.free_segment is if true, the actual byte data is freed as well.The allocated element data if @free_segment is false, otherwise NULL..byte_array_free_to_bytes (list array)
Transfers the data from the
GByteArrayinto a new immutable [struct@GLib.Bytes]. TheGByteArrayis freed unless the reference count of @array is greater than one, in which theGByteArraywrapper is preserved but the size of @array will be set to zero. This is identical to using [ctor@GLib.Bytes.new_take] and [func@GLib.ByteArray.free] together.
array is a byte array.The new immutable [struct@GLib.Bytes] representing same byte data that was in the array.byte_array_new ()
Creates a new
GByteArraywith a reference count of 1.
The new GByteArray.byte_array_new_take (list data)
Creates a byte array containing the @data. After this call, @data belongs to the
GByteArrayand may no longer be modified by the caller. The memory of @data has to be dynamically allocated and will eventually be freed with [func@GLib.free]. Do not use it if @len is greater thanG_MAXUINT.GByteArraystores the length of its data inguint, which may be shorter thangsize.
data is the byte data for the array.len is the length of @data.The new GByteArray.byte_array_prepend (list array, list data)
Adds the given data to the start of the
GByteArray. The array will grow in size automatically if necessary.
array is a byte array.data is the byte data to be added.len is the number of bytes to add.The GByteArray.byte_array_ref (list array)
Atomically increments the reference count of @array by one. This function is thread-safe and may be called from any thread.
array is a byte array.The passed in GByteArray.byte_array_remove_index (list array, int index_)
Removes the byte at the given index from a
GByteArray. The following bytes are moved down one place.
array is a byte array.index_ is the index of the byte to remove.The GByteArray.byte_array_remove_index_fast (list array, int index_)
Removes the byte at the given index from a
GByteArray. The last element in the array is used to fill in the space, so this function does not preserve the order of theGByteArray. But it is faster than [func@GLib.ByteArray.remove_index].
array is a byte array.index_ is the index of the byte to remove.The GByteArray.byte_array_remove_range (list array, int index_, int length)
Removes the given number of bytes starting at the given index from a
GByteArray. The following elements are moved to close the gap.
array is a byte array.index_ is the index of the first byte to remove.length is the number of bytes to remove.The GByteArray.byte_array_set_size (list array, int length)
Sets the size of the
GByteArray, expanding it if necessary.
array is a byte array.length is the new size of the GByteArray.The GByteArray.byte_array_sized_new (int reserved_size)
Creates a new
GByteArraywith @reserved_size bytes preallocated. This avoids frequent reallocation, if you are going to add many bytes to the array. Note however that the size of the array is still 0.
reserved_size is the number of bytes preallocated.The new GByteArray.byte_array_sort (list array, object compare_func)
Sorts a byte array, using @compare_func which should be a
qsort()-style comparison function (returns less than zero for first arg is less than second arg, zero for equal, greater than zero if first arg is greater than second arg). If two array elements compare equal, their order in the sorted array is undefined. If you want equal elements to keep their order (i.e. you want a stable sort) you can write a comparison function that, if two elements would otherwise compare equal, compares them by their addresses.
array is a byte array.compare_func is the comparison function.None.byte_array_sort_with_data (list array, object compare_func)
Like [func@GLib.ByteArray.sort], but the comparison function takes an extra user data argument.
array is a byte array.compare_func is the comparison function.user_data is the data to pass to @compare_func.None.byte_array_steal (list array)
Frees the data in the array and resets the size to zero, while the underlying array is preserved for use elsewhere and returned to the caller.
array is a byte array.len is the pointer to retrieve the number of elements of the original array.The allocated element data.byte_array_unref (list 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.
array is a byte array.None.canonicalize_filename (string filename, string relative_to)
Gets the canonical file name from @filename. All triple slashes are turned into single slashes, and all
..and.s resolved against
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. Ifis %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.filename is the name of the file.relative_to is the relative directory, or %NULL to use the current working directory.a newly allocated string with the canonical file path.chdir (string 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().
path is a pathname in the GLib file name encoding (UTF-8 on Windows).0 on success, -1 if an error occurred..check_version (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.)
required_major is the required major version.required_minor is the required minor version.required_micro is the required micro version.%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..checksum_type_get_length (string checksum_type)
Gets the length in bytes of digests of type @checksum_type
checksum_type is a #GChecksumType.the checksum length, or -1 if @checksum_type is not supported..chmod (string filename, int mode)
A wrapper for the POSIX chmod() function. The chmod() function is used to set the permissions of a file system object. On Windows the file protection mechanism is not at all POSIX-like, and the underlying chmod() function in the C library just sets or clears the FAT-style READONLY attribute. It does not touch any ACL. Software that needs to manage file permissions on Windows exactly should use the Win32 API. See your C library manual for more details about chmod().
filename is a pathname in the GLib file name encoding (UTF-8 on Windows).mode is as in chmod().0 if the operation succeeded, -1 on error.clear_error ()
If @err or
*erris %NULL, does nothing. Otherwise, calls g_error_free() on*errand sets*errto %NULL.
None.clear_handle_id (int tag_ptr, object clear_func)
Clears a numeric handler, such as a [struct@GLib.Source] ID. The @tag_ptr must be a valid pointer to the variable holding the handler. If the ID is zero then this function does nothing. Otherwise, @clear_func is called with the ID as a parameter, and the tag is set to zero. A macro is also included that allows this function to be used without pointer casts.
tag_ptr is a pointer to the handler ID.clear_func is the function to call to clear the handler.None.clear_list (list list_ptr, object destroy)
Clears a pointer to a #GList, freeing it and, optionally, freeing its elements using @destroy. @list_ptr must be a valid pointer. If @list_ptr points to a #GList, this does nothing.
list_ptr is a #GList return location.destroy is the function to pass to g_list_free_full() or %NULL to not free elements.None.clear_pointer (object destroy)
Clears a reference to a variable. @pp must not be %NULL. If the reference is %NULL then this function does nothing. Otherwise, the variable is destroyed using @destroy and the pointer is set to %NULL. A macro is also included that allows this function to be used without pointer casts. This will mask any warnings about incompatible function types or calling conventions, so you must ensure that your @destroy function is compatible with being called as [callback@GLib.DestroyNotify] using the standard calling convention for the platform that GLib was compiled for; otherwise the program will experience undefined behaviour. Examples of this kind of undefined behaviour include using many Windows Win32 APIs, as well as many if not all OpenGL and Vulkan calls on 32-bit Windows, which typically use the
__stdcallcalling convention rather than the__cdeclcalling convention. The affected functions can be used by wrapping them in a [callback@GLib.DestroyNotify] that is declared with the standard calling convention:c // Wrapper needed to avoid mismatched calling conventions on Windows static void destroy_sync (void *sync) { glDeleteSync (sync); } // … g_clear_pointer (&sync, destroy_sync);
pp is a pointer to a variable, struct member etc. holding a pointer.destroy is a function to which a gpointer can be passed, to destroy *pp.None.clear_slist (list slist_ptr, object destroy)
Clears a pointer to a #GSList, freeing it and, optionally, freeing its elements using @destroy. @slist_ptr must be a valid pointer. If
points to a #GSList, this does nothing.slist_ptr is a #GSList return location.destroy is the function to pass to g_slist_free_full() or %NULL to not free elements.None.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. In case of success, %errno is undefined. 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. It is a bug to call this function with an invalid file descriptor. On POSIX platforms since GLib 2.76, this function is async-signal safe if (and only if) @error is %NULL and @fd is a valid open file descriptor. This makes it safe to call from a signal handler or a #GSpawnChildSetupFunc under those conditions. See
signal(7)andsignal-safety(7)for more details.
fd is A file descriptor.%TRUE on success, %FALSE if there was an error..compute_checksum_for_bytes (string checksum_type, object 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.
checksum_type is a #GChecksumType.data is binary blob to compute the digest of.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..compute_checksum_for_data (string checksum_type, list data)
Computes the checksum for a binary @data of @length. 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.
checksum_type is a #GChecksumType.data is binary blob to compute the digest of.length is length of @data.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..compute_checksum_for_string (string checksum_type, string str, int length)
Computes the checksum of a string. The hexadecimal string returned will be in lower case.
checksum_type is a #GChecksumType.str is the string to compute the checksum of.length is the length of the string, or -1 if the string is null-terminated..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..compute_hmac_for_bytes (string digest_type, object key, object 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.
digest_type is a #GChecksumType to use for the HMAC.key is the key to use in the HMAC.data is binary blob to compute the HMAC of.the HMAC of the binary data as a string in hexadecimal. The returned string should be freed with g_free() when done using it..compute_hmac_for_data (string digest_type, list key, list data)
Computes the HMAC for a binary @data of @length. 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.
digest_type is a #GChecksumType to use for the HMAC.key is the key to use in the HMAC.key_len is the length of the key.data is binary blob to compute the HMAC of.length is length of @data.the HMAC of the binary data as a string in hexadecimal. The returned string should be freed with g_free() when done using it..compute_hmac_for_string (string digest_type, list key, string str, int length)
Computes the HMAC for a string. The hexadecimal string returned will be in lower case.
digest_type is a #GChecksumType to use for the HMAC.key is the key to use in the HMAC.key_len is the length of the key.str is the string to compute the HMAC for.length is the length of the string, or -1 if the string is nul-terminated.the HMAC as a hexadecimal string. The returned string should be freed with g_free() when done using it..cond_new ()
Allocates and initializes a new #GCond.
a newly allocated #GCond. Free with g_cond_free().convert (list str, string to_codeset, string from_codeset)
Converts a string from one character set to another. Note that you should use g_iconv() for streaming conversions. Despite the fact that
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.str is the string to convert..len is 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 is name of character set into which to convert @str.from_codeset is character set of @str..bytes_read is 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 is the number of bytes stored in the output buffer (not including the terminating nul)..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..convert_with_fallback (list str, string to_codeset, string from_codeset, string fallback)
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.)
str is the string to convert..len is 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 is name of character set into which to convert @str.from_codeset is character set of @str..fallback is 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 is 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 is the number of bytes stored in the output buffer (not including the terminating nul)..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..convert_with_iconv (list str, object converter)
Converts a string from one character set to another. Note that you should use g_iconv() for streaming conversions. Despite the fact that
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.) Characters which are valid in the input character set, but which have no representation in the output character set will result in a %G_CONVERT_ERROR_ILLEGAL_SEQUENCE error. This is in contrast to the iconv() specification, which leaves this behaviour implementation defined. Note that this is the same error code as is returned for an invalid byte sequence in the input character set. To get defined behaviour for conversion of unrepresentable characters, use g_convert_with_fallback().str is the string to convert..len is 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).converter is conversion descriptor from g_iconv_open().bytes_read is 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 is the number of bytes stored in the output buffer (not including the terminating nul)..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..creat (string filename, int mode)
A wrapper for the POSIX creat() function. The creat() function is used to convert a pathname into a file descriptor, creating a file if necessary. On POSIX systems file descriptors are implemented by the operating system. On Windows, it's the C library that implements creat() and file descriptors. The actual Windows API for opening files is different, see MSDN documentation for CreateFile(). The Win32 API uses file handles, which are more randomish integers, not small integers like file descriptors. Because file descriptors are specific to the C library on Windows, the file descriptor returned by this function makes sense only to functions in the same C library. Thus if the GLib-using code uses a different C library than GLib does, the file descriptor returned by this function cannot be passed to C library functions like write() or read(). See your C library manual for more details about creat().
filename is a pathname in the GLib file name encoding (UTF-8 on Windows).mode is as in creat().a new file descriptor, or -1 if an error occurred. The return value can be used exactly like the return value from creat()..datalist_clear (object datalist)
Frees all the data elements of the datalist. The data elements' destroy functions are called if they have been set.
datalist is a datalist..None.datalist_foreach (object datalist, object func)
Calls the given function for each data element of the datalist. The function is called with each data element's #GQuark id and data, together with the given @user_data parameter. Note that this function is NOT thread-safe. So unless @datalist can be protected from any modifications during invocation of this function, it should not be called. @func can make changes to @datalist, but the iteration will not reflect changes made during the g_datalist_foreach() call, other than skipping over elements that are removed.
datalist is a datalist..func is the function to call for each data element..user_data is user data to pass to the function..None.datalist_get_data (object datalist, string key)
Gets a data element, using its string identifier. This is slower than g_datalist_id_get_data() because it compares strings.
datalist is a datalist..key is the string identifying a data element..the data element, or %NULL if it is not found..datalist_get_flags (object datalist)
Gets flags values packed in together with the datalist. See g_datalist_set_flags().
datalist is pointer to the location that holds a list.the flags of the datalist.datalist_init (object datalist)
Resets the datalist to %NULL. It does not free any memory or call any destroy functions.
datalist is a pointer to a pointer to a datalist..None.datalist_set_flags (object datalist, int flags)
Turns on flag values for a data list. This function is used to keep a small number of boolean flags in an object with a data list without using any additional space. It is not generally useful except in circumstances where space is very tight. (It is used in the base #GObject type, for example.)
datalist is pointer to the location that holds a list.flags is the flags to turn on. The values of the flags are restricted by %G_DATALIST_FLAGS_MASK (currently 3; giving two possible boolean flags). A value for @flags that doesn't fit within the mask is an error..None.datalist_unset_flags (object datalist, int flags)
Turns off flag values for a data list. See g_datalist_unset_flags()
datalist is pointer to the location that holds a list.flags is the flags to turn off. The values of the flags are restricted by %G_DATALIST_FLAGS_MASK (currently 3: giving two possible boolean flags). A value for @flags that doesn't fit within the mask is an error..None.dataset_destroy (dataset_location)
Destroys the dataset, freeing all memory allocated, and calling any destroy functions set for data elements.
dataset_location is the location identifying the dataset..None.dataset_foreach (dataset_location, object func)
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
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.dataset_location is the location identifying the dataset..func is the function to call for each data element..user_data is user data to pass to the function..None.date_strftime (string s, int slen, string format, object date)
Generates a printed representation of the date, in a locale-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.
s is destination buffer.slen is buffer size.format is format string.date is valid #GDate.number of characters written to the buffer, or 0 if the buffer was too small.date_valid_julian (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.
julian_date is Julian day to check.%TRUE if the Julian day is valid.date_valid_month (string month)
Returns %TRUE if the month value is valid. The 12 #GDateMonth enumeration values are the only valid months.
month is month.%TRUE if the month is valid.date_valid_weekday (string weekday)
Returns %TRUE if the weekday is valid. The seven #GDateWeekday enumeration values are the only valid weekdays.
weekday is weekday.%TRUE if the weekday is valid.dcgettext (string domain, string 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.
domain is the translation domain to use, or %NULL to use the domain set with textdomain().msgid is message to translate.category is a locale category.the translated string for the given locale category.dgettext (string domain, string 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.
domain is the translation domain to use, or %NULL to use the domain set with textdomain().msgid is message to translate.The translated string.dir_make_tmp (string tmpl)
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.
tmpl is Template for directory name, as in g_mkdtemp(), basename only, or %NULL for a default template.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..direct_equal (v1, 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).
v1 is a key.v2 is a key to compare with @v1.%TRUE if the two keys match..direct_hash (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).
v is a #gpointer key.a hash value corresponding to the key..dngettext (string domain, string msgid, string msgid_plural, int 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.
domain is the translation domain to use, or %NULL to use the domain set with textdomain().msgid is message to translate.msgid_plural is plural form of the message.n is the quantity for which translation is needed.The translated string.double_equal (v1, 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
parameter, when using non-%NULL pointers to doubles as keys in a #GHashTable.v1 is a pointer to a #gdouble key.v2 is a pointer to a #gdouble key to compare with @v1.%TRUE if the two keys match..double_hash (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.
v is a pointer to a #gdouble key.a hash value corresponding to the key..dpgettext (string domain, string msgctxtid, int 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.
domain is the translation domain to use, or %NULL to use the domain set with textdomain().msgctxtid is a combined message context and message id, separated by a \004 character.msgidoffset is the offset of the message id in @msgctxid.The translated string.dpgettext2 (string domain, string context, string 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.
domain is the translation domain to use, or %NULL to use the domain set with textdomain().context is the message context.msgid is the message.The translated string.environ_getenv (list envp, string variable)
Returns the value of the environment variable @variable in the provided list @envp.
envp is an environment list (eg, as returned from g_get_environ()), or %NULL for an empty environment list.variable is the environment variable to get.the value of the environment variable, or %NULL if the environment variable is not set in @envp. The returned string is owned by @envp, and will be freed if @variable is set or unset again..environ_setenv (list envp, string variable, string value, bool overwrite)
Sets the environment variable @variable in the provided list @envp to
envp is an environment list that can be freed using g_strfreev() (e.g., as returned from g_get_environ()), or %NULL for an empty environment list.variable is the environment variable to set, must not contain '='.value is the value for to set the variable to.overwrite is whether to change the variable if it already exists.the updated environment list. Free it using g_strfreev()..environ_unsetenv (list envp, string variable)
Removes the environment variable @variable from the provided environment
envp is an environment list that can be freed using g_strfreev() (e.g., as returned from g_get_environ()), or %NULL for an empty environment list.variable is the environment variable to remove, must not contain '='.the updated environment list. Free it using g_strfreev()..file_error_from_errno (int err_no)
Gets a #GFileError constant based on the passed-in @err_no. For example, if you pass in
EEXISTthis function returns %G_FILE_ERROR_EXIST. Unlikeerrnovalues, 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.
err_no is an "errno" value.#GFileError corresponding to the given @err_no.file_get_contents (string filename)
Reads an entire file into allocated memory, with good error checking. If the call was successful, it returns %TRUE and sets @contents to the file contents and @length to the length of the file contents in bytes. The string stored in @contents will be nul-terminated, so for text files you can pass %NULL for the @length argument. 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. In the error case, @contents is set to %NULL and @length is set to zero.
filename is name of a file to read contents from, in the GLib file name encoding.contents is location to store an allocated string, use g_free() to free the returned string.length is location to store length in bytes of the contents, or %NULL.%TRUE on success, %FALSE if an error occurred.file_open_tmp (string tmpl)
Opens a file for writing 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_mkstemp() (and mkstemp()) @tmpl is not modified, and might thus be a read-only literal string. Upon success, and if @name_used is non-%NULL, the actual name used is returned in @name_used. This string should be freed with g_free() when not needed any longer. The returned name is in the GLib file name encoding.
tmpl is Template for file name, as in g_mkstemp(), basename only, or %NULL for a default template.name_used is location to store actual name used, or %NULL.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 @error will be set..file_read_link (string filename)
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. The returned string may also be a relative path. Use g_build_filename() to convert it to an absolute path: |[ g_autoptr(GError) local_error = NULL; g_autofree gchar *link_target = g_file_read_link ("/etc/localtime", &local_error); if (local_error != NULL) g_error ("Error reading link: %s", local_error->message); if (!g_path_is_absolute (link_target)) { g_autofree gchar *absolute_link_target = g_build_filename ("/etc", link_target, NULL); g_free (link_target); link_target = g_steal_pointer (&absolute_link_target); } ]|
filename is the symbolic link.A newly-allocated string with the contents of the symbolic link, or %NULL if an error occurred..file_set_contents (string filename, list contents)
Writes all of @contents to a file named @filename. This is a convenience wrapper around calling g_file_set_contents_full() with
flagsset toG_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_ONLY_EXISTINGandmodeset to0666.
filename is name of a file to write @contents to, in the GLib file name encoding.contents is string to write to the file.length is length of @contents, or -1 if @contents is a nul-terminated string.%TRUE on success, %FALSE if an error occurred.file_set_contents_full (string filename, list contents, string flags, int mode)
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, thefsync()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
Otherwise, the permissions of the existing file will remain unchanged.filename is name of a file to write @contents to, in the GLib file name encoding.contents is string to write to the file.length is length of @contents, or -1 if @contents is a nul-terminated string.flags is flags controlling the safety vs speed of the operation.mode is file mode, as passed to open(); typically this will be 0666.%TRUE on success, %FALSE if an error occurred.file_test (string filename, string 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, see TOCTOU. For example, you might think you could use %G_FILE_TEST_IS_SYMLINK to know whether it is safe to write to a file without being tricked into writing into a different location. It doesn't work! |[ // DON'T DO THIS if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK)) { fd = g_open (filename, O_WRONLY); // write to fd } // DO THIS INSTEAD fd = g_open (filename, O_WRONLY | O_NOFOLLOW | O_CLOEXEC); if (fd == -1) { // check error if (errno == ELOOP) // file is a symlink and can be ignored else // handle errors as before } else { // 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 thePATHEXTenvironment variable.
filename is a filename to test in the GLib file name encoding.test is bitfield of #GFileTest flags.whether a test was %TRUE.filename_display_basename (string 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.
filename is an absolute pathname in the GLib file name encoding.a newly allocated string containing a rendition of the basename of the filename in valid UTF-8.filename_display_name (string 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
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.filename is a pathname hopefully in the GLib file name encoding.a newly allocated string containing a rendition of the filename in valid UTF-8.filename_from_uri (string uri)
Converts an escaped ASCII-encoded URI to a local filename in the encoding used for filenames. Since GLib 2.78, the query string and fragment can be present in the URI, but are not part of the resulting filename. We take inspiration from https://url.spec.whatwg.org/#file-state, but we don't support the entire standard.
uri is a uri describing a filename (escaped, encoded in ASCII)..hostname is Location to store hostname for the URI. If there is no hostname in the URI, %NULL will be stored in this location..a newly-allocated string holding the resulting filename, or %NULL on an error..filename_from_utf8 (string utf8string, int len)
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. 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.
utf8string is a UTF-8 encoded string..len is the length of the string, or -1 if the string is nul-terminated..bytes_read is 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 is the number of bytes stored in the output buffer (not including the terminating nul)..The converted string, or %NULL on an error..filename_to_uri (string filename, string hostname)
Converts an absolute filename to an escaped ASCII-encoded URI, with the path component following Section 3.3. of RFC 2396.
filename is 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 is A UTF-8 encoded hostname, or %NULL for none..a newly-allocated string holding the resulting URI, or %NULL on an error..filename_to_utf8 (string opsysstring, int len)
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. 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.
opsysstring is a string in the encoding for filenames.len is 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 is 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 is the number of bytes stored in the output buffer (not including the terminating nul)..The converted string, or %NULL on an error..find_program_in_path (string 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
exists and is executable, and %NULL otherwise. On Windows, ifdoes 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.program is a program name in the GLib file name encoding.a newly-allocated string with the absolute path, or %NULL.fopen (string filename, string mode)
A wrapper for the stdio
fopen()function. Thefopen()function opens a file and associates a new stream with it. Because file descriptors are specific to the C library on Windows, and a file descriptor is part of theFILEstruct, theFILE*returned by this function makes sense only to functions in the same C library. Thus if the GLib-using code uses a different C library than GLib does, the FILE* returned by this function cannot be passed to C library functions likefprintf()orfread(). See your C library manual for more details aboutfopen(). Asclose()andfclose()are part of the C library, this implies that it is currently impossible to close a file if the application C library and the C library used by GLib are different. Convenience functions like g_file_set_contents_full() avoid this problem. Since GLib 2.86, theeoption is supported in @mode on all platforms. On Unix platforms it will setO_CLOEXECon the opened file descriptor. On Windows platforms it will be converted to theNmodifier. It is recommended to seteunconditionally, unless you know the returned file should be shared between this process and a new fork.
filename is a pathname in the GLib file name encoding (UTF-8 on Windows).mode is a string describing the mode in which the file should be opened.A FILE* if the file was successfully opened, or %NULL if an error occurred.format_size (int 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.
size is a size in bytes.a newly-allocated formatted string containing a human readable file size.format_size_for_display (int 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.1 MB". The prefix units base is 1024 (i.e. 1 KB is 1024 bytes). This string should be freed with g_free() when not needed any longer.
size is a size in bytes.a newly-allocated formatted string containing a human readable file size.format_size_full (int size, string flags)
Formats a size. This function is similar to g_format_size() but allows for flags that modify the output. See #GFormatSizeFlags.
size is a size in bytes.flags is #GFormatSizeFlags to modify the output.a newly-allocated formatted string containing a human readable file size.fprintf (file, string format, list varargs)
An implementation of the standard
fprintf()function which supports positional parameters, as specified in the Single Unix Specification.glib/gprintf.hmust be explicitly included in order to use this function.
file is the stream to write to.format is a standard printf() format string, but notice string precision pitfalls.... is the arguments to insert in the output.the number of bytes printed.free (mem)
Frees the memory pointed to by @mem. If you know the allocated size of
calling g_free_sized() may be faster, depending on the libc implementation in use. Starting from GLib 2.78, this may happen automatically in case a GCC compatible compiler is used with some optimization level and the allocated size is known at compile time (see documentation of __builtin_object_size() to understand its caveats). If @mem is %NULL it simply returns, so there is no need to check @mem against %NULL before calling this function.mem is the memory to free.None.free_sized (mem, int size)
Frees the memory pointed to by @mem, assuming it is has the given @size. If @mem is %NULL this is a no-op (and @size is ignored). It is an error if @size doesn’t match the size passed when @mem was allocated. @size is passed to this function to allow optimizations in the allocator. If you don’t know the allocation size, use g_free() instead. In case a GCC compatible compiler is used, this function may be used automatically via g_free() if the allocated size is known at compile time, since GLib 2.78.
mem is the memory to free.size is size of @mem, in bytes.None.freopen (string filename, string mode, stream)
A wrapper for the POSIX freopen() function. The freopen() function opens a file and associates it with an existing stream. See your C library manual for more details about freopen(). Since GLib 2.86, the
eoption is supported in @mode on all platforms. See the documentation for [func@GLib.fopen] for more details.
filename is a pathname in the GLib file name encoding (UTF-8 on Windows).mode is a string describing the mode in which the file should be opened.stream is an existing stream which will be reused, or %NULL.A FILE* if the file was successfully opened, or %NULL if an error occurred..fsync (int fd)
A wrapper for the POSIX
fsync()function. On Windows,_commit()will be used. On macOS,fcntl(F_FULLFSYNC)will be used. Thefsync()function is used to synchronize a file's in-core state with that of the disk. This wrapper will handle retrying onEINTR. See the C library manual for more details about fsync().
fd is a file descriptor.0 on success, or -1 if an error occurred. The return value can be used exactly like the return value from fsync()..get_application_name ()
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).
human-readable application name. May return %NULL.get_charset ()
Obtains the character set for the current locale; 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,LANGandCHARSETare queried in order. nl_langinfo() returns the C locale if no locale has been loaded by setlocale(). 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.
charset is return location for character set name, or %NULL..%TRUE if the returned charset is UTF-8.get_codeset ()
Gets the character set for the current locale.
a newly allocated string containing the name of the character set. This string must be freed with g_free()..get_console_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.
charset is return location for character set name, or %NULL..%TRUE if the returned charset is UTF-8.get_current_dir ()
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.
the current directory.get_current_time (object result)
Queries the system wall-clock time. This is equivalent to the UNIX
gettimeofday()function, but portable. You may find [func@GLib.get_real_time] to be more convenient.
result is [struct@GLib.TimeVal] structure in which to store current time.None.get_environ ()
Gets the list of environment variables for the current process. The list is %NULL terminated and each item in the list is of the form 'NAME=VALUE'. This is equivalent to direct access to the 'environ' global variable, except portable. The return value is freshly allocated and it should be freed with g_strfreev() when it is no longer needed.
the list of environment variables.get_filename_charsets ()
Determines the preferred character sets used for filenames. The first character set from the @charsets is the filename encoding, the subsequent character sets are used when trying to generate a displayable representation of a filename, see g_filename_display_name(). On Unix, the character sets are determined by consulting the environment variables
G_FILENAME_ENCODINGandG_BROKEN_FILENAMES. On Windows, the character set used in the GLib API is always UTF-8 and said environment variables have no effect.G_FILENAME_ENCODINGmay be set to a comma-separated list of character set names. The special token@localeis taken to mean the character set for the current locale. IfG_FILENAME_ENCODINGis not set, butG_BROKEN_FILENAMESis, the character set of the current locale is taken as the filename encoding. If neither environment variable is set, UTF-8 is taken as the filename encoding, but the character set of the current locale is also put in the list of encodings. The returned @charsets belong to GLib and must not be freed. Note that on Unix, regardless of the locale character set orG_FILENAME_ENCODINGvalue, the actual file names present on a system might be in any random encoding or just gibberish.
filename_charsets is return location for the %NULL-terminated list of encoding names.%TRUE if the filename encoding is UTF-8..get_home_dir ()
Gets the current user's home directory. As with most UNIX tools, this function will return the value of the
HOMEenvironment variable if it is set to an existing absolute path name, falling back to thepasswdfile in the case that it is unset. If the path given inHOMEis non-absolute, does not exist, or is not a directory, the result is undefined. Before version 2.36 this function would ignore theHOMEenvironment variable, taking the value from thepasswddatabase 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 theHOMEenvironment variable yourself or unset it before calling any functions in GLib.
the current user's home directory.get_host_name ()
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.
the host name of the machine..get_language_names ()
Computes a list of applicable locale names, which can be used to e.g. construct locale-dependent filenames or search paths. The returned list is sorted from most desirable to least desirable and always contains the default locale "C". For example, if LANGUAGE=de:en_US, then the returned list is "de", "en_US", "en", "C". This function consults the environment variables
LANGUAGE,LC_ALL,LC_MESSAGESandLANGto find the list of locales specified by the user.
a %NULL-terminated array of strings owned by GLib that must not be modified or freed..get_language_names_with_category (string category_name)
Computes a list of applicable locale names with a locale category name, which can be used to construct the fallback locale-dependent filenames or search paths. The returned list is sorted from most desirable to least desirable and always contains the default locale "C". This function consults the environment variables
LANGUAGE,LC_ALL, @category_name, andLANGto find the list of locales specified by the user. g_get_language_names() returns g_get_language_names_with_category("LC_MESSAGES").
category_name is a locale category name.a %NULL-terminated array of strings owned by the thread g_get_language_names_with_category was called from. It must not be modified or freed. It must be copied if planned to be used in another thread..get_locale_variants (string locale)
Returns a list of derived variants of @locale, which can be used to e.g. construct locale-dependent filenames or search paths. The returned list is sorted from most desirable to least desirable. This function handles territory, charset and extra locale modifiers. See
setlocale(3)for information about locales and their format. @locale itself is guaranteed to be returned in the output. For example, if @locale isfr_BE, then the returned list isfr_BE,fr. If @locale isen_GB.UTF-8@euro, then the returned list isen_GB.UTF-8@euro,en_GB.UTF-8,en_GB@euro,en_GB,en.UTF-8@euro,en.UTF-8,en@euro,en. If you need the list of variants for the current locale, use g_get_language_names().
locale is a locale identifier.a newly allocated array of newly allocated strings with the locale variants. Free with g_strfreev()..get_monotonic_time ()
Queries the system monotonic time in microseconds. 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. A more accurate version of this function exists. [func@GLib.get_monotonic_time_ns] returns the time in nanoseconds.
the monotonic time, in microseconds.get_monotonic_time_ns ()
Queries the system monotonic time in nanoseconds. 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. Another version of this function exists. [func@GLib.get_monotonic_time] returns the time in microseconds. If you want to support older GLib versions, it is an alternative.
the monotonic time, in nanoseconds.get_num_processors ()
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.
Number of schedulable threads, always greater than 0.get_os_info (string key_name)
Get information about the operating system. On Linux this comes from the
/etc/os-releasefile. 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-releaseprovides 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.
key_name is a key for the OS info being requested, for example %G_OS_INFO_KEY_NAME..The associated value for the requested key or %NULL if this information is not provided..get_prgname ()
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].
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..get_real_name ()
Gets the real name of the user. This usually comes from the user's entry in the
passwdfile. 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.
the user's real name..get_real_time ()
Queries the system wall-clock time. This is equivalent to the UNIX
gettimeofday()function, but portable. You should only use this call if you are actually interested in the real wall-clock time. [func@GLib.get_monotonic_time] is probably more useful for measuring intervals.
the number of microseconds since January 1, 1970 UTC.get_system_config_dirs ()
Returns an ordered list of base directories in which to access system-wide configuration information. On UNIX platforms this is determined using the mechanisms described in the XDG Base Directory Specification. In this case the list of directories retrieved will be
XDG_CONFIG_DIRS. On Windows it follows XDG Base Directory Specification ifXDG_CONFIG_DIRSis defined. IfXDG_CONFIG_DIRSis undefined, the directory that contains application data for all users is used instead. A typical path isC:\Documents and Settings\All Users\Application Data. This folder is used for application data that is not user specific. For example, an application can store a spell-check dictionary, a database of clip art, or a log file in the FOLDERID_ProgramData folder. This information will not roam and is available to anyone using the computer. 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.
a %NULL-terminated array of strings owned by GLib that must not be modified or freed..get_system_data_dirs ()
Returns an ordered list of base directories in which to access system-wide application data. On UNIX platforms this is determined using the mechanisms described in the XDG Base Directory Specification In this case the list of directories retrieved will be
XDG_DATA_DIRS. On Windows it follows XDG Base Directory Specification ifXDG_DATA_DIRSis defined. IfXDG_DATA_DIRSis undefined, the first elements in the list are the Application Data and Documents folders for All Users. (These can be determined only on Windows 2000 or later and are not present in the list on other Windows versions.) See documentation for FOLDERID_ProgramData and FOLDERID_PublicDocuments. Then follows the "share" subfolder in the installation folder for the package containing the DLL that calls this function, if it can be determined. Finally the list contains the "share" subfolder in the installation folder for GLib, and in the installation folder for the package the application's .exe file belongs to. The installation folders above are determined by looking up the folder where the module (DLL or EXE) in question is located. If the folder's name is "bin", its parent is used, otherwise the folder itself. Note that on Windows the returned list can vary depending on where this function is called. 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.
a %NULL-terminated array of strings owned by GLib that must not be modified or freed..get_tmp_dir ()
Gets the directory to use for temporary files. On UNIX, this is taken from the
TMPDIRenvironment variable. If the variable is not set,P_tmpdiris used, as defined by the system C library. Failing that, a hard-coded default of "/tmp" is returned. On Windows, theTEMPenvironment 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.
the directory to use for temporary files..get_user_cache_dir ()
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. In this case the directory retrieved will be
XDG_CACHE_HOME. On Windows it follows XDG Base Directory Specification ifXDG_CACHE_HOMEis defined. IfXDG_CACHE_HOMEis undefined, the directory that serves as a common repository for temporary Internet files is used instead. A typical path isC:\Documents and Settings\username\Local Settings\Temporary Internet Files. See the documentation forFOLDERID_InternetCache. 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.
a string owned by GLib that must not be modified or freed..get_user_config_dir ()
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. In this case the directory retrieved will be
XDG_CONFIG_HOME. On Windows it follows XDG Base Directory Specification ifXDG_CONFIG_HOMEis defined. IfXDG_CONFIG_HOMEis undefined, the folder to use for local (as opposed to roaming) application data is used instead. See the documentation forFOLDERID_LocalAppData. 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.
a string owned by GLib that must not be modified or freed..get_user_data_dir ()
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. In this case the directory retrieved will be
XDG_DATA_HOME. On Windows it follows XDG Base Directory Specification ifXDG_DATA_HOMEis defined. IfXDG_DATA_HOMEis undefined, the folder to use for local (as opposed to roaming) application data is used instead. See the documentation forFOLDERID_LocalAppData. 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.
a string owned by GLib that must not be modified or freed..get_user_name ()
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.
the user name of the current user..get_user_runtime_dir ()
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. This is the directory specified in the
XDG_RUNTIME_DIRenvironment 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.
a string owned by GLib that must not be modified or freed..get_user_special_dir (string 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/Desktopwhen 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.
directory is the logical id of special directory.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..get_user_state_dir ()
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. In this case the directory retrieved will be
XDG_STATE_HOME. On Windows it follows XDG Base Directory Specification ifXDG_STATE_HOMEis defined. IfXDG_STATE_HOMEis undefined, the folder to use for local (as opposed to roaming) application data is used instead. See the documentation forFOLDERID_LocalAppData. 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.
a string owned by GLib that must not be modified or freed..getenv (string 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.
variable is the environment variable to get.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()..hash_table_add (object hash_table, 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
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.hash_table is a #GHashTable.key is a key to insert.%TRUE if the key did not exist yet.hash_table_contains (object hash_table, key)
Checks if @key is in @hash_table.
hash_table is a #GHashTable.key is a key to check.%TRUE if @key is in @hash_table, %FALSE otherwise..hash_table_destroy (object 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.
hash_table is a #GHashTable.None.hash_table_find (object hash_table, object predicate)
Calls the given function for key/value pairs in the #GHashTable until
returns %TRUE. The function is passed the key and value of each pair, and the given @user_data parameter. The hash table may not be modified while iterating over it (you can't add/remove items). Note, that hash tables are really only optimized for forward lookups, i.e. g_hash_table_lookup(). So code that frequently issues g_hash_table_find() or g_hash_table_foreach() (e.g. in the order of once per every entry in a hash table) should probably be reworked to use additional or different data structures for reverse lookups (keep in mind that an O(n) find/foreach operation issued for all n values in a hash table ends up needing O(n*n) operations).hash_table is a #GHashTable.predicate is function to test the key/value pairs for a certain property.user_data is user data to pass to the function.The value of the first key/value pair is returned, for whichevaluates to %TRUE. If no pair with the requested property is found, %NULL is returned..hash_table_foreach (object hash_table, object func)
Calls the given function for each of the key/value pairs in the #GHashTable. The function is passed the key and value of each pair, and the given @user_data parameter. The hash table may not be modified while iterating over it (you can't add/remove items). To remove all items matching a predicate, use g_hash_table_foreach_remove(). The order in which g_hash_table_foreach() iterates over the keys/values in the hash table is not defined. See g_hash_table_find() for performance caveats for linear order searches in contrast to g_hash_table_lookup().
hash_table is a #GHashTable.func is the function to call for each key/value pair.user_data is user data to pass to the function.None.hash_table_foreach_remove (object hash_table, object func)
Calls the given function for each key/value pair in the #GHashTable. If the function returns %TRUE, then the key/value pair is removed from the #GHashTable. If you supplied key or value destroy functions when creating the #GHashTable, they are used to free the memory allocated for the removed keys and values. See #GHashTableIter for an alternative way to loop over the key/value pairs in the hash table.
hash_table is a #GHashTable.func is the function to call for each key/value pair.user_data is user data to pass to the function.the number of key/value pairs removed.hash_table_foreach_steal (object hash_table, object func)
Calls the given function for each key/value pair in the #GHashTable. If the function returns %TRUE, then the key/value pair is removed from the #GHashTable, but no key or value destroy functions are called. See #GHashTableIter for an alternative way to loop over the key/value pairs in the hash table.
hash_table is a #GHashTable.func is the function to call for each key/value pair.user_data is user data to pass to the function.the number of key/value pairs removed..hash_table_get_keys_as_ptr_array (object hash_table)
Retrieves every key inside @hash_table, as a #GPtrArray. The returned data is valid until changes to the hash release those keys. This iterates over every entry in the hash table to build its return value. To iterate over the entries in a #GHashTable more efficiently, use a #GHashTableIter. You should always unref the returned array with g_ptr_array_unref().
hash_table is a #GHashTable.a #GPtrArray containing each key from the table. Unref with g_ptr_array_unref() when done..hash_table_get_values_as_ptr_array (object hash_table)
Retrieves every value inside @hash_table, as a #GPtrArray. The returned data is valid until changes to the hash release those values. This iterates over every entry in the hash table to build its return value. To iterate over the entries in a #GHashTable more efficiently, use a #GHashTableIter. You should always unref the returned array with g_ptr_array_unref().
hash_table is a #GHashTable.a #GPtrArray containing each value from the table. Unref with g_ptr_array_unref() when done..hash_table_insert (object hash_table, key, 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.
hash_table is a #GHashTable.key is a key to insert.value is the value to associate with the key.%TRUE if the key did not exist yet.hash_table_lookup (object hash_table, 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().
hash_table is a #GHashTable.key is the key to look up.the associated value, or %NULL if the key is not found.hash_table_lookup_extended (object hash_table, lookup_key)
Looks up a key in the #GHashTable, returning the original key and the associated value and a #gboolean which is %TRUE if the key was found. This is useful if you need to free the memory allocated for the original key, for example before calling g_hash_table_remove(). You can actually pass %NULL for @lookup_key to test whether the %NULL key exists, provided the hash and equal functions of @hash_table are %NULL-safe.
hash_table is a #GHashTable.lookup_key is the key to look up.orig_key is return location for the original key.value is return location for the value associated with the key.%TRUE if the key was found in the #GHashTable.hash_table_new_similar (object 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
The returned hash table will be empty; it will not contain the keys or values from @other_hash_table.other_hash_table is Another #GHashTable.a new #GHashTable.hash_table_ref (object hash_table)
Atomically increments the reference count of @hash_table by one. This function is MT-safe and may be called from any thread.
hash_table is a valid #GHashTable.the passed in #GHashTable.hash_table_remove (object hash_table, 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.
hash_table is a #GHashTable.key is the key to remove.%TRUE if the key was found and removed from the #GHashTable.hash_table_remove_all (object 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.
hash_table is a #GHashTable.None.hash_table_replace (object hash_table, key, 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
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.hash_table is a #GHashTable.key is a key to insert.value is the value to associate with the key.%TRUE if the key did not exist yet.hash_table_size (object hash_table)
Returns the number of elements contained in the #GHashTable.
hash_table is a #GHashTable.the number of key/value pairs in the #GHashTable..hash_table_steal (object hash_table, key)
Removes a key and its associated value from a #GHashTable without calling the key and value destroy functions.
hash_table is a #GHashTable.key is the key to remove.%TRUE if the key was found and removed from the #GHashTable.hash_table_steal_all (object hash_table)
Removes all keys and their associated values from a #GHashTable without calling the key and value destroy functions.
hash_table is a #GHashTable.None.hash_table_steal_all_keys (object hash_table)
Removes all keys and their associated values from a #GHashTable without calling the key destroy functions, returning the keys as a #GPtrArray with the free func set to the @hash_table key destroy function.
hash_table is a #GHashTable.a #GPtrArray containing each key of the table. Unref with g_ptr_array_unref() when done..hash_table_steal_all_values (object hash_table)
Removes all keys and their associated values from a #GHashTable without calling the value destroy functions, returning the values as a #GPtrArray with the free func set to the @hash_table value destroy function.
hash_table is a #GHashTable.a #GPtrArray containing each value of the table. Unref with g_ptr_array_unref() when done..hash_table_steal_extended (object hash_table, lookup_key)
Looks up a key in the #GHashTable, stealing the original key and the associated value and returning %TRUE if the key was found. If the key was not found, %FALSE is returned. If found, the stolen key and value are removed from the hash table without calling the key and value destroy functions, and ownership is transferred to the caller of this method, as with g_hash_table_steal(). That is the case regardless whether
or @stolen_value output parameters are requested. You can pass %NULL for @lookup_key, provided the hash and equal functions ofare %NULL-safe. The dictionary implementation optimizes for having all values identical to their keys, for example by using g_hash_table_add(). Before 2.82, when stealing both the key and the value from such a dictionary, the value was %NULL. Since 2.82, the returned value and key will be the same.hash_table is a #GHashTable.lookup_key is the key to look up.stolen_key is return location for the original key.stolen_value is return location for the value associated with the key.%TRUE if the key was found in the #GHashTable.hash_table_unref (object 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.
hash_table is a valid #GHashTable.None.hook_destroy (object hook_list, int hook_id)
Destroys a #GHook, given its ID.
hook_list is a #GHookList.hook_id is a hook ID.%TRUE if the #GHook was found in the #GHookList and destroyed.hook_destroy_link (object hook_list, object hook)
Removes one #GHook from a #GHookList, marking it inactive and calling g_hook_unref() on it.
hook_list is a #GHookList.hook is the #GHook to remove.None.hook_free (object hook_list, object hook)
Calls the #GHookList @finalize_hook function if it exists, and frees the memory allocated for the #GHook.
hook_list is a #GHookList.hook is the #GHook to free.None.hook_insert_before (object hook_list, object sibling, object hook)
Inserts a #GHook into a #GHookList, before a given #GHook.
hook_list is a #GHookList.sibling is the #GHook to insert the new #GHook before.hook is the #GHook to insert.None.hook_insert_sorted (object hook_list, object hook, object func)
Inserts a #GHook into a #GHookList, sorted by the given function.
hook_list is a #GHookList.hook is the #GHook to insert.func is the comparison function used to sort the #GHook elements.None.hook_prepend (object hook_list, object hook)
Prepends a #GHook on the start of a #GHookList.
hook_list is a #GHookList.hook is the #GHook to add to the start of @hook_list.None.hook_unref (object hook_list, object 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.
hook_list is a #GHookList.hook is the #GHook to unref.None.hostname_is_ascii_encoded (string 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.
hostname is a hostname.%TRUE if @hostname contains any ASCII-encoded segments..hostname_is_ip_address (string 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).
hostname is a hostname (or IP address in string form).%TRUE if @hostname is an IP address.hostname_is_non_ascii (string 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.
hostname is a hostname.%TRUE if @hostname contains any non-ASCII characters.hostname_to_ascii (string hostname)
Converts @hostname to its canonical ASCII form; an ASCII-only string containing no uppercase letters and not ending with a trailing dot.
hostname is a valid UTF-8 or ASCII hostname.an ASCII hostname, which must be freed, or %NULL if @hostname is in some way invalid..hostname_to_unicode (string 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.
hostname is a valid UTF-8 or ASCII hostname.a UTF-8 hostname, which must be freed, or %NULL if @hostname is in some way invalid..iconv (object converter, string inbuf, int inbytes_left, string outbuf, int outbytes_left)
Same as the standard UNIX routine iconv(), but may be implemented via libiconv on UNIX flavors that lack a native implementation. GLib provides g_convert() and g_locale_to_utf8() which are likely more convenient than the raw iconv wrappers. Note that the behaviour of iconv() for characters which are valid in the input character set, but which have no representation in the output character set, is implementation defined. This function may return success (with a positive number of non-reversible conversions as replacement characters were used), or it may return -1 and set an error such as %EILSEQ, in such a situation. See
iconv(3posix)andiconv(3)for more details about behavior when an error occurs.
converter is conversion descriptor from g_iconv_open().inbuf is bytes to convert.inbytes_left is inout parameter, bytes remaining to convert in @inbuf.outbuf is converted output bytes.outbytes_left is inout parameter, bytes available to fill in @outbuf.count of non-reversible conversions, or -1 on error.iconv_open (string to_codeset, string from_codeset)
Same as the standard UNIX routine iconv_open(), but may be implemented via libiconv on UNIX flavors that lack a native implementation. GLib provides g_convert() and g_locale_to_utf8() which are likely more convenient than the raw iconv wrappers.
to_codeset is destination codeset.from_codeset is source codeset.a "conversion descriptor", or (GIConv)-1 if opening the converter failed..idle_add (object function)
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, [const@GLib.PRIORITY_DEFAULT_IDLE]. If the function returns [const@GLib.SOURCE_REMOVE] it is automatically removed from the list of event sources and will not be called again. See main loop memory management for details on how to handle the return value and memory management of @data. This internally creates a main loop source using [func@GLib.idle_source_new] and attaches it to the global [struct@GLib.MainContext] using [method@GLib.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.
function is function to call.data is data to pass to @function.the ID (greater than 0) of the event source.idle_add_full (int priority, object function)
Adds a function to be called whenever there are no higher priority events pending. If the function returns [const@GLib.SOURCE_REMOVE] it is automatically removed from the list of event sources and will not be called again. See main loop memory management for details on how to handle the return value and memory management of @data. This internally creates a main loop source using [func@GLib.idle_source_new] and attaches it to the global [struct@GLib.MainContext] using [method@GLib.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.
priority is the priority of the idle source; typically this will be in the range between [const@GLib.PRIORITY_DEFAULT_IDLE] and [const@GLib.PRIORITY_HIGH_IDLE].function is function to call.data is data to pass to @function.notify is function to call when the idle is removed.the ID (greater than 0) of the event source.idle_add_once (object function)
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, [const@GLib.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 [func@GLib.idle_add].
function is function to call.data is data to pass to @function.the ID (greater than 0) of the event source.idle_remove_by_data (data)
Removes the idle function with the given data.
data is the data for the idle source’s callback..true if an idle source was found and removed, false otherwise.idle_source_new ()
Creates a new idle source. The source will not initially be associated with any [struct@GLib.MainContext] and must be added to one with [method@GLib.Source.attach] before it will be executed. Note that the default priority for idle sources is [const@GLib.PRIORITY_DEFAULT_IDLE], as compared to other sources which have a default priority of [const@GLib.PRIORITY_DEFAULT].
the newly-created idle source.int64_equal (v1, 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
parameter, when using non-%NULL pointers to 64-bit integers as keys in a #GHashTable.v1 is a pointer to a #gint64 key.v2 is a pointer to a #gint64 key to compare with @v1.%TRUE if the two keys match..int64_hash (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.
v is a pointer to a #gint64 key.a hash value corresponding to the key..int_equal (v1, 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.
v1 is a pointer to a #gint key.v2 is a pointer to a #gint key to compare with @v1.%TRUE if the two keys match..int_hash (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.
v is a pointer to a #gint key.a hash value corresponding to the key..intern_static_string (string arg0String)
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
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++.string is a static string.a canonical representation for the string.intern_string (string arg0String)
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++.
string is a string.a canonical representation for the string.io_add_watch (object channel, string condition, object func)
Adds the #GIOChannel into the default main loop context with the default priority.
channel is a #GIOChannel.condition is the condition to watch for.func is the function to call when the condition is satisfied.user_data is user data to pass to @func.the event source id.io_add_watch_full (object channel, int priority, string condition, object func)
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.
channel is a #GIOChannel.priority is the priority of the #GIOChannel source.condition is the condition to watch for.func is the function to call when the condition is satisfied.user_data is user data to pass to @func.notify is the function to call when the source is removed.the event source id.io_channel_error_from_errno (int en)
Converts an
errnoerror number to a #GIOChannelError.
en is an errno error number, e.g. EINVAL.a #GIOChannelError error number, e.g. %G_IO_CHANNEL_ERROR_INVAL..io_create_watch (object channel, string condition)
Creates a #GSource that's dispatched when @condition is met for the given
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.channel is a #GIOChannel to watch.condition is conditions to watch for.a new #GSource.list_pop_allocator ()
Generated wrapper for GIR function
list_pop_allocator. Native symbol:g_list_pop_allocator.
None.list_push_allocator (object allocator)
Generated wrapper for GIR function
list_push_allocator. Native symbol:g_list_push_allocator.
None.listenv ()
Gets the names of all variables set in the environment. Programs that want to be portable to Windows should typically use this function and g_getenv() instead of using the environ array from the C library directly. On Windows, the strings in the environ array are in system codepage encoding, while in most of the typical use cases for environment variables in GLib-using programs you want the UTF-8 encoding that this function and g_getenv() provide.
a %NULL-terminated list of strings which must be freed with g_strfreev()..locale_from_utf8 (string utf8string, int len)
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. On Windows this means the system codepage. The input string shall not contain nul characters even if the
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.utf8string is a UTF-8 encoded string.len is the length of the string, or -1 if the string is nul-terminated..bytes_read is 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 is the number of bytes stored in the output buffer (not including the terminating nul)..A newly-allocated buffer containing the converted string, or %NULL on an error, and error will be set..locale_to_utf8 (list opsysstring)
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 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.
opsysstring is a string in the encoding of the current locale. On Windows this means the system codepage..len is 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 is 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 is the number of bytes stored in the output buffer (not including the terminating nul)..The converted string, or %NULL on an error..log (string log_domain, string log_level, string format, list varargs)
Logs an error or debugging message. If the log level has been set as fatal, [func@GLib.BREAKPOINT] is called to terminate the program. See the documentation for [func@GLib.BREAKPOINT] for details of the debugging options this provides. If [func@GLib.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 this will output via the structured log writer function (see [func@GLib.log_set_writer_func]).
log_domain is the log domain, usually G_LOG_DOMAIN, or NULL for the default.log_level is the log level, either from [type@GLib.LogLevelFlags] or a user-defined level.format is the message format. See the printf() documentation.... is the parameters to insert into the format string.None.log_default_handler (string log_domain, string log_level, string message, unused_data)
The default log handler set up by GLib; [func@GLib.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
stderrorstdoutand if the log level is fatal it calls [func@GLib.BREAKPOINT]. It automatically prints a new-line character after the message, so one does not need to be manually included in
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. If you need to set the allowed domains at runtime, use [func@GLib.log_writer_default_set_debug_domains]. - DEBUG_INVOCATION: If set to 1, this is equivalent to G_MESSAGES_DEBUG=all. DEBUG_INVOCATION is a standard environment variable set by systemd to prompt debug output. (Since: 2.84) stderr is used for levels [flags@GLib.LogLevelFlags.LEVEL_ERROR], [flags@GLib.LogLevelFlags.LEVEL_CRITICAL], [flags@GLib.LogLevelFlags.LEVEL_WARNING] and [flags@GLib.LogLevelFlags.LEVEL_MESSAGE]. stdout is used for the rest, unless stderr was requested by [func@GLib.log_writer_default_set_use_stderr]. This has no effect if structured logging is enabled; see Using Structured Logging.log_domain is the log domain of the message, or NULL for the default "" application domain.log_level is the level of the message.message is the message.unused_data is data passed from [func@GLib.log] which is unused.None.log_get_always_fatal ()
Gets the current fatal mask. This is mostly used by custom log writers to make fatal messages (
fatal-warnings,fatal-criticals) work as expected, when using theG_DEBUGenvironment variable (see Running GLib Applications). An example usage is shown below:c static GLogWriterOutput my_custom_log_writer_fn (GLogLevelFlags log_level, const GLogField *fields, gsize n_fields, gpointer user_data) { // abort if the message was fatal if (log_level & g_log_get_always_fatal ()) g_abort (); // custom log handling code ... ... // success return G_LOG_WRITER_HANDLED; }
the current fatal mask.log_get_debug_enabled ()
Return whether debug output from the GLib logging system is enabled. Note that this should not be used to conditionalise calls to [func@GLib.debug] or other logging functions; it should only be used from [type@GLib.LogWriterFunc] implementations. Note also that the value of this does not depend on
G_MESSAGES_DEBUG, norDEBUG_INVOCATION, nor [func@GLib.log_writer_default_set_debug_domains]; see the docs for [func@GLib.log_set_debug_enabled].
TRUE if debug output is enabled, FALSE otherwise.log_remove_handler (string log_domain, int handler_id)
Removes the log handler. This has no effect if structured logging is enabled; see Using Structured Logging.
log_domain is the log domain.handler_id is the ID of the handler, which was returned in [func@GLib.log_set_handler].None.log_set_always_fatal (string 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. [flags@GLib.LogLevelFlags.LEVEL_ERROR] is always fatal. You can also make some message levels fatal at runtime by setting the
G_DEBUGenvironment variable (see Running GLib Applications). Libraries should not call this function, as it affects all messages logged by a process, including those from other libraries. Structured log messages (using [func@GLib.log_structured] and [func@GLib.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.
fatal_mask is the mask containing bits set for each level of error which is to be fatal.the old fatal mask.log_set_debug_enabled (bool enabled)
Enable or disable debug output from the GLib logging system for all domains. This value interacts disjunctively with
G_MESSAGES_DEBUG,DEBUG_INVOCATIONand [func@GLib.log_writer_default_set_debug_domains] — if any 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.
enabled is TRUE to enable debug output, FALSE otherwise.None.log_set_default_handler (object log_func)
Installs a default log handler which is used if no log handler has been set for the particular log domain and log level combination. By default, GLib uses [func@GLib.log_default_handler] as default log handler. This has no effect if structured logging is enabled; see Using Structured Logging.
log_func is the log handler function.user_data is data passed to the log handler.the previous default log handler.log_set_fatal_mask (string log_domain, string fatal_mask)
Sets the log levels which are fatal in the given domain. [flags@GLib.LogLevelFlags.LEVEL_ERROR] is always fatal. This has no effect on structured log messages (using [func@GLib.log_structured] or [func@GLib.log_structured_array]). To change the fatal behaviour for specific log messages, programs must install a custom log writer function using [func@GLib.log_set_writer_func]. See Using Structured Logging. This function is mostly intended to be used with [flags@GLib.LogLevelFlags.LEVEL_CRITICAL]. You should typically not set [flags@GLib.LogLevelFlags.LEVEL_WARNING], [flags@GLib.LogLevelFlags.LEVEL_MESSAGE], [flags@GLib.LogLevelFlags.LEVEL_INFO] or [flags@GLib.LogLevelFlags.LEVEL_DEBUG] as fatal except inside of test programs.
log_domain is the log domain.fatal_mask is the new fatal mask.the old fatal mask for the log domain.log_set_handler (string log_domain, string log_levels, object log_func)
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 [flags@GLib.LogLevelFlags.FLAG_FATAL] and [flags@GLib.LogLevelFlags.FLAG_RECURSION] bit flags. Note that since the [flags@GLib.LogLevelFlags.LEVEL_ERROR] log level is always fatal, if you want to set a handler for this log level you must combine it with [flags@GLib.LogLevelFlags.FLAG_FATAL]. This has no effect if structured logging is enabled; see Using Structured Logging. The
log_domainparameter can be set toNULLor an empty string to use the default application domain. Here is an example for adding a log handler for all warning messages in the default domain: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: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:c g_log_set_handler ("GLib", G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, my_log_handler, NULL);
log_domain is the log domain application domain.log_levels is the log levels to apply the log handler for. To handle fatal and recursive messages as well, combine the log levels with the [flags@GLib.LogLevelFlags.FLAG_FATAL] and [flags@GLib.LogLevelFlags.FLAG_RECURSION] bit flags..log_func is the log handler function.user_data is data passed to the log handler.the id of the new handler.log_set_handler_full (string log_domain, string log_levels, object log_func)
Like [func@GLib.log_set_handler], but takes a destroy notify for the
This has no effect if structured logging is enabled; see Using Structured Logging. The log_domain parameter can be set to NULL or an empty string to use the default application domain.log_domain is the log domain application domain.log_levels is the log levels to apply the log handler for. To handle fatal and recursive messages as well, combine the log levels with the [flags@GLib.LogLevelFlags.FLAG_FATAL] and [flags@GLib.LogLevelFlags.FLAG_RECURSION] bit flags..log_func is the log handler function.user_data is data passed to the log handler.destroy is destroy notify for @user_data, or NULL.the ID of the new handler.log_set_writer_func (object func)
Set a writer function which will be called to format and write out each log message. Each program should set a writer function, or the default writer ([func@GLib.log_writer_default]) will be used. Libraries must not call this function — only programs are allowed to install a writer function, as there must be a single, central point where log messages are formatted and outputted. There can only be one writer function. It is an error to set more than one.
func is log writer function, which must not be NULL.user_data is user data to pass to @func.user_data_free is function to free @user_data once it’s finished with, if non-NULL.None.log_structured (string log_domain, string log_level, list varargs)
Log a message with structured data. The message will be passed through to the log writer set by the application using [func@GLib.log_set_writer_func]. If the message is fatal (i.e. its log level is [flags@GLib.LogLevelFlags.LEVEL_ERROR]), the program will be aborted by calling [func@GLib.BREAKPOINT] at the end of this function. If the log writer returns [enum@GLib.LogWriterOutput.UNHANDLED] (failure), no other fallback writers will be tried. See the documentation for [type@GLib.LogWriterFunc] 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 [func@GLib.log_structured_array]. The keys for structured data should follow the systemd journal fields 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. Note that keys that expect UTF-8 strings (specifically"MESSAGE"and"GLIB_DOMAIN") must be passed as nul-terminated UTF-8 strings until GLib version 2.74.1 because the default log handler did not consider the length of theGLogField. Starting with GLib 2.74.1 this is fixed and non-nul-terminated UTF-8 strings can be passed with their correct length, with the exception of"GLIB_DOMAIN"which was only fixed with GLib 2.82.3. The @log_domain will be converted into aGLIB_DOMAINfield. @log_level will be converted into aPRIORITYfield. The format string will have its placeholders substituted for the provided values and be converted into aMESSAGEfield. Other fields you may commonly want to pass into this function: *MESSAGE_ID*CODE_FILE*CODE_LINE*CODE_FUNC*ERRNONote thatCODE_FILE,CODE_LINEandCODE_FUNCare automatically set by the logging macros, [func@GLib.DEBUG_HERE], [func@GLib.message], [func@GLib.warning], [func@GLib.critical], [func@GLib.error], etc, if the symbolG_LOG_USE_STRUCTUREDis defined before includingglib.h. For example: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 eachMESSAGE_IDmust be uniquely and randomly generated. If adding aMESSAGE_ID, consider shipping a message 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 [func@GLib.log_structured_array] and pass the pointer as a field withGLogField.lengthset to zero, otherwise it will be interpreted as a string. For example: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 aMESSAGEkey before the format string. TheMESSAGE-format pair has to be the last of the key-value pairs, andMESSAGEis the only field for whichprintf()-style formatting is supported. The default writer function forstdoutandstderrwill automatically append a new-line character after the message, so you should not add one manually to the format string.
log_domain is log domain, usually G_LOG_DOMAIN.log_level is log level, either from [type@GLib.LogLevelFlags], or a user-defined level.... is 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.None.log_structured_array (string log_level, list fields)
Log a message with structured data. The message will be passed through to the log writer set by the application using [func@GLib.log_set_writer_func]. If the message is fatal (i.e. its log level is [flags@GLib.LogLevelFlags.LEVEL_ERROR]), the program will be aborted at the end of this function. See [func@GLib.log_structured] for more documentation. This assumes that @log_level is already present in
(typically as the PRIORITY field).log_level is log level, either from [type@GLib.LogLevelFlags], or a user-defined level.fields is key–value pairs of structured data to add to the log message.n_fields is number of elements in the @fields array.None.log_structured_standard (string log_domain, string log_level, string file, string line, string func, string message_format, list varargs)
Generated wrapper for GIR function
log_structured_standard. Native symbol:g_log_structured_standard.
None.log_variant (string log_domain, string log_level, object fields)
Log a message with structured data, accepting the data within a [type@GLib.Variant]. 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 typeG_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 thanG_MAXSSIZE. Otherwise it will be truncated to this size. For other types [method@GLib.Variant.print] will be used to convert the value into a string. For more details on its usage and about the parameters, see [func@GLib.log_structured].
log_domain is log domain, usually G_LOG_DOMAIN.log_level is log level, either from [type@GLib.LogLevelFlags], or a user-defined level.fields is a dictionary ([type@GLib.Variant] of the type G_VARIANT_TYPE_VARDICT) containing the key-value pairs of message data..None.log_writer_default (string log_level, list fields, user_data)
Format a structured log message and output it to the default log destination for the platform. On Linux, this is typically the systemd journal, falling back to
stdoutorstderrif running from the terminal or if output is being redirected to a file. Support for other platform-specific logging mechanisms may be added in future. Distributors of GLib may modify this function to impose their own (documented) platform-specific log writing policies. This is suitable for use as a [type@GLib.LogWriterFunc], and is the default writer used if no other is set using [func@GLib.log_set_writer_func]. As with [func@GLib.log_default_handler], this function drops debug and informational messages unless their log domain (orall) is listed in the space-separatedG_MESSAGES_DEBUGenvironment variable, orDEBUG_INVOCATION=1is set in the environment, or set at runtime by [func@GLib.log_writer_default_set_debug_domains]. [func@GLib.log_writer_default] uses the mask set by [func@GLib.log_set_always_fatal] to determine which messages are fatal. When using a custom writer function instead it is up to the writer function to determine which log messages are fatal.
log_level is log level, either from [type@GLib.LogLevelFlags], or a user-defined level.fields is key–value pairs of structured data forming the log message.n_fields is number of elements in the @fields array.user_data is user data passed to [func@GLib.log_set_writer_func].[enum@GLib.LogWriterOutput.HANDLED] on success, [enum@GLib.LogWriterOutput.UNHANDLED] otherwise.log_writer_default_set_debug_domains (string domains)
Reset the list of domains to be logged, that might be initially set by the
G_MESSAGES_DEBUGorDEBUG_INVOCATIONenvironment variables. This function is thread-safe.
domains is NULL-terminated array with domains to be printed. NULL or an array with no values means none. Array with a single value "all" means all..None.log_writer_default_set_use_stderr (bool use_stderr)
Configure whether the built-in log functions will output all log messages to
stderr. The built-in log functions are [func@GLib.log_default_handler] for the old-style API, and both [func@GLib.log_writer_default] and [func@GLib.log_writer_standard_streams] for the structured API. By default, log messages of levels [flags@GLib.LogLevelFlags.LEVEL_INFO] and [flags@GLib.LogLevelFlags.LEVEL_DEBUG] are sent tostdout, and other log messages are sent tostderr. This is problematic for applications that intend to reservestdoutfor 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.
use_stderr is If TRUE, use stderr for log messages that would normally have appeared on stdout.None.log_writer_default_would_drop (string log_level, string log_domain)
Check whether [func@GLib.log_writer_default] and [func@GLib.log_default_handler] would ignore a message with the given domain and level. As with [func@GLib.log_default_handler], this function drops debug and informational messages unless their log domain (or
all) is listed in the space-separatedG_MESSAGES_DEBUGenvironment variable, orDEBUG_INVOCATION=1is set in the environment, or by [func@GLib.log_writer_default_set_debug_domains]. This can be used when implementing log writers with the same filtering behaviour as the default, but a different destination or output format: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` and `DEBUG_INVOCATION` are not set:c if (!g_log_writer_default_would_drop (G_LOG_LEVEL_DEBUG, G_LOG_DOMAIN)) { g_autofree gchar *result = expensive_computation (my_object); g_debug ("my_object result: %s", result); } ```
log_level is log level, either from [type@GLib.LogLevelFlags], or a user-defined level.log_domain is log domain.TRUE if the log message would be dropped by GLib’s default log handlers.log_writer_format_fields (string log_level, list fields, bool use_color)
Format a structured log message as a string suitable for outputting to the terminal (or elsewhere). This will include the values of all fields it knows how to interpret, which includes
MESSAGEandGLIB_DOMAIN(see the documentation for [func@GLib.log_structured]). It does not include values from unknown fields. The returned string does not have a trailing new-line character. It is encoded in the character set of the current locale, which is not necessarily UTF-8.
log_level is log level, either from [type@GLib.LogLevelFlags], or a user-defined level.fields is key–value pairs of structured data forming the log message.n_fields is number of elements in the @fields array.use_color is TRUE to use ANSI color escape sequences when formatting the message, FALSE to not.string containing the formatted log message, in the character set of the current locale.log_writer_is_journald (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
stdoutorstderr). Invalid file descriptors are accepted and returnFALSE, which allows for the following construct without needing any additional error handling:c is_journald = g_log_writer_is_journald (fileno (stderr));
output_fd is output file descriptor to check.TRUE if @output_fd points to the journal, FALSE otherwise.log_writer_journald (string log_level, list fields, user_data)
Format a structured log message and send it to the systemd journal as a set of key–value pairs. All fields are sent to the journal, but if a field has length zero (indicating program-specific data) then only its key will be sent. This is suitable for use as a [type@GLib.LogWriterFunc]. If GLib has been compiled without systemd support, this function is still defined, but will always return [enum@GLib.LogWriterOutput.UNHANDLED].
log_level is log level, either from [type@GLib.LogLevelFlags], or a user-defined level.fields is key–value pairs of structured data forming the log message.n_fields is number of elements in the @fields array.user_data is user data passed to [func@GLib.log_set_writer_func].[enum@GLib.LogWriterOutput.HANDLED] on success, [enum@GLib.LogWriterOutput.UNHANDLED] otherwise.log_writer_standard_streams (string log_level, list fields, user_data)
Format a structured log message and print it to either
stdoutorstderr, depending on its log level. [flags@GLib.LogLevelFlags.LEVEL_INFO] and [flags@GLib.LogLevelFlags.LEVEL_DEBUG] messages are sent tostdout, or tostderrif requested by [func@GLib.log_writer_default_set_use_stderr]; all other log levels are sent tostderr. Only fields which are understood by this function are included in the formatted string which is printed. If the output stream supports ANSI color escape sequences, they will be used in the output. A trailing new-line character is added to the log message when it is printed. This is suitable for use as a [type@GLib.LogWriterFunc].
log_level is log level, either from [type@GLib.LogLevelFlags], or a user-defined level.fields is key–value pairs of structured data forming the log message.n_fields is number of elements in the @fields array.user_data is user data passed to [func@GLib.log_set_writer_func].[enum@GLib.LogWriterOutput.HANDLED] on success, [enum@GLib.LogWriterOutput.UNHANDLED] otherwise.log_writer_supports_color (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.
output_fd is output file descriptor to check.TRUE if ANSI color escapes are supported, FALSE otherwise.log_writer_syslog (string log_level, list fields, user_data)
Format a structured log message and send it to the syslog daemon. Only fields which are understood by this function are included in the formatted string which is printed. Log facility will be defined via the SYSLOG_FACILITY field and accepts the following values: "auth", "daemon", and "user". If SYSLOG_FACILITY is not specified, LOG_USER facility will be used. This is suitable for use as a [type@GLib.LogWriterFunc]. If syslog is not supported, this function is still defined, but will always return [enum@GLib.LogWriterOutput.UNHANDLED].
log_level is log level, either from [type@GLib.LogLevelFlags], or a user-defined level.fields is key–value pairs of structured data forming the log message.n_fields is number of elements in the @fields array.user_data is user data passed to [func@GLib.log_set_writer_func].[enum@GLib.LogWriterOutput.HANDLED] on success, [enum@GLib.LogWriterOutput.UNHANDLED] otherwise.lstat (string filename, object buf)
A wrapper for the POSIX lstat() function. The lstat() function is like stat() except that in the case of symbolic links, it returns information about the symbolic link itself and not the file that it refers to. If the system does not support symbolic links g_lstat() is identical to g_stat(). See your C library manual for more details about lstat().
filename is a pathname in the GLib file name encoding (UTF-8 on Windows).buf is a pointer to a stat struct, which will be filled with the file information.0 if the information was successfully retrieved, -1 if an error occurred.main_context_default ()
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 [func@GLib.MainContext.get_thread_default].
the global-default main context..main_context_get_thread_default ()
Gets the thread-default main context 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 [func@GLib.MainContext.ref_thread_default] to get a [struct@GLib.MainContext] to add their [struct@GLib.Source]s 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
NULLif you are running in the default thread.) If you need to hold a reference on the context, use [func@GLib.MainContext.ref_thread_default] instead.
the thread-default main context, or NULL if the thread-default context is the global-default main context.main_context_ref_thread_default ()
Gets a reference to the thread-default [struct@GLib.MainContext] for this thread This is the same as [func@GLib.MainContext.get_thread_default], but it also adds a reference to the returned main context with [method@GLib.MainContext.ref]. In addition, unlike [func@GLib.MainContext.get_thread_default], if the thread-default context is the global-default context, this will return that [struct@GLib.MainContext] (with a ref added to it) rather than returning
NULL.
the thread-default main context.main_current_source ()
Returns the currently firing source for this thread.
the currently firing source, or NULL if none is firing.main_depth ()
Returns the depth of the stack of calls to [method@GLib.MainContext.dispatch] on any #GMainContext in the current thread. That is, when called from the top level, it gives
0. When called from within a callback from [method@GLib.MainContext.iteration] (or [method@GLib.MainLoop.run], etc.) it returns1. When called from within a callback to a recursive call to [method@GLib.MainContext.iteration], it returns2. And so forth. This function is useful in a situation like the following: Imagine an extremely simple ‘garbage collected’ system.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 tofree_allocated_memory(), but that doesn’t work, since the idle function could be called from a recursive callback. This can be fixed by using [func@GLib.main_depth]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 [func@GLib.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 [func@GLib.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. Usegtk_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.
the main loop recursion level in the current thread.malloc (int 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.
n_bytes is the number of bytes to allocate.a pointer to the allocated memory.malloc0 (int 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.
n_bytes is the number of bytes to allocate.a pointer to the allocated memory.malloc0_n (int n_blocks, int n_block_bytes)
This function is similar to g_malloc0(), allocating (@n_blocks *
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.n_blocks is the number of blocks to allocate.n_block_bytes is the size of each block in bytes.a pointer to the allocated memory.malloc_n (int n_blocks, int n_block_bytes)
This function is similar to g_malloc(), allocating (@n_blocks *
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.n_blocks is the number of blocks to allocate.n_block_bytes is the size of each block in bytes.a pointer to the allocated memory.markup_collect_attributes (string element_name, string attribute_names, string attribute_values, object error, string first_type, string first_attr, list varargs)
Collects the attributes of the element from the data passed to the #GMarkupParser start_element function, dealing with common error conditions and supporting boolean values. This utility function is not required to write a parser but can save a lot of typing. The
@attribute_names, @attribute_values and @error parameters passed to the start_element callback should be passed unmodified to this function. Following these arguments is a list of "supported" attributes to collect. It is an error to specify multiple attributes with the same name. If any attribute not in the list appears in the @attribute_names array then an unknown attribute error will result. The #GMarkupCollectType field allows specifying the type of collection to perform and if a given attribute must appear or is optional. The attribute name is simply the name of the attribute to collect. The pointer should be of the appropriate type (see the descriptions under #GMarkupCollectType) and may be %NULL in case a particular attribute is to be allowed but ignored. This function deals with issuing errors for missing attributes (of type %G_MARKUP_ERROR_MISSING_ATTRIBUTE), unknown attributes (of type %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE) and duplicate attributes (of type %G_MARKUP_ERROR_INVALID_CONTENT) as well as parse errors for boolean-valued attributes (again of type %G_MARKUP_ERROR_INVALID_CONTENT). In all of these cases %FALSE will be returned and @error will be set as appropriate.element_name is the current tag name.attribute_names is the attribute names.attribute_values is the attribute values.error is a pointer to a #GError or %NULL.first_type is the #GMarkupCollectType of the first attribute.first_attr is the name of the first attribute.... is a pointer to the storage location of the first attribute (or %NULL), followed by more types names and pointers, ending with %G_MARKUP_COLLECT_INVALID.%TRUE if successful.markup_escape_text (string text, int length)
Escapes text so that the markup parser will parse it verbatim. Less than, greater than, ampersand, etc. are replaced with the corresponding entities. This function would typically be used when writing out a file to be parsed with the markup parser. Note that this function doesn't protect whitespace and line endings from being processed according to the XML rules for normalization of line endings and attribute values. Note also that this function will produce character references in the range of ... for all control sequences except for tabstop, newline and carriage return. The character references in this range are not valid XML 1.0, but they are valid XML 1.1 and will be accepted by the GMarkup parser.
text is some valid UTF-8 text.length is length of @text in bytes, or -1 if the text is nul-terminated.a newly allocated string with the escaped text.markup_printf_escaped (string format, list varargs)
Formats arguments according to @format, escaping all string and character arguments in the fashion of g_markup_escape_text(). This is useful when you want to insert literal strings into XML-style markup output, without having to worry that the strings might themselves contain markup. |[ const char *store = "Fortnum & Mason"; const char *item = "Tea"; char *output; output = g_markup_printf_escaped ("
" " ", store, item); ]|%s " "- %s
" "
format is printf() style format string.... is the arguments to insert in the format string.newly allocated result from formatting operation. Free with g_free()..mem_chunk_info ()
Generated wrapper for GIR function
mem_chunk_info. Native symbol:g_mem_chunk_info.
None.mem_is_system_malloc ()
Checks whether the allocator used by g_malloc() is the system's malloc implementation. If it returns %TRUE memory allocated with malloc() can be used interchangeably with memory allocated using g_malloc(). This function is useful for avoiding an extra copy of allocated memory returned by a non-GLib-based API.
if %TRUE, malloc() and g_malloc() can be mixed..mem_profile ()
GLib used to support some tools for memory profiling, but this no longer works. There are many other useful tools for memory profiling these days which can be used instead.
None.mem_set_vtable (object vtable)
This function used to let you override the memory allocation function. However, its use was incompatible with the use of global constructors in GLib and GIO, because those use the GLib allocators before main is reached. Therefore this function is now deprecated and is just a stub.
vtable is table of memory allocation routines..None.memdup (mem, int byte_size)
Allocates @byte_size bytes of memory, and copies @byte_size bytes into it from @mem. If @mem is
NULLit returnsNULL.
mem is the memory to copy.byte_size is the number of bytes to copy.a pointer to the newly-allocated copy of the memory.memdup2 (mem, int byte_size)
Allocates @byte_size bytes of memory, and copies @byte_size bytes into it from @mem. If @mem is
NULLit returnsNULL. This replaces [func@GLib.memdup], which was prone to integer overflows when converting the argument from agsizeto aguint.
mem is the memory to copy.byte_size is the number of bytes to copy.a pointer to the newly-allocated copy of the memory.mkdir (string filename, int mode)
A wrapper for the POSIX mkdir() function. The mkdir() function attempts to create a directory with the given name and permissions. The mode argument is ignored on Windows. See your C library manual for more details about mkdir().
filename is a pathname in the GLib file name encoding (UTF-8 on Windows).mode is permissions to use for the newly created directory.0 if the directory was successfully created, -1 if an error occurred.mkdir_with_parents (string pathname, int mode)
Create a directory if it doesn't already exist. Create intermediate parent directories as needed, too.
pathname is a pathname in the GLib file name encoding.mode is permissions to use for newly created directories.0 if the directory already exists, or was successfully created. Returns -1 if an error occurred, with errno set..mkdtemp (string tmpl)
Creates a temporary directory in the current 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.
tmpl is template directory name.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..mkdtemp_full (string tmpl, int mode)
Creates a temporary directory in the current 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.
tmpl is template directory name.mode is permissions to create the temporary directory with.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 (string tmpl)
Opens a temporary file in the current directory. 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.
tmpl is template filename.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..mkstemp_full (string tmpl, int flags, int mode)
Opens a temporary file in the current directory. 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
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.tmpl is template filename.flags is flags to pass to an open() call in addition to O_EXCL and O_CREAT, which are passed automatically.mode is permissions to create the temporary file with.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..mutex_new ()
Allocates and initializes a new #GMutex.
a newly allocated #GMutex. Use g_mutex_free() to free.node_pop_allocator ()
Generated wrapper for GIR function
node_pop_allocator. Native symbol:g_node_pop_allocator.
None.node_push_allocator (object allocator)
Generated wrapper for GIR function
node_push_allocator. Native symbol:g_node_push_allocator.
None.nullify_pointer (nullify_location)
Set the pointer at the specified location to %NULL.
nullify_location is the memory address of the pointer..None.on_error_query (string prg_name)
Prompts the user with
[E]xit, [H]alt, show [S]tack trace or [P]roceed. This function is intended to be used for debugging use only. The following example shows how it can be used together with the g_log() functions. |[ #include <glib.h> static void log_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data) { g_log_default_handler (log_domain, log_level, message, user_data); g_on_error_query (MY_PROGRAM_NAME); } int main (int argc, char *argv[]) { g_log_set_handler (MY_LOG_DOMAIN, G_LOG_LEVEL_WARNING | G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL, log_handler, NULL); ... ]| If "[E]xit" is selected, the application terminates with a call to _exit(0). If "[S]tack" trace is selected, g_on_error_stack_trace() is called. This invokes gdb, which attaches to the current process and shows a stack trace. The prompt is then shown again. If "[P]roceed" is selected, the function returns. This function may cause different actions on non-UNIX platforms. On Windows consider using theG_DEBUGGERenvironment variable (see Running GLib Applications) and calling g_on_error_stack_trace() instead.
prg_name is 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).None.on_error_stack_trace (string 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_DEBUGGERenvironment variable is set, a debugger will be invoked to attach and handle that exception (see Running GLib Applications).
prg_name is the program name, needed by gdb for the "[S]tack trace" option, or NULL to use a default string.None.once_init_enter ()
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
it can be ensured that an initialization section will be executed only once during a program's life time, and that concurrent threads are blocked until initialization completed. To be used in constructs like this: |[ static gsize initialization_value = 0; if (g_once_init_enter (&initialization_value)) { gsize setup_value = 42; // initialization code here g_once_init_leave (&initialization_value, setup_value); } // use initialization_value here ]| While @location has a volatile qualifier, this is a historical artifact and the pointer passed to it should not be volatile.location is location of a static initializable variable containing 0.%TRUE if the initialization section should be entered, %FALSE and blocks otherwise.once_init_enter_impl (int location)
Generated wrapper for GIR function
once_init_enter_impl. Native symbol:g_once_init_enter_impl.
once_init_enter_pointer (location)
This functions behaves in the same way as g_once_init_enter(), but can can be used to initialize pointers (or #guintptr) instead of #gsize. |[ static MyStruct *interesting_struct = NULL; if (g_once_init_enter_pointer (&interesting_struct)) { MyStruct *setup_value = allocate_my_struct (); // initialization code here g_once_init_leave_pointer (&interesting_struct, g_steal_pointer (&setup_value)); } // use interesting_struct here ]|
location is location of a static initializable variable containing NULL.%TRUE if the initialization section should be entered, %FALSE and blocks otherwise.once_init_leave (int 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
volatilequalifier, this is a historical artifact and the pointer passed to it should not bevolatile.
location is location of a static initializable variable containing 0.result is new non-0 value for *value_location.None.once_init_leave_pointer (location, result)
Counterpart to g_once_init_enter_pointer(). Expects a location of a static
NULL-initialized initialization variable, and an initialization value other thanNULL. Sets the variable to the initialization value, and releases concurrent threads blocking in g_once_init_enter_pointer() on this initialization variable. This functions behaves in the same way as g_once_init_leave(), but can be used to initialize pointers (or #guintptr) instead of #gsize.
location is location of a static initializable variable containing NULL.result is new non-NULL value for *location.None.open (string filename, int flags, int mode)
A wrapper for the POSIX open() function. The open() function is used to convert a pathname into a file descriptor. On POSIX systems file descriptors are implemented by the operating system. On Windows, it's the C library that implements open() and file descriptors. The actual Win32 API for opening files is quite different, see MSDN documentation for CreateFile(). The Win32 API uses file handles, which are more randomish integers, not small integers like file descriptors. Because file descriptors are specific to the C library on Windows, the file descriptor returned by this function makes sense only to functions in the same C library. Thus if the GLib-using code uses a different C library than GLib does, the file descriptor returned by this function cannot be passed to C library functions like write() or read(). See your C library manual for more details about open().
filename is a pathname in the GLib file name encoding (UTF-8 on Windows).flags is as in open().mode is as in open().a new file descriptor, or -1 if an error occurred. The return value can be used exactly like the return value from open()..parse_debug_string (string arg0String, list keys)
Parses a string containing debugging options into a %guint containing bit flags. This is used within GDK and GTK to parse the debug options passed on the command line or through environment variables. If @string is equal to "all", all flags are set. Any flags specified along with "all" in
are inverted; thus, "all,foo,bar" or "foo,bar,all" sets all flags except those corresponding to "foo" and "bar". If @string is equal to "help", all the available keys in @keys are printed out to standard error.string is a list of debug options separated by colons, spaces, or commas, or %NULL..keys is pointer to an array of #GDebugKey which associate strings with bit flags..nkeys is the number of #GDebugKeys in the array..the combined set of bit flags..path_buf_equal (v1, v2)
Compares two path buffers for equality and returns
TRUEif they are equal. The paths inside the path buffers are not going to be normalized, soX/Y/Z/A/..,X/./Y/ZandX/Y/Zare not going to be considered equal. This function can be passed to g_hash_table_new() as thekey_equal_funcparameter.
v1 is a path buffer to compare.v2 is a path buffer to compare.TRUE if the two path buffers are equal, and FALSE otherwise.path_get_basename (string 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
consists only of directory separators (and on Windows, possibly a drive letter), a single separator is returned. If @file_name is empty, it gets ".".file_name is the name of the file.a newly allocated string containing the last component of the filename.path_get_dirname (string file_name)
Gets the directory components of a file name. For example, the directory component of
/usr/bin/testis/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.
file_name is the name of the file.the directory components of the file.path_is_absolute (string 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.
file_name is a file name.%TRUE if @file_name is absolute.path_skip_root (string 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.
file_name is a file name.a pointer into @file_name after the root component.pattern_match (object pspec, int string_length, string arg2String, string string_reversed)
Matches a string against a compiled pattern. Passing the correct length of the string given is mandatory. The reversed string can be omitted by passing
NULL, this is more efficient if the reversed version of the string to be matched is not at hand, asg_pattern_match()will only construct it if the compiled pattern requires reverse matches. Note that, if the user code will (possibly) match a string against a multitude of patterns containing wildcards, chances are high that some patterns will require a reversed string. In this case, it’s more efficient to provide the reversed string to avoid multiple constructions thereof in the various calls tog_pattern_match(). Note also that the reverse of a UTF-8 encoded string can in general not be obtained by [func@GLib.strreverse]. This works only if the string does not contain any multibyte characters. GLib offers the [func@GLib.utf8_strreverse] function to reverse UTF-8 encoded strings.
pspec is a #GPatternSpec.string_length is the length of @string (in bytes, i.e. strlen(), not [func@GLib.utf8_strlen]).string is the UTF-8 encoded string to match.string_reversed is the reverse of @string.%TRUE if @string matches @pspec.pattern_match_simple (string pattern, string arg1String)
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 [ctor@GLib.PatternSpec.new] and call [method@GLib.PatternSpec.match_string] repeatedly.
pattern is the UTF-8 encoded pattern.string is the UTF-8 encoded string to match.%TRUE if @string matches @pspec.pattern_match_string (object pspec, string arg1String)
Matches a string against a compiled pattern. If the string is to be matched against more than one pattern, consider using [method@GLib.PatternSpec.match] instead while supplying the reversed string.
pspec is a #GPatternSpec.string is the UTF-8 encoded string to match.%TRUE if @string matches @pspec.pointer_bit_lock (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
volatilequalifier, this is a historical artifact and the argument passed to it should not bevolatile.
address is a pointer to a #gpointer-sized value.lock_bit is a bit value between 0 and 31.None.pointer_bit_lock_and_get (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.
address is a pointer to a #gpointer-sized value.lock_bit is a bit value between 0 and 31.out_ptr is returns the set pointer atomically. This is the value after setting the lock, it thus always has the lock bit set, while previously @address had the lockbit unset. You may also use g_pointer_bit_lock_mask_ptr() to clear the lock bit..None.pointer_bit_lock_mask_ptr (ptr, int lock_bit, bool set, int preserve_mask, preserve_ptr)
This mangles @ptr as g_pointer_bit_lock() and g_pointer_bit_unlock() do.
ptr is the pointer to mask.lock_bit is the bit to set/clear. If set to G_MAXUINT, the lockbit is taken from @preserve_ptr or @ptr (depending on @preserve_mask)..set is whether to set (lock) the bit or unset (unlock). This has no effect, if @lock_bit is set to G_MAXUINT..preserve_mask is if non-zero, a bit-mask for @preserve_ptr. Thebits from @preserve_ptr are set in the result. Note that the @lock_bit bit will be always set according to @set, regardless of @preserve_mask and @preserve_ptr (unless @lock_bit is G_MAXUINT)..preserve_ptr is if @preserve_mask is non-zero, the bits from this pointer are set in the result..the mangled pointer..pointer_bit_trylock (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
volatilequalifier, this is a historical artifact and the argument passed to it should not bevolatile.
address is a pointer to a #gpointer-sized value.lock_bit is a bit value between 0 and 31.%TRUE if the lock was acquired.pointer_bit_unlock (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
volatilequalifier, this is a historical artifact and the argument passed to it should not bevolatile.
address is a pointer to a #gpointer-sized value.lock_bit is a bit value between 0 and 31.None.pointer_bit_unlock_and_set (address, int lock_bit, ptr, int preserve_mask)
This is equivalent to g_pointer_bit_unlock() and atomically setting the pointer value. Note that the lock bit will be cleared from the pointer. If the unlocked pointer that was set is not identical to @ptr, an assertion fails. In other words, @ptr must have @lock_bit unset. This also means, you usually can only use this on the lowest bits.
address is a pointer to a #gpointer-sized value.lock_bit is a bit value between 0 and 31.ptr is the new pointer value to set.preserve_mask is if non-zero, those bits of the current pointer inare preserved. Note that the @lock_bit bit will be always unset regardless of @ptr, @preserve_mask and the currently set value in @address..None.poll (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
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().fds is file descriptors to poll.nfds is the number of file descriptors in @fds.timeout is amount of time to wait, in milliseconds, or -1 to wait forever.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..prefix_error (string format, list varargs)
Formats a string according to @format and prefix it to an existing error message. If @err is %NULL (ie: no error variable) then do nothing. If
*erris %NULL (ie: an error variable is present but there is no error condition) then also do nothing.
err is a return location for a #GError.format is printf()-style format string.... is arguments to @format.None.prefix_error_literal (string prefix)
Prefixes @prefix to an existing error message. If @err or
*erris %NULL (i.e.: no error variable) then do nothing.
err is a return location for a #GError, or %NULL.prefix is string to prefix @err with.None.print (string format, list varargs)
Outputs a formatted message via the print handler. The default print handler outputs the encoded message to
stdout, without appending a trailing new-line character. Typically, @format should end with its own new-line character. This function 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 [func@GLib.log], [func@GLib.log_structured], or the convenience macros [func@GLib.message], [func@GLib.warning] and [func@GLib.error].
format is the message format. See the printf() documentation.... is the parameters to insert into the format string.None.printerr (string format, list varargs)
Outputs a formatted message via the error message handler. The default handler outputs the encoded message to
stderr, without appending a trailing new-line character. Typically, @format should end with its own new-line character. This function should not be used from within libraries. Instead [func@GLib.log] or [func@GLib.log_structured] should be used, or the convenience macros [func@GLib.message], [func@GLib.warning] and [func@GLib.error].
format is the message format. See the printf() documentation.... is the parameters to insert into the format string.None.printf (string format, list varargs)
An implementation of the standard
printf()function which supports positional parameters, as specified in the Single Unix Specification. As with the standardprintf(), 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.hmust be explicitly included in order to use this function.
format is a standard printf() format string, but notice string precision pitfalls.... is the arguments to insert in the output.the number of bytes printed.private_new (object notify)
Creates a new #GPrivate.
notify is a #GDestroyNotify.a newly allocated #GPrivate (which can never be destroyed).propagate_error (object src)
If @dest is %NULL, free @src; otherwise, moves @src into
*dest. The error variable @dest points to must be %NULL. @src must be non-%NULL. Note that @src is no longer valid after this call. If you want to keep using the same GError*, you need to set it to %NULL after calling this function on it.
dest is error return location.src is error to move into the return location.None.propagate_prefixed_error (object dest, object src, string format, list varargs)
If @dest is %NULL, free @src; otherwise, moves @src into
*dest.*destmust be %NULL. After the move, add a prefix as with g_prefix_error().
dest is error return location.src is error to move into the return location.format is printf()-style format string.... is arguments to @format.None.ptr_array_find (haystack, needle)
Checks whether @needle exists in @haystack. If the element is found, true is returned and the element’s index is returned in @index_ (if non-
NULL). Otherwise, false is returned and @index_ is undefined. If
exists multiple times in @haystack, the index of the first instance is returned. This does pointer comparisons only. If you want to use more complex equality checks, such as string comparisons, use [func@GLib.PtrArray.find_with_equal_func].haystack is the pointer array to be searched.needle is the pointer to look for.index_ is the return location for the index of the element, if found.true if @needle is one of the elements of @haystack; false otherwise.ptr_array_find_with_equal_func (haystack, needle, object equal_func)
Checks whether @needle exists in @haystack, using the given @equal_func. If the element is found, true is returned and the element’s index is returned in @index_ (if non-
NULL). Otherwise, false is returned and
is undefined. If @needle exists multiple times in @haystack, the index of the first instance is returned. @equal_func is called with the element from the array as its first parameter, and @needle as its second parameter. If @equal_func is NULL, pointer equality is used.haystack is the pointer array to be searched.needle is the pointer to look for.equal_func is the function to call for each element, which should return true when the desired element is found; or NULL to use pointer equality.index_ is the return location for the index of the element, if found.true if @needle is one of the elements of @haystack; false otherwise.ptr_array_new_from_array (data, int len, object copy_func)
Creates a new
GPtrArray, copying @len pointers from @data, and setting the array’s reference count to 1. This avoids having to manually add each element one by one. If @copy_func is provided, then it is used to copy each element before adding them to the new array. If it isNULLthen the pointers are copied directly. It also sets @element_free_func for freeing each element when the array is destroyed either via [func@GLib.PtrArray.unref], when [func@GLib.PtrArray.free] is called with
set to true or when removing elements. Do not use it ifis greater than G_MAXUINT. GPtrArray stores the length of its data in guint, which may be shorter than gsize.data is an array of pointers.len is the number of pointers in @data.copy_func is a copy function used to copy every element in the array.copy_func_user_data is the user data passed to @copy_func.element_free_func is a function to free elements on @array destruction.The new GPtrArray.ptr_array_new_from_null_terminated_array (data, object copy_func)
Creates a new
GPtrArraycopying the pointers from @data after having computed the length of it and with a reference count of 1. This avoids having to manually add each element one by one. If @copy_func is provided, then it is used to copy the data in the new array. It also sets
for freeing each element when the array is destroyed either via [func@GLib.PtrArray.unref], when [func@GLib.PtrArray.free] is called with @free_segment set to true or when removing elements. Do not use it if the @data has more than G_MAXUINT elements. GPtrArray stores the length of its data in guint, which may be shorter than gsize.data is an array of pointers, NULL terminated.copy_func is a copy function used to copy every element in the array.copy_func_user_data is the user data passed to @copy_func.element_free_func is a function to free elements on @array destruction.The new GPtrArray.ptr_array_new_take (data, int len, object element_free_func)
Creates a new
GPtrArraywith @data as pointers, @len as length and a reference count of 1. This avoids having to copy such data manually. After this call, @data belongs to theGPtrArrayand may no longer be modified by the caller. The memory of @data has to be dynamically allocated and will eventually be freed with [func@GLib.free]. It also sets @element_free_func for freeing each element when the array is destroyed either via [func@GLib.PtrArray.unref], when [func@GLib.PtrArray.free] is called with @free_segment set to true or when removing elements. Do not use it if @len is greater thanG_MAXUINT.GPtrArraystores the length of its data inguint, which may be shorter thangsize.
data is an array of pointers.len is the number of pointers in @data.element_free_func is a function to free elements on @array destruction.The new GPtrArray.ptr_array_new_take_null_terminated (data, object element_free_func)
Creates a new
GPtrArraywith @data as pointers, computing the length of it and setting the reference count to 1. This avoids having to copy such data manually. After this call, @data belongs to theGPtrArrayand may no longer be modified by the caller. The memory of @data has to be dynamically allocated and will eventually be freed with [func@GLib.free]. The length is calculated by iterating through @data until the firstNULLelement is found. It also sets @element_free_func for freeing each element when the array is destroyed either via [func@GLib.PtrArray.unref], when [func@GLib.PtrArray.free] is called with
set to true or when removing elements. Do not use it if thelength is greater than G_MAXUINT. GPtrArray stores the length of its data in guint, which may be shorter than gsize.data is an array of pointers, NULL terminated.element_free_func is a function to free elements on @array destruction.The new GPtrArray.qsort_with_data (pbase, int total_elems, int size, object compare_func)
This is just like the standard C
qsort()function, but the comparison routine accepts a user data argument (likeqsort_r()). Unlikeqsort(), this is guaranteed to be a stable sort (since GLib 2.32).
pbase is start of array to sort.total_elems is elements in the array.size is size of each element.compare_func is function to compare elements.user_data is data to pass to @compare_func.None.random_double ()
Returns a random #gdouble equally distributed over the range [0..1).
a random number.random_double_range (double begin, double end)
Returns a random #gdouble equally distributed over the range [@begin..@end).
begin is lower closed bound of the interval.end is upper open bound of the interval.a random number.random_int ()
Return a random #guint32 equally distributed over the range [0..2^32-1].
a random number.random_int_range (int begin, int end)
Returns a random #gint32 equally distributed over the range [@begin..@end-1].
begin is lower closed bound of the interval.end is upper open bound of the interval.a random number.random_set_seed (int seed)
Sets the seed for the global random number generator, which is used by the g_random_* functions, to @seed.
seed is a value to reinitialize the global random number generator.None.rc_box_acquire (mem_block)
Acquires a reference on the data pointed by @mem_block.
mem_block is a pointer to reference counted data.a pointer to the data, with its reference count increased.rc_box_alloc (int 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.
block_size is the size of the allocation, must be greater than 0.a pointer to the allocated memory.rc_box_alloc0 (int 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.
block_size is the size of the allocation, must be greater than 0.a pointer to the allocated memory.rc_box_dup (int block_size, mem_block)
Allocates a new block of data with reference counting semantics, and copies @block_size bytes of @mem_block into it.
block_size is the number of bytes to copy, must be greater than 0.mem_block is the memory to copy.a pointer to the allocated memory.rc_box_get_size (mem_block)
Retrieves the size of the reference counted data pointed by @mem_block.
mem_block is a pointer to reference counted data.the size of the data, in bytes.rc_box_release (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.
mem_block is a pointer to reference counted data.None.rc_box_release_full (mem_block, object 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
and then will free the resources allocated for @mem_block.mem_block is a pointer to reference counted data.clear_func is a function to call when clearing the data.None.realloc (mem, int n_bytes)
Reallocates the memory pointed to by @mem, so that it now has space for
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.mem is the memory to reallocate.n_bytes is new size of the memory in bytes.the new address of the allocated memory.realloc_n (mem, int n_blocks, int n_block_bytes)
This function is similar to g_realloc(), allocating (@n_blocks *
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.mem is the memory to reallocate.n_blocks is the number of blocks to allocate.n_block_bytes is the size of each block in bytes.the new address of the allocated memory.ref_count_compare (int rc, int val)
Compares the current value of @rc with @val.
rc is the address of a reference count variable.val is the value to compare.%TRUE if the reference count is the same as the given value.ref_count_dec (int rc)
Decreases the reference count. If %TRUE is returned, the reference count reached 0. After this point, @rc is an undefined state and must be reinitialized with g_ref_count_init() to be used again.
rc is the address of a reference count variable.%TRUE if the reference count reached 0, and %FALSE otherwise.ref_count_inc (int rc)
Increases the reference count.
rc is the address of a reference count variable.None.ref_count_init ()
Initializes a reference count variable to 1.
rc is the address of a reference count variable.None.ref_string_acquire (string str)
Acquires a reference on a string.
str is a reference counted string.the given string, with its reference count increased.ref_string_equal (string str1, string str2)
Compares two ref-counted strings for byte-by-byte equality. It can be passed to [func@GLib.HashTable.new] as the key equality function, and behaves exactly the same as [func@GLib.str_equal] (or
strcmp()), but can return slightly faster as it can check the string lengths before checking all the bytes.
str1 is a reference counted string.str2 is a reference counted string.TRUE if the strings are equal, otherwise FALSE.ref_string_length (string str)
Retrieves the length of @str.
str is a reference counted string.the length of the given string, in bytes.ref_string_new (string str)
Creates a new reference counted string and copies the contents of @str into it.
str is a NUL-terminated string.the newly created reference counted string.ref_string_new_intern (string 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.
str is a NUL-terminated string.the newly created reference counted string, or a new reference to an existing string.ref_string_new_len (string str, int 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
addressable bytes.str is a string.len is length of @str to use, or -1 if @str is nul-terminated.the newly created reference counted string.ref_string_release (string str)
Releases a reference on a string; if it was the last reference, the resources allocated by the string are freed as well.
str is a reference counted string.None.regex_check_replacement (string replacement)
Checks whether @replacement is a valid replacement string (see g_regex_replace()), i.e. that all escape sequences in it are valid. If
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.replacement is the replacement string.has_references is location to store information about references inor %NULL.whether @replacement is a valid replacement string.regex_escape_nul (string arg0String, 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.
string is the string to escape.length is the length of @string.a newly-allocated escaped string.regex_escape_string (string arg0String, 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.
string is the string to escape.length is the length of @string, in bytes, or -1 if @string is nul-terminated.a newly-allocated escaped string.regex_match_simple (string pattern, string arg1String, string compile_options, string 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().
pattern is the regular expression.string is the string to scan for matches.compile_options is compile options for the regular expression, or 0.match_options is match options, or 0.%TRUE if the string matched, %FALSE otherwise.regex_split_simple (string pattern, string arg1String, string compile_options, string match_options)
Breaks the string on the pattern, and returns an array of the tokens. If the pattern contains capturing parentheses, then the text for each of the substrings will also be returned. If the pattern does not match anywhere in the string, then the whole string is returned as the first token. This function is equivalent to g_regex_split() 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 split 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_split(). As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent an empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling this function. A pattern that can match empty strings splits @string into separate characters wherever it matches the empty string between characters. For example splitting "ab c" using as a separator "\s*", you will get "a", "b" and "c".
pattern is the regular expression.string is the string to scan for matches.compile_options is compile options for the regular expression, or 0.match_options is match options, or 0.a %NULL-terminated array of strings. Free it using g_strfreev().reload_user_special_dirs_cache ()
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.
None.remove (string filename)
A wrapper for the POSIX remove() function. The remove() function deletes a name from the filesystem. See your C library manual for more details about how remove() works on your system. On Unix, remove() removes also directories, as it calls unlink() for files and rmdir() for directories. On Windows, although remove() in the C library only works for files, this function tries first remove() and then if that fails rmdir(), and thus works for both files and directories. Note however, that on Windows, it is in general not possible to remove a file that is open to some process, or mapped into memory. If this function fails on Windows you can't infer too much from the errno value. rmdir() is tried regardless of what caused remove() to fail. Any errno value set by remove() will be overwritten by that set by rmdir().
filename is a pathname in the GLib file name encoding (UTF-8 on Windows).0 if the file was successfully removed, -1 if an error occurred.rename (string oldfilename, string newfilename)
A wrapper for the POSIX rename() function. The rename() function renames a file, moving it between directories if required. See your C library manual for more details about how rename() works on your system. It is not possible in general on Windows to rename a file that is open to some process.
oldfilename is a pathname in the GLib file name encoding (UTF-8 on Windows).newfilename is a pathname in the GLib file name encoding.0 if the renaming succeeded, -1 if an error occurred.return_if_fail_warning (string log_domain, string pretty_function, string expression)
Internal function used to print messages from the public [func@GLib.return_if_fail] and [func@GLib.return_val_if_fail] macros.
log_domain is log domain.pretty_function is function containing the assertion.expression is expression which failed.None.rmdir (string 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.
filename is a pathname in the GLib file name encoding (UTF-8 on Windows).0 if the directory was successfully removed, -1 if an error occurred.sequence_foreach_range (object begin, object end, object func)
Calls @func for each item in the range (@begin, @end) passing @user_data to the function. @func must not modify the sequence itself.
begin is a #GSequenceIter.end is a #GSequenceIter.func is a #GFunc.user_data is user data passed to @func.None.sequence_get (object iter)
Returns the data that @iter points to.
iter is a #GSequenceIter.the data that @iter points to.sequence_insert_before (object iter, data)
Inserts a new item just before the item pointed to by @iter.
iter is a #GSequenceIter.data is the data for the new item.an iterator pointing to the new item.sequence_move (object src, object 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.
src is a #GSequenceIter pointing to the item to move.dest is a #GSequenceIter pointing to the position to which the item is moved.None.sequence_move_range (object dest, object begin, object 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.
dest is a #GSequenceIter.begin is a #GSequenceIter.end is a #GSequenceIter.None.sequence_range_get_midpoint (object begin, object 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.
begin is a #GSequenceIter.end is a #GSequenceIter.a #GSequenceIter pointing somewhere in the (@begin, @end) range.sequence_remove (object 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.
iter is a #GSequenceIter.None.sequence_remove_range (object begin, object 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.
begin is a #GSequenceIter.end is a #GSequenceIter.None.sequence_set (object iter, 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.
iter is a #GSequenceIter.data is new data for the item.None.sequence_sort_changed (object iter, object cmp_func)
Moves the data pointed to by @iter to a new position as indicated by
This function should be called for items in a sequence already sorted according to @cmp_func whenever some aspect of an item changes so that @cmp_func may return different values for that item. @cmp_func is called with two items of the @seq, and @cmp_data. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first.iter is A #GSequenceIter.cmp_func is the function used to compare items in the sequence.cmp_data is user data passed to @cmp_func..None.sequence_sort_changed_iter (object iter, object iter_cmp)
Like g_sequence_sort_changed(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function. @iter_cmp is called with two iterators pointing into the #GSequence that @iter points into. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first.
iter is a #GSequenceIter.iter_cmp is the function used to compare iterators in the sequence.cmp_data is user data passed to @cmp_func.None.sequence_swap (object a, object b)
Swaps the items pointed to by @a and @b. It is allowed for @a and @b to point into difference sequences.
a is a #GSequenceIter.b is a #GSequenceIter.None.set_application_name (string 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.
application_name is localized name of the application.None.set_prgname (string 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. By default, 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. See the GTK documentation for requirements on integrating g_set_prgname() with GTK applications.
prgname is the name of the program..None.set_print_handler (object func)
Sets the print handler to @func, or resets it to the default GLib handler if
NULL. Any messages passed to [func@GLib.print] will be output via the new handler. The default handler outputs the encoded message tostdout. By providing your own handler you can redirect the output, to a GTK widget or a log file for example. Since 2.76 this functions always returns a valid [type@GLib.PrintFunc], and never returnsNULL. If no custom print handler was set, it will return the GLib default print handler and that can be re-used to decorate its output and/or to write tostderrin all platforms. Before GLib 2.76, this wasNULL.
func is the new print handler or NULL to reset to the default.the old print handler.set_printerr_handler (object func)
Sets the handler for printing error messages to @func, or resets it to the default GLib handler if
NULL. Any messages passed to [func@GLib.printerr] will be output via the new handler. The default handler outputs the encoded message tostderr. By providing your own handler you can redirect the output, to a GTK widget or a log file for example. Since 2.76 this functions always returns a valid [type@GLib.PrintFunc], and never returnsNULL. If no custom error print handler was set, it will return the GLib default error print handler and that can be re-used to decorate its output and/or to write tostderrin all platforms. Before GLib 2.76, this wasNULL.
func is he new error message handler or NULL to reset to the default.the old error message handler.setenv (string variable, string value, bool 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.
variable is the environment variable to set, must not contain '='..value is the value for to set the variable to..overwrite is whether to change the variable if it already exists..%FALSE if the environment variable couldn't be set..shell_parse_argv (string command_line)
Parses a command line into an argument vector, in much the same way the shell would, but without many of the expansions the shell would perform (variable expansion, globs, operators, filename expansion, etc. are not supported). The results are defined to be the same as those you would get from a UNIX98
/bin/sh, as long as the input contains none of the unsupported shell expansions. If the input does contain such expansions, they are passed through literally. Possible errors are those from the %G_SHELL_ERROR domain. In particular, if @command_line is an empty string (or a string containing only whitespace), %G_SHELL_ERROR_EMPTY_STRING will be returned. It’s guaranteed that @argvp will be a non-empty array if this function returns successfully. Free the returned vector with g_strfreev().
command_line is command line to parse.argcp is return location for number of args.argvp is return location for array of args.%TRUE on success, %FALSE if error set.shell_quote (string 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).
unquoted_string is a literal string.quoted string.shell_unquote (string quoted_string)
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.
quoted_string is shell-quoted string.an unquoted string.slice_alloc (int block_size)
Allocates a block of memory from the libc allocator. The block address handed out can be expected to be aligned to at least
1 * sizeof (void*). Since GLib 2.76 this always uses the system malloc() implementation internally.
block_size is the number of bytes to allocate.a pointer to the allocated memory block, which will be %NULL if and only if @mem_size is 0.slice_alloc0 (int block_size)
Allocates a block of memory via g_slice_alloc() and initializes the returned memory to 0. Since GLib 2.76 this always uses the system malloc() implementation internally.
block_size is the number of bytes to allocate.a pointer to the allocated block, which will be %NULL if and only ifis 0.slice_copy (int block_size, mem_block)
Allocates a block of memory from the slice allocator and copies
bytes into it from @mem_block. @mem_block must be non-%NULL if @block_size is non-zero. Since GLib 2.76 this always uses the system malloc() implementation internally.block_size is the number of bytes to allocate.mem_block is the memory to copy.a pointer to the allocated memory block, which will be %NULL if and only if @mem_size is 0.slice_free1 (int block_size, 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-friendlyenvironment variable. If @mem_block is %NULL, this function does nothing. Since GLib 2.76 this always uses the system free_sized() implementation internally.
block_size is the size of the block.mem_block is a pointer to the block to free.None.slice_free_chain_with_offset (int block_size, mem_chain, int 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-friendlyenvironment variable. If @mem_chain is %NULL, this function does nothing. Since GLib 2.76 this always uses the system free_sized() implementation internally.
block_size is the size of the blocks.mem_chain is a pointer to the first block of the chain.next_offset is the offset of the @next field in the blocks.None.slice_get_config (string ckey)
Generated wrapper for GIR function
slice_get_config. Native symbol:g_slice_get_config.
slice_get_config_state (string ckey, int address, int n_values)
Generated wrapper for GIR function
slice_get_config_state. Native symbol:g_slice_get_config_state.
slice_set_config (string ckey, int value)
Generated wrapper for GIR function
slice_set_config. Native symbol:g_slice_set_config.
None.slist_pop_allocator ()
Generated wrapper for GIR function
slist_pop_allocator. Native symbol:g_slist_pop_allocator.
None.slist_push_allocator (object allocator)
Generated wrapper for GIR function
slist_push_allocator. Native symbol:g_slist_push_allocator.
None.snprintf (string arg0String, int n, string format, list varargs)
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 [func@GLib.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.
string is the buffer to hold the output.n is the maximum number of bytes to produce (including the terminating nul character).format is a standard printf() format string, but notice string precision pitfalls.... is the arguments to insert in the output.the number of bytes which would be produced if the buffer was large enough.sort_array (array, int n_elements, int element_size, object compare_func)
This is just like the standard C
qsort()function, but the comparison routine accepts a user data argument (likeqsort_r()). Unlikeqsort(), this is guaranteed to be a stable sort.
array is start of array to sort.n_elements is number of elements in the array.element_size is size of each element.compare_func is function to compare elements.user_data is data to pass to @compare_func.None.source_remove (int tag)
Removes the source with the given ID from the default main context. You must use [method@GLib.Source.destroy] for sources added to a non-default main context. The ID of a [struct@GLib.Source] is given by [method@GLib.Source.get_id], or will be returned by the functions [method@GLib.Source.attach], [func@GLib.idle_add], [func@GLib.idle_add_full], [func@GLib.timeout_add], [func@GLib.timeout_add_full], [func@GLib.child_watch_add], [func@GLib.child_watch_add_full], [func@GLib.io_add_watch], and [func@GLib.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 [func@GLib.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.
tag is the ID of the source to remove..true if the source was found and removed, false otherwise.source_remove_by_funcs_user_data (object funcs, 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.
funcs is the @source_funcs passed to [ctor@GLib.Source.new].user_data is the user data for the callback.true if a source was found and removed, false otherwise.source_remove_by_user_data (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.
user_data is the user_data for the callback.true if a source was found and removed, false otherwise.source_set_name_by_id (int tag, string name)
Sets the name of a source using its ID. This is a convenience utility to set source names from the return value of [func@GLib.idle_add], [func@GLib.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 [func@GLib.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.
tag is a source ID.name is debug name for the source.None.spaced_primes_closest (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.
num is a #guint.the smallest prime number from a built-in array of primes which is larger than @num.spawn_async (string working_directory, list argv, list envp, string flags, object child_setup)
Executes a child program asynchronously. See g_spawn_async_with_pipes_and_fds() for a full description; this function simply calls the g_spawn_async_with_pipes() without any pipes, which in turn calls g_spawn_async_with_pipes_and_fds(). You should call g_spawn_close_pid() on the returned child process reference when you don't need it any more. If you are writing a GTK application, and the program you are spawning is a graphical application too, then to ensure that the spawned program opens its windows on the right screen, you may want to use #GdkAppLaunchContext, #GAppLaunchContext, or set the %DISPLAY environment variable. Note that the returned @child_pid on Windows is a handle to the child process and not its identifier. Process handles and process identifiers are different concepts on Windows.
working_directory is child's current working directory, or %NULL to inherit parent's.argv is child's argument vector.envp is child's environment, or %NULL to inherit parent's.flags is flags from #GSpawnFlags.child_setup is function to run in the child just before exec().user_data is user data for @child_setup.child_pid is return location for child process reference, or %NULL.%TRUE on success, %FALSE if error is set.spawn_async_with_fds (string working_directory, list argv, list envp, string flags, object child_setup, int stdin_fd, int stdout_fd, int stderr_fd)
Executes a child program asynchronously. Identical to g_spawn_async_with_pipes_and_fds() but with
n_fdsset to zero, so no FD assignments are used.
working_directory is child's current working directory, or %NULL to inherit parent's, in the GLib file name encoding.argv is child's argument vector, in the GLib file name encoding; it must be non-empty and %NULL-terminated.envp is child's environment, or %NULL to inherit parent's, in the GLib file name encoding.flags is flags from #GSpawnFlags.child_setup is function to run in the child just before exec().user_data is user data for @child_setup.child_pid is return location for child process ID, or %NULL.stdin_fd is file descriptor to use for child's stdin, or -1.stdout_fd is file descriptor to use for child's stdout, or -1.stderr_fd is file descriptor to use for child's stderr, or -1.%TRUE on success, %FALSE if an error was set.spawn_async_with_pipes (string working_directory, list argv, list envp, string flags, object child_setup)
Identical to g_spawn_async_with_pipes_and_fds() but with
n_fdsset to zero, so no FD assignments are used.
working_directory is child's current working directory, or %NULL to inherit parent's, in the GLib file name encoding.argv is child's argument vector, in the GLib file name encoding; it must be non-empty and %NULL-terminated.envp is child's environment, or %NULL to inherit parent's, in the GLib file name encoding.flags is flags from #GSpawnFlags.child_setup is function to run in the child just before exec().user_data is user data for @child_setup.child_pid is return location for child process ID, or %NULL.standard_input is return location for file descriptor to write to child's stdin, or %NULL.standard_output is return location for file descriptor to read child's stdout, or %NULL.standard_error is return location for file descriptor to read child's stderr, or %NULL.%TRUE on success, %FALSE if an error was set.spawn_async_with_pipes_and_fds (string working_directory, list argv, list envp, string flags, object child_setup, int stdin_fd, int stdout_fd, int stderr_fd, list source_fds, list target_fds)
Executes a child program asynchronously (your program will not block waiting for the child to exit). The child program is specified by the only argument that must be provided, @argv. @argv should be a %NULL-terminated array of strings, to be passed as the argument vector for the child. The first string in @argv is of course the name of the program to execute. By default, the name of the program must be a full path. If @flags contains the %G_SPAWN_SEARCH_PATH flag, the
PATHenvironment variable is used to search for the executable. If @flags contains the %G_SPAWN_SEARCH_PATH_FROM_ENVP flag, thePATHvariable from @envp is used to search for the executable. If both the %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP flags are set, thePATHvariable from @envp takes precedence over the environment variable. If the program name is not a full path and %G_SPAWN_SEARCH_PATH flag is not used, then the program will be run from the current directory (or @working_directory, if specified); this might be unexpected or even dangerous in some cases when the current directory is world-writable. On Windows, note that all the string or string vector arguments to this function and the otherg_spawn*()functions are in UTF-8, the GLib file name encoding. Unicode characters that are not part of the system codepage passed in these arguments will be correctly available in the spawned program only if it uses wide character API to retrieve its command line. For C programs built with Microsoft's tools it is enough to make the program have awmain()instead ofmain().wmain()has a wide character argument vector as parameter. At least currently, mingw doesn't supportwmain(), so if you use mingw to develop the spawned program, it should call g_win32_get_command_line() to get arguments in UTF-8. On Windows the low-level child process creation APICreateProcess()doesn't use argument vectors, but a command line. The C runtime library'sspawn*()family of functions (which g_spawn_async_with_pipes() eventually calls) paste the argument vector elements together into a command line, and the C runtime startup code does a corresponding reconstruction of an argument vector from the command line, to be passed tomain(). Complications arise when you have argument vector elements that contain spaces or double quotes. Thespawn*()functions don't do any quoting or escaping, but on the other hand the startup code does do unquoting and unescaping in order to enable receiving arguments with embedded spaces or double quotes. To work around this asymmetry, g_spawn_async_with_pipes() will do quoting and escaping on argument vector elements that need it before calling the C runtimespawn()function. The returned @child_pid on Windows is a handle to the child process, not its identifier. Process handles and process identifiers are different concepts on Windows. @envp is a %NULL-terminated array of strings, where each string has the formKEY=VALUE. This will become the child's environment. If @envp is %NULL, the child inherits its parent's environment. @flags should be the bitwise OR of any flags you want to affect the function's behaviour. The %G_SPAWN_DO_NOT_REAP_CHILD means that the child will not automatically be reaped; you must use a child watch (g_child_watch_add()) to be notified about the death of the child process, otherwise it will stay around as a zombie process until this process exits. Eventually you must call g_spawn_close_pid() on the @child_pid, in order to free resources which may be associated with the child process. (On Unix, using a child watch is equivalent to calling waitpid() or handling theSIGCHLDsignal manually. On Windows, calling g_spawn_close_pid() is equivalent to callingCloseHandle()on the process handle returned in @child_pid). See g_child_watch_add(). Open UNIX file descriptors marked asFD_CLOEXECwill be automatically closed in the child process. %G_SPAWN_LEAVE_DESCRIPTORS_OPEN means that other open file descriptors will be inherited by the child; otherwise all descriptors except stdin/stdout/stderr will be closed before callingexec()in the child. %G_SPAWN_SEARCH_PATH means that @argv[0] need not be an absolute path, it will be looked for in thePATHenvironment variable. %G_SPAWN_SEARCH_PATH_FROM_ENVP means need not be an absolute path, it will be looked for in thePATHvariable from @envp. If both %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP are used, the value from @envp takes precedence over the environment. %G_SPAWN_CHILD_INHERITS_STDIN means that the child will inherit the parent's standard input (by default, the child's standard input is attached to/dev/null). %G_SPAWN_STDIN_FROM_DEV_NULL explicitly imposes the default behavior. Both flags cannot be enabled at the same time and, in both cases, the @stdin_pipe_out argument is ignored. %G_SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output will be discarded (by default, it goes to the same location as the parent's standard output). %G_SPAWN_CHILD_INHERITS_STDOUT explicitly imposes the default behavior. Both flags cannot be enabled at the same time and, in both cases, the @stdout_pipe_out argument is ignored. %G_SPAWN_STDERR_TO_DEV_NULL means that the child's standard error will be discarded (by default, it goes to the same location as the parent's standard error). %G_SPAWN_CHILD_INHERITS_STDERR explicitly imposes the default behavior. Both flags cannot be enabled at the same time and, in both cases, the @stderr_pipe_out argument is ignored. It is valid to pass the same FD in multiple parameters (e.g. you can pass a single FD for both @stdout_fd and @stderr_fd, and include it in @source_fds too).
and @target_fds allow zero or more FDs from this process to be remapped to different FDs in the spawned process. If @n_fds is greater than zero, @source_fds and @target_fds must both be non-%NULL and the same length. Each FD in @source_fds is remapped to the FD number at the same index in @target_fds. The source and target FD may be equal to simply propagate an FD to the spawned process. FD remappings are processed after standard FDs, so any target FDs which equal @stdin_fd,or @stderr_fd will overwrite them in the spawned process.is supported on Windows since 2.72. %G_SPAWN_FILE_AND_ARGV_ZERO means that the first element of @argv is the file to execute, while the remaining elements are the actual argument vector to pass to the file. Normally g_spawn_async_with_pipes() usesas the file to execute, and passes all of @argv to the child.and @user_data are a function and user data. On POSIX platforms, the function is called in the child after GLib has performed all the setup it plans to perform (including creating pipes, closing file descriptors, etc.) but before calling exec(). That is, @child_setup is called just before calling exec() in the child. Obviously actions taken in this function will only affect the child, not the parent. On Windows, there is no separate fork() and exec() functionality. Child processes are created and run with a single API call, CreateProcess(). There is no sensible thing @child_setup could be used for on Windows so it is ignored and not called. If non-%NULL, @child_pid will on Unix be filled with the child's process ID. You can use the process ID to send signals to the child, or to use g_child_watch_add() (or waitpid()) if you specified the %G_SPAWN_DO_NOT_REAP_CHILD flag. On Windows, @child_pid will be filled with a handle to the child process only if you specified the %G_SPAWN_DO_NOT_REAP_CHILD flag. You can then access the child process using the Win32 API, for example wait for its termination with the WaitFor*() functions, or examine its exit code with GetExitCodeProcess(). You should close the handle with CloseHandle() or g_spawn_close_pid() when you no longer need it. If non-%NULL, the@stdout_pipe_out, @stderr_pipe_out locations will be filled with file descriptors for writing to the child's standard input or reading from its standard output or standard error. The caller of g_spawn_async_with_pipes() must close these file descriptors when they are no longer in use. If these parameters are %NULL, the corresponding pipe won't be created. If @stdin_pipe_out is %NULL, the child's standard input is attached to /dev/null unless %G_SPAWN_CHILD_INHERITS_STDIN is set. If @stderr_pipe_out is NULL, the child's standard error goes to the same location as the parent's standard error unless %G_SPAWN_STDERR_TO_DEV_NULL is set. If @stdout_pipe_out is NULL, the child's standard output goes to the same location as the parent's standard output unless %G_SPAWN_STDOUT_TO_DEV_NULL is set. @error can be %NULL to ignore errors, or non-%NULL to report errors. If an error is set, the function returns %FALSE. Errors are reported even if they occur in the child (for example if the executable in @argv[0] is not found). Typically the message field of returned errors should be displayed to users. Possible errors are those from the %G_SPAWN_ERROR domain. If an error occurs, @child_pid, @stdin_pipe_out, @stdout_pipe_out, andwill not be filled with valid values. If @child_pid is not %NULL and an error does not occur then the returned process reference must be closed using g_spawn_close_pid(). On modern UNIX platforms, GLib can use an efficient process launching codepath driven internally by posix_spawn(). This has the advantage of avoiding the fork-time performance costs of cloning the parent process address space, and avoiding associated memory overcommit checks that are not relevant in the context of immediately executing a distinct process. This optimized codepath will be used provided that the following conditions are met: 1. %G_SPAWN_DO_NOT_REAP_CHILD is set 2. %G_SPAWN_LEAVE_DESCRIPTORS_OPEN is set 3. %G_SPAWN_SEARCH_PATH_FROM_ENVP is not set 4. @working_directory is %NULL 5. @child_setup is %NULL 6. The program is of a recognised binary format, or has a shebang. Otherwise, GLib will have to execute the program through the shell, which is not done using the optimized codepath. If you are writing a GTK application, and the program you are spawning is a graphical application too, then to ensure that the spawned program opens its windows on the right screen, you may want to use #GdkAppLaunchContext, #GAppLaunchContext, or set the DISPLAY environment variable.working_directory is child's current working directory, or %NULL to inherit parent's, in the GLib file name encoding.argv is child's argument vector, in the GLib file name encoding; it must be non-empty and %NULL-terminated.envp is child's environment, or %NULL to inherit parent's, in the GLib file name encoding.flags is flags from #GSpawnFlags.child_setup is function to run in the child just before exec().user_data is user data for @child_setup.stdin_fd is file descriptor to use for child's stdin, or -1.stdout_fd is file descriptor to use for child's stdout, or -1.stderr_fd is file descriptor to use for child's stderr, or -1.source_fds is array of FDs from the parent process to make available in the child process.target_fds is array of FDs to remap @source_fds to in the child process.n_fds is number of FDs in @source_fds and @target_fds.child_pid_out is return location for child process ID, or %NULL.stdin_pipe_out is return location for file descriptor to write to child's stdin, or %NULL.stdout_pipe_out is return location for file descriptor to read child's stdout, or %NULL.stderr_pipe_out is return location for file descriptor to read child's stderr, or %NULL.%TRUE on success, %FALSE if an error was set.spawn_check_exit_status (int wait_status)
An old name for g_spawn_check_wait_status(), deprecated because its name is misleading. Despite the name of the function, @wait_status must be the wait status as returned by g_spawn_sync(), g_subprocess_get_status(),
waitpid(), etc. On Unix platforms, it is incorrect for it to be the exit status as passed toexit()or returned by g_subprocess_get_exit_status() orWEXITSTATUS().
wait_status is A status as returned from g_spawn_sync().%TRUE if child exited successfully, %FALSE otherwise (and @error will be set).spawn_check_wait_status (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). 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
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.wait_status is A platform-specific wait status as returned from g_spawn_sync().%TRUE if child exited successfully, %FALSE otherwise (and @error will be set).spawn_command_line_async (string 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(). 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().
command_line is a command line.%TRUE on success, %FALSE if error is set.sprintf (string arg0String, string format, list varargs)
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 [func@GLib.snprintf], to avoid the risk of buffer overflow.glib/gprintf.hmust be explicitly included in order to use this function. See also [func@GLib.strdup_printf].
string is 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 is a standard printf() format string, but notice string precision pitfalls.... is the arguments to insert in the output.the number of bytes printed.stat (string filename, object buf)
A wrapper for the POSIX stat() function. The stat() function returns information about a file. On Windows the stat() function in the C library checks only the FAT-style READONLY attribute and does not look at the ACL at all. Thus on Windows the protection bits in the @st_mode field are a fabrication of little use. On Windows the Microsoft C libraries have several variants of the stat struct and stat() function with names like _stat(), _stat32(), _stat32i64() and _stat64i32(). The one used here is for 32-bit code the one with 32-bit size and time fields, specifically called _stat32(). In Microsoft's compiler, by default struct stat means one with 64-bit time fields while in MinGW struct stat is the legacy one with 32-bit fields. To hopefully clear up this messs, the gstdio.h header defines a type #GStatBuf which is the appropriate struct type depending on the platform and/or compiler being used. On POSIX it is just struct stat, but note that even on POSIX platforms, stat() might be a macro. See your C library manual for more details about stat().
filename is a pathname in the GLib file name encoding (UTF-8 on Windows).buf is a pointer to a stat struct, which will be filled with the file information.0 if the information was successfully retrieved, -1 if an error occurred.stpcpy (string dest, string src)
Copies a nul-terminated string into the destination buffer, including the trailing nul byte, and returns a pointer to the trailing nul byte in
dest. The return value is useful for concatenating multiple strings without having to repeatedly scan for the end.
dest is destination buffer.src is source string.a pointer to the trailing nul byte in dest.str_equal (v1, 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().
v1 is a key.v2 is a key to compare with @v1.%TRUE if the two keys match.str_has_prefix (string str, string prefix)
Looks whether the string @str begins with @prefix.
str is a string to look in.prefix is the prefix to look for.true if @str begins with @prefix, false otherwise.str_has_suffix (string str, string suffix)
Looks whether a string ends with @suffix.
str is a string to look in.suffix is the suffix to look for.true if @str ends with @suffix, false otherwise.str_hash (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.
v is a string key.a hash value corresponding to the key.str_is_ascii (string str)
Determines if a string is pure ASCII. A string is pure ASCII if it contains no bytes with the high bit set.
str is a string.true if @str is ASCII.str_match_string (string search_term, string potential_hit, bool accept_alternates)
Checks if a search conducted for @search_term should match
This function calls [func@GLib.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 inis 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).search_term is the search term from the user.potential_hit is the text that may be a hit.accept_alternates is if true, ASCII alternates are accepted.true if @potential_hit is a hit.str_to_ascii (string str, string 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.
str is a string, in UTF-8.from_locale is the source locale, if known.a string in plain ASCII.str_tokenize_and_fold (string arg0String, string translit_locale)
Tokenizes @string and performs folding on each token. A token is a non-empty sequence of alphanumeric characters in the source string, separated by non-alphanumeric characters. An "alphanumeric" character for this purpose is one that matches [func@GLib.unichar_isalnum] or [func@GLib.unichar_ismark]. Each token is then (Unicode) normalised and case-folded. If @ascii_alternates is non-
NULLand some of the returned tokens contain non-ASCII characters, ASCII alternatives will be generated. The number of ASCII alternatives that are generated and the method for doing so is unspecified, but @translit_locale (if specified) may improve the transliteration if the language of the source string is known.
string is a string to tokenize.translit_locale is the language code (like 'de' or 'en_GB') from whichoriginates.ascii_alternates is a return location for ASCII alternates.the folded tokens.strcanon (string arg0String, string valid_chars, int 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:
C g_ascii_strup (g_strcanon (str, "abc", '?'))In order to modify a copy, you may use [func@GLib.strdup]:C reformatted = g_strcanon (g_strdup (const_str), "abc", '?'); … g_free (reformatted);
string is a nul-terminated array of bytes.valid_chars is bytes permitted in @string.substitutor is replacement character for disallowed bytes.the modified @string.strcasecmp (string s1, string s2)
A case-insensitive string comparison, corresponding to the standard
strcasecmp()function on platforms which support it.
s1 is string to compare with @s2.s2 is string to compare with @s1.0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2.strchomp (string arg0String)
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 [func@GLib.strchug] and [func@GLib.strstrip].
string is a string to remove the trailing whitespace from.the modified @string.strchug (string arg0String)
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 [func@GLib.strchomp] and [func@GLib.strstrip].
string is a string to remove the leading whitespace from.the modified @string.strcmp0 (string str1, string str2)
Compares @str1 and @str2 like
strcmp(). HandlesNULLgracefully by sorting it before non-NULLstrings. Comparing twoNULLpointers returns 0.
str1 is a string.str2 is another string.an integer less than, equal to, or greater than zero, if @str1 is <, == or > than @str2.strcompress (string source)
Makes a copy of a string replacing C string-style escape sequences with their one byte equivalent: -
\b→ U+0008 Backspace -\f→ U+000C Form Feed -\n→ U+000A Line Feed -\r→ U+000D Carriage Return -\t→ U+0009 Horizontal Tabulation -\v→ U+000B Vertical Tabulation -\followed by one to three octal digits → the numeric value (mod 256) -\followed by any other character → the character as is. For example,\\will turn into a backslash (\) and\"into a double quote ("). [func@GLib.strescape] does the reverse conversion.
source is a string to compress.a newly-allocated copy of @source with all escaped character compressed.strconcat (string string1, list varargs)
Concatenates all of the given strings into one long string. The variable argument list must end with
NULL. If you forget theNULL,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.
string1 is the first string to add, which must not be NULL.... is a NULL-terminated list of strings to append to the string.a newly-allocated string containing all the string arguments.strdelimit (string arg0String, string delimiters, int new_delimiter)
Converts any delimiter characters in @string to @new_delimiter. Any characters in @string which are found in @delimiters are changed to the
character. Modifies @string in place, and returns @string itself, not a copy. The return value is to allow nesting such as: C g_ascii_strup (g_strdelimit (str, "abc", '?')) In order to modify a copy, you may use [func@GLib.strdup]: C reformatted = g_strdelimit (g_strdup (const_str), "abc", '?'); … g_free (reformatted); string is the string to convert.delimiters is a string containing the current delimiters, or NULL to use the standard delimiters defined in [const@GLib.STR_DELIMITERS].new_delimiter is the new delimiter character.the modified @string.strdown (string arg0String)
Converts a string to lower case.
string is the string to convert.the string.strdup (string str)
Duplicates a string. If @str is
NULLit returnsNULL.
str is the string to duplicate.a newly-allocated copy of @str.strdup_printf (string format, list varargs)
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 is guaranteed to be non-NULL, unless @format contains%lcor%lsconversions, which can fail if no multibyte representation is available for the given character.
format is a standard printf() format string, but notice string precision pitfalls.... is the parameters to insert into the format string.a newly-allocated string holding the result.strdupv (list str_array)
Copies an array of strings. The copy is a deep copy; each string is also copied. If called on a
NULLvalue,g_strdupv()simply returnsNULL.
str_array is an array of strings to copy.a newly-allocated array of strings. Use [func@GLib.strfreev] to free it..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. If the error code is unknown, it returns a string like “Unknown error <code>”. Note that the string may be translated according to the current locale. The value oferrnowill 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:C int saved_errno; ret = read (blah); saved_errno = errno; g_strerror (saved_errno);
errnum is the system error number. See the standard C errno documentation.the string describing the error code.strescape (string source, string exceptions)
It replaces the following special characters in the string @source with their corresponding C escape sequence: | Symbol | Escape | |-----------------------------------------------------------------------------|--------| | U+0008 Backspace |
\b| | U+000C Form Feed |\f| | U+000A Line Feed |\n| | U+000D Carriage Return |\r| | U+0009 Horizontal Tabulation |\t| | U+000B Vertical Tabulation |\v| It also inserts a backslash (\) before any backslash or a double quote ("). 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 backslash followed by their octal representation. Characters supplied in @exceptions are not escaped. [func@GLib.strcompress] does the reverse conversion.
source is a string to escape.exceptions is a string of characters not to escape in @source.a newly-allocated copy of @source with special characters escaped.strfreev (list str_array)
Frees an array of strings, as well as each string it contains. If
is NULL, this function simply returns.str_array is an array of strings to free.None.strip_context (string msgid, string msgval)
An auxiliary function for gettext() support (see Q_()).
msgid is a string.msgval is another string.@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 (string separator, list varargs)
Joins a number of strings together to form one long string, with the optional @separator inserted between each of them.
separator is a string to insert between each of the strings.... is a NULL-terminated list of strings to join.a newly-allocated string containing all of the strings joined together, with @separator between them.strjoinv (string separator, list str_array)
Joins an array of strings together to form one long string, with the optional @separator inserted between each of them. If @str_array has no items, the return value will be an empty string. If @str_array contains a single item, @separator will not appear in the resulting string.
separator is a string to insert between each of the strings.str_array is an array of strings to join.a newly-allocated string containing all of the strings joined together, with @separator between them.strlcat (string dest, string src, int 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. Unlikestrncat(), @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 tostrcat()orstrncat(), but for real security [func@GLib.strconcat] is harder to mess up.
dest is destination buffer, already containing one nul-terminated string.src is source buffer.dest_size is length of @dest buffer in bytes (not length of existing string inside @dest).size of attempted result, which is MIN (dest_size, strlen (original dest)) + strlen (src), so if @retval >= @dest_size, truncation occurred.strlcpy (string dest, string src, int dest_size)
Portability wrapper that calls
strlcpy()on systems which have it, and emulatesstrlcpy()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. Unlikestrncpy(), 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 thanstrcpy()orstrncpy(), but if you really want to avoid screwups, [func@GLib.strdup] is an even better idea.
dest is destination buffer.src is source buffer.dest_size is length of @dest in bytes.length of @src.strncasecmp (string s1, string s2, int n)
A case-insensitive string comparison, corresponding to the standard
strncasecmp()function on platforms which support it. It is similar to [func@GLib.strcasecmp] except it only compares the first @n characters of the strings.
s1 is string to compare with @s2.s2 is string to compare with @s1.n is the maximum number of characters to compare.0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2.strndup (string str, int 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
NULLit returnsNULL. To copy a number of characters from a UTF-8 encoded string, use [func@GLib.utf8_strncpy] instead.
str is the string to duplicate.n is the maximum number of bytes to copy from @str.a newly-allocated buffer containing the first @n bytes of @str.strnfill (int length, int fill_char)
Creates a new string @length bytes long filled with @fill_char.
length is the length of the new string.fill_char is the byte to fill the string with.a newly-allocated string filled with @fill_char.strreverse (string arg0String)
Reverses all of the bytes in a string. For example,
g_strreverse ("abcdef")will result in "fedcba". Note thatg_strreverse()doesn't work on UTF-8 strings containing multibyte characters. For that purpose, use [func@GLib.utf8_strreverse].
string is the string to reverse.the @string, reversed in place.strrstr (string haystack, string needle)
Searches the string @haystack for the last occurrence of the string
The fact that this function returns gchar * rather than const gchar * is a historical artifact.haystack is a string to search in.needle is the string to search for.a pointer to the found occurrence, or NULL if not found.strrstr_len (string haystack, int haystack_len, string needle)
Searches the string @haystack for the last occurrence of the string
limiting the length of the search to @haystack_len. The fact that this function returns gchar * rather than const gchar * is a historical artifact.haystack is a string to search in.haystack_len is the maximum length of @haystack in bytes. A length of -1 can be used to mean "search the entire string", like [func@GLib.strrstr].needle is the string to search for.a pointer to the found occurrence, or NULL if not found.strsignal (int signum)
Returns a string describing the given signal, e.g. "Segmentation fault". If the signal is unknown, it returns “unknown signal (<signum>)”. You should use this function in preference to
strsignal(), because it returns a string in UTF-8 encoding, and since not all platforms support thestrsignal()function.
signum is the signal number. See the signal documentation.the string describing the signal.strsplit (string arg0String, string delimiter, int max_tokens)
Splits a string into a maximum of @max_tokens pieces, using the given
If @max_tokens is reached, the remainder of @string is appended to the last token. As an example, the result of g_strsplit (":a:bc::d:", ":", -1) is an array containing the six strings "", "a", "bc", "", "d" and "". As a special case, the result of splitting the empty string "" is an empty array, not an array containing a single string. The reason for this special case is that being able to represent an empty array is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling g_strsplit().string is a string to split.delimiter is a string which specifies the places at which to split the string. The delimiter is not included in any of the resulting strings, unless @max_tokens is reached..max_tokens is the maximum number of pieces to split @string into If this is less than 1, the string is split completely.a newly-allocated array of strings, freed with [func@GLib.strfreev].strsplit_set (string arg0String, list delimiters, int max_tokens)
Splits @string into a number of tokens not containing any of the bytes in
A token is the (possibly empty) longest string that does not contain any of the bytes in @delimiters. Note that separators will only be single bytes from @delimiters. If @max_tokens is reached, the remainder is appended to the last token. For example, the result of g_strsplit_set ("abc:def/ghi", ":/", -1) is an array containing the three strings "abc", "def", and "ghi". The result of g_strsplit_set (":def/ghi:/x", ":/", -1) is an array containing the five strings "", "def", "ghi", "", "x". As a special case, the result of splitting the empty string "" is an empty array, not an array containing a single string. The reason for this special case is that being able to represent an empty array is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling g_strsplit_set(). 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.string is a string to split.delimiters is a nul-terminated byte array containing bytes that are used to split the string; can be empty (just a nul byte), which will result in no string splitting.max_tokens is the maximum number of tokens to split @string into. If this is less than 1, the string is split completely.a newly-allocated array of strings. Use [func@GLib.strfreev] to free it..strstr_len (string haystack, int haystack_len, string needle)
Searches the string @haystack for the first occurrence of the string
limiting the length of the search to @haystack_len or a nul terminator byte (whichever is reached first). A length of -1 can be used to mean “search the entire string”, like strstr(). The fact that this function returns gchar * rather than const gchar * is a historical artifact.haystack is a string to search in.haystack_len is the maximum length of @haystack in bytes, or -1 to search it entirely.needle is the string to search for.a pointer to the found occurrence, or NULL if not found.strtod (string nptr)
Converts a string to a floating point value. It calls the standard
strtod()function to handle the conversion, but if the string is not completely converted it attempts the conversion again with [func@GLib.ascii_strtod], and returns the best match. This function should seldom be used. The normal situation when reading numbers not for human consumption is to use [func@GLib.ascii_strtod]. Only when you know that you must expect both locale formatted and C formatted numbers should you use this. Make sure that you don't pass strings such as comma separated lists of values, since the commas may be interpreted as a decimal point in some locales, causing unexpected results.
nptr is the string to convert to a numeric value.endptr is if non-NULL, it returns the character after the last character used in the conversion.the converted value.strup (string arg0String)
Converts a string to upper case.
string is the string to convert.the string.strv_contains (list strv, string str)
Checks if an array of strings contains the string @str according to [func@GLib.str_equal]. @strv must not be
NULL.
strv is an array of strings to search in.str is the string to search for.true if @str is an element of @strv.strv_equal (list strv1, list strv2)
Checks if two arrays of strings contain exactly the same elements in exactly the same order. Elements are compared using [func@GLib.str_equal]. To match independently of order, sort the arrays first (using [func@GLib.qsort_with_data] or similar). Two empty arrays are considered equal. Neither @strv1 nor @strv2 may be
NULL.
strv1 is an array of strings to compare to @strv2.strv2 is an array of strings to compare to @strv1.true if @strv1 and @strv2 are equal.strv_get_type ()
Generated wrapper for GIR function
strv_get_type. Native symbol:g_strv_get_type.
strv_length (list str_array)
Returns the length of an array of strings. @str_array must not be
NULL.
str_array is an array of strings.length of @str_array.test_add_data_func (string testpath, test_data, object test_func)
Creates a new test case. This function is similar to [func@GLib.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 /-separated portions of @testpath. The
argument will be passed as first argument to @test_func. Ifincludes 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 [func@GLib.test_trap_subprocess]. No component of @testpath may start with a dot (.) if the [const@GLib.TEST_OPTION_ISOLATE_DIRS] option is being used; and it is recommended to do so even if it isn’t.testpath is a /-separated name for the test.test_data is data for the @test_func.test_func is the test function to invoke for this test.None.test_add_data_func_full (string testpath, test_data, object test_func)
Creates a new test case. In contrast to [func@GLib.test_add_data_func], this function is freeing @test_data after the test run is complete.
testpath is a /-separated name for the test.test_data is data for @test_func.test_func is the test function to invoke for this test.data_free_func is #GDestroyNotify for @test_data.None.test_add_func (string testpath, object test_func)
Creates a new test case. This function is similar to [func@GLib.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 /-separated portions of @testpath. If
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 [func@GLib.test_trap_subprocess]. No component of @testpath may start with a dot (.) if the [const@GLib.TEST_OPTION_ISOLATE_DIRS] option is being used; and it is recommended to do so even if it isn’t.testpath is a /-separated name for the test.test_func is the test function to invoke for this test.None.test_add_vtable (string testpath, int data_size, test_data, object data_setup, object data_test, object data_teardown)
Generated wrapper for GIR function
test_add_vtable. Native symbol:g_test_add_vtable.
None.test_assert_expected_messages_internal (string domain, string file, int line, string func)
Generated wrapper for GIR function
test_assert_expected_messages_internal. Native symbol:g_test_assert_expected_messages_internal.
None.test_bug (string bug_uri_snippet)
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 [func@GLib.test_bug_base] and @bug_uri_snippet. If [func@GLib.test_bug_base] has not been called, it is assumed to be the empty string, so a full URI can be provided to [func@GLib.test_bug] instead. See also [func@GLib.test_summary]. Since GLib 2.70, the base URI is not prepended to @bug_uri_snippet if it is already a valid URI.
bug_uri_snippet is Bug specific bug tracker URI or URI portion..None.test_bug_base (string uri_pattern)
Specifies the base URI for bug reports. The base URI is used to construct bug report messages for [func@GLib.test_message] when [func@GLib.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
or by replacing the special string %s within @uri_pattern if that is present. If [func@GLib.test_bug_base] is not called, bug URIs are formed solely from the value provided by [func@GLib.test_bug].uri_pattern is the base pattern for bug URIs.None.test_build_filename (string file_type, string first_path, list varargs)
Creates the pathname to a data file that is required for a test. This function is conceptually similar to [func@GLib.build_filename] except that the first argument has been replaced with a [enum@GLib.TestFileType] argument. The data file should either have been distributed with the module containing the test ([enum@GLib.TestFileType.dist] or built as part of the buildcsystem of that module ([enum@GLib.TestFileType.built]). In order for this function to work in srcdir != builddir situations, the
G_TEST_SRCDIRandG_TEST_BUILDDIRenvironment variables need to have been defined. As of 2.38, this is done by the glib.mk that is 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 ofargv[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.
file_type is the type of file (built vs. distributed).first_path is the first segment of the pathname.... is NULL-terminated additional path segments.the path of the file, to be freed using [func@GLib.free].test_create_case (string test_name, int data_size, test_data, object data_setup, object data_test, object data_teardown)
Creates a new [struct@GLib.TestCase]. This API is fairly low level, and calling [func@GLib.test_add] or [func@GLib.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, [func@GLib.test_create_case] will be called with the same type of fixture (the @data_size argument), but varying @test_name and @data_test arguments.
test_name is the name for the test case.data_size is the size of the fixture data structure.test_data is test data argument for the test functions.data_setup is the function to set up the fixture data.data_test is the actual test function.data_teardown is the function to teardown the fixture data.a newly allocated test case.test_create_suite (string suite_name)
Creates a new test suite with the name @suite_name.
suite_name is a name for the suite.a newly allocated test suite.test_disable_crash_reporting ()
Attempts to disable system crash reporting infrastructure. This function should be called before exercising code paths that are expected or intended to crash, to avoid wasting resources in system-wide crash collection infrastructure such as systemd-coredump or abrt.
None.test_expect_message (string log_domain, string log_level, string 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 ([func@GLib.log] without
G_LOG_USE_STRUCTUREDdefined). It will not work with the structured logging API. See Testing for Messages. Use [func@GLib.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 [func@GLib.test_expect_message].) For example: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 [func@GLib.error] messages, since [func@GLib.error] intentionally never returns even if the program doesn’t abort; use [func@GLib.test_trap_subprocess] in this case. If messages at [flags@GLib.LogLevelFlags.LEVEL_DEBUG] are emitted, but not explicitly expected via [func@GLib.test_expect_message] then they will be ignored.
log_domain is the log domain of the message.log_level is the log level of the message.pattern is a glob-style pattern (see [type@GLib.PatternSpec]).None.test_fail ()
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 [func@GLib.test_skip] and [func@GLib.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 [func@GLib.test_message] before [func@GLib.test_fail], or use [func@GLib.test_fail_printf] instead.
None.test_fail_printf (string format, list varargs)
Indicates that a test failed and records a message. Also see [func@GLib.test_fail]. The message is formatted as if by [func@GLib.strdup_printf].
format is the format string.... is printf-like arguments to @format.None.test_failed ()
Returns whether a test has already failed. This will be the case when [func@GLib.test_fail], [func@GLib.test_incomplete] or [func@GLib.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.
true if the test has failed.test_get_dir (string 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.
file_type is the type of file (built vs. distributed).the path of the directory, owned by GLib.test_get_filename (string file_type, string first_path, list varargs)
Gets the pathname to a data file that is required for a test. This is the same as [func@GLib.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).
file_type is the type of file (built vs. distributed).first_path is the first segment of the pathname.... is NULL-terminated additional path segments.the path, automatically freed at the end of the testcase.test_get_path ()
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. [func@GLib.test_add] when the test was added. This function returns a valid string only within a test function. Note that this is a test path, not a file system path.
the test path for the test currently being run.test_get_root ()
Gets the toplevel test suite for the test path API.
the toplevel test suite.test_incomplete (string 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.
msg is explanation.None.test_incomplete_printf (string format, list varargs)
Indicates that a test failed because of some incomplete functionality. Equivalent to [func@GLib.test_incomplete], but the explanation is formatted as if by [func@GLib.strdup_printf].
format is the format string.... is printf-like arguments to @format.None.test_init (int argc, string argv, list varargs)
Initializes the GLib testing framework. This includes seeding the test random number generator, setting the program name, and parsing test-related commandline args. This should be called before calling any other
g_test_*()functions. The following arguments are understood: --l: List test cases available in a test executable. ---seed=SEED: Provide a random seed to reproduce test runs using random numbers. ---verbose: Run tests verbosely. --q,--quiet: Run tests quietly. --p PATH: Execute all tests matching the given path. --s PATH: Skip all tests matching the given path. This can also be used to force a test to run that would otherwise be skipped (ie, a test whose name contains "/subprocess"). --m {perf|slow|thorough|quick|undefined|no-undefined}: Execute tests according to these test modes:perf: Performance tests, may take long and report results (off by default).slow,thorough: Slow and thorough tests, may take quite long and maximize coverage (off by default).quick: Quick tests, should run really quickly and give good coverage (the default).undefined: Tests for undefined behaviour, may provoke programming errors under [func@GLib.test_trap_subprocess] or [func@GLib.test_expect_message] to check that appropriate assertions or warnings are given (the default).no-undefined: Avoid tests for undefined behaviour. ---debug-log: Debug test logging output. Any parsed arguments are removed from @argv, and @argc is adjust accordingly. The following options are supported: -G_TEST_OPTION_NO_PRGNAME: Causes g_test_init() to not call [func@GLib.set_prgname]. Since. 2.84 -G_TEST_OPTION_ISOLATE_DIRS: Creates a unique temporary directory for each unit test and sets XDG directories to point there for the duration of the unit test. See [const@GLib.TEST_OPTION_ISOLATE_DIRS]. -G_TEST_OPTION_NONFATAL_ASSERTIONS: This has the same effect as [func@GLib.test_set_nonfatal_assertions]. Since 2.84 Since 2.58, if tests are compiled withG_DISABLE_ASSERTdefined,g_test_init()will print an error and exit. This is to prevent no-op tests from being executed, as [func@GLib.assert] is commonly (erroneously) used in unit tests, and is a no-op when compiled withG_DISABLE_ASSERT. Ensure your tests are compiled withoutG_DISABLE_ASSERTdefined.
argc is address of the @argc parameter of main().argv is address of the @argv parameter of main().... is NULL-terminated list of special options.None.test_log_set_fatal_handler (object log_func)
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 [func@GLib.log_structured] or [func@GLib.log_structured_array]). To change the fatal behaviour for specific log messages, programs must install a custom log writer function using [func@GLib.log_set_writer_func].See Using Structured Logging.
log_func is the log handler function..user_data is data passed to the log handler..None.test_log_type_name (string log_type)
Generated wrapper for GIR function
test_log_type_name. Native symbol:g_test_log_type_name.
test_maximized_result (double maximized_quantity, string format, list varargs)
Reports 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.
maximized_quantity is the reported value.format is the format string of the report message.... is printf-like arguments to @format.None.test_message (string format, list varargs)
Adds a message to the test report.
format is the format string.... is printf-like arguments to @format.None.test_minimized_result (double minimized_quantity, string format, list varargs)
Reports 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.
minimized_quantity is the reported value.format is the format string of the report message.... is printf-like arguments to @format.None.test_queue_destroy (object destroy_func, destroy_data)
Enqueues a callback @destroy_func to be executed during the next test case teardown phase. This is most useful to auto destroy allocated test resources at the end of a test run. Resources are released in reverse queue order, that means enqueueing callback
Abefore callbackBwill causeB()to be called beforeA()during teardown.
destroy_func is destroy callback for teardown phase.destroy_data is destroy callback data.None.test_queue_free (gfree_pointer)
Enqueues a pointer to be released with [func@GLib.free] during the next teardown phase. This is equivalent to calling [func@GLib.test_queue_destroy] with a destroy callback of [func@GLib.free].
gfree_pointer is the pointer to be stored.None.test_rand_double ()
Gets a reproducible random floating point number. See [func@GLib.test_rand_int] for details on test case random numbers.
a random number from the seeded random number generator.test_rand_double_range (double range_start, double range_end)
Gets a reproducible random floating point number out of a specified range. See [func@GLib.test_rand_int] for details on test case random numbers.
range_start is the minimum value returned by this function.range_end is the minimum value not returned by this function.a number with @range_start <= number < @range_end.test_rand_int ()
Gets 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.
a random number from the seeded random number generator.test_rand_int_range (int begin, int end)
Gets a reproducible random integer number out of a specified range. See [func@GLib.test_rand_int] for details on test case random numbers.
begin is the minimum value returned by this function.end is the smallest value not to be returned by this function.a number with @begin <= number < @end.test_run ()
Runs all tests under the toplevel suite. The toplevel suite can be retrieved with [func@GLib.test_get_root]. Similar to [func@GLib.test_run_suite], the test cases to be run are filtered according to test path arguments (
-p testpathand-s testpath) as parsed by [func@GLib.test_init]. [func@GLib.test_run_suite] or [func@GLib.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 theg_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 [func@GLib.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 [func@GLib.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.
0 on success, 1 on failure (assuming it returns at all), 0 or 77 if all tests were skipped or marked as incomplete.test_run_suite (object suite)
Executes the tests within @suite and all nested test suites. The test suites to be executed are filtered according to test path arguments (
-p testpathand-s testpath) as parsed by [func@GLib.test_init]. See the [func@GLib.test_run] documentation for more information on the order that tests are run in. [func@GLib.test_run_suite] or [func@GLib.test_run] may only be called once in a program.
suite is a test suite.0 on success.test_set_nonfatal_assertions ()
Changes the behaviour of the various assertion macros. The
g_assert_*()macros,g_test_assert_expected_messages()and the variousg_test_trap_assert_*()macros are changed to not abort to program. Instead, they will call [func@GLib.test_fail] and continue. (This also changes the behavior of [func@GLib.test_fail] so that it will not cause the test program to abort after completing the failed test.) Note that the [func@GLib.assert_not_reached] and [func@GLib.assert] macros are not affected by this. This function can only be called after [func@GLib.test_init].
None.test_skip (string 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.
msg is explanation.None.test_skip_printf (string format, list varargs)
Indicates that a test was skipped. Equivalent to [func@GLib.test_skip], but the explanation is formatted as if by [func@GLib.strdup_printf].
format is the format string.... is printf-like arguments to @format.None.test_subprocess ()
Returns true if the test program is running under [func@GLib.test_trap_subprocess].
true if the test program is running under [func@GLib.test_trap_subprocess].test_summary (string summary)
Sets the summary for a test. 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, and it should summarise what the test checks, and how. This should be called at the top of a test function. For example:
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."); // ... }See also [func@GLib.test_bug].
summary is summary of the test purpose.None.test_timer_elapsed ()
Gets the number of seconds since the last start of the timer with [func@GLib.test_timer_start].
the time since the last start of the timer in seconds.test_timer_last ()
Reports the last result of [func@GLib.test_timer_elapsed].
the last result of [func@GLib.test_timer_elapsed].test_timer_start ()
Starts a timing test. Call [func@GLib.test_timer_elapsed] when the task is supposed to be done. Call this function again to restart the timer.
None.test_trap_assertions (string domain, string file, int line, string func, int assertion_flags, string pattern)
Generated wrapper for GIR function
test_trap_assertions. Native symbol:g_test_trap_assertions.
None.test_trap_fork (int usec_timeout, string test_trap_flags)
Forks the current test program to execute a test case that might not return or that might abort. If @usec_timeout is non-0, the forked test case is aborted and considered failing if its run time exceeds it. The forking behavior can be configured with [flags@GLib.TestTrapFlags] flags. In the following example, the test code forks, the forked child process produces some sample output and exits successfully. The forking parent process then asserts successful child program termination and validates child program outputs.
c static void test_fork_patterns (void) { if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR)) { g_print ("some stdout text: somagic17 "); g_printerr ("some stderr text: semagic43 "); exit (0); // successful test run } g_test_trap_assert_passed (); g_test_trap_assert_stdout ("*somagic17*"); g_test_trap_assert_stderr ("*semagic43*"); }
usec_timeout is timeout for the forked test in microseconds.test_trap_flags is flags to modify forking behaviour.true for the forked child and false for the executing parent process..test_trap_has_passed ()
Checks the result of the last [func@GLib.test_trap_subprocess] call.
true if the last test subprocess terminated successfully.test_trap_has_skipped ()
Checks the result of the last [func@GLib.test_trap_subprocess] call.
true if the last test subprocess was skipped.test_trap_reached_timeout ()
Checks the result of the last [func@GLib.test_trap_subprocess] call.
true if the last test subprocess got killed due to a timeout.test_trap_subprocess (string test_path, int usec_timeout, string test_flags)
Respawns the test program to run only @test_path in a subprocess. This is equivalent to calling [func@GLib.test_trap_subprocess_with_envp] with
envpset toNULL. See the documentation for that function for full details.
test_path is test to run in a subprocess.usec_timeout is timeout for the subprocess test in microseconds..test_flags is flags to modify subprocess behaviour.None.test_trap_subprocess_with_envp (string test_path, list envp, int usec_timeout, string test_flags)
Respawns the test program to run only @test_path in a subprocess with a given environment. This can be used for a test case that might not return, or that might abort. If @test_path is
NULLthen the same test is re-run in a subprocess. You can use [func@GLib.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 @envp isNULL, the parent process’ environment will be inherited. 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 [flags@GLib.TestSubprocessFlags] flags. You can use methods such as [func@GLib.test_trap_assert_passed], [func@GLib.test_trap_assert_failed], and [func@GLib.test_trap_assert_stderr] to check the results of the subprocess. (But note that [func@GLib.test_trap_assert_stdout] and [func@GLib.test_trap_assert_stderr] cannot be used if @test_flags specifies that the child should inherit the parent stdout/stderr.) If yourmain ()needs to behave differently in the subprocess, you can call [func@GLib.test_subprocess] (after calling [func@GLib.test_init]) to see whether you are in a subprocess. Internally, this function tracks the child process using [func@GLib.child_watch_source_new], so your process must not ignoreSIGCHLD, and must not attempt to watch or wait for the child process via another mechanism. The following example tests that callingmy_object_new(1000000)will abort with an error message.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*"); } static void test_different_username (void) { if (g_test_subprocess ()) { // Code under test goes here g_message ("Username is now simulated as %s", g_getenv ("USER")); return; } // Reruns this same test in a subprocess g_auto(GStrv) envp = g_get_environ (); envp = g_environ_setenv (g_steal_pointer (&envp), "USER", "charlie", TRUE); g_test_trap_subprocess_with_envp (NULL, envp, 0, G_TEST_SUBPROCESS_DEFAULT); g_test_trap_assert_passed (); g_test_trap_assert_stdout ("Username is now simulated as charlie"); } int main (int argc, char **argv) { g_test_init (&argc, &argv, NULL); g_test_add_func ("/myobject/create-large-object", test_create_large_object); g_test_add_func ("/myobject/different-username", test_different_username); return g_test_run (); }
test_path is test to run in a subprocess.envp is environment to run the test in.usec_timeout is timeout for the subprocess test in microseconds.test_flags is flags to modify subprocess behaviour.None.thread_create (object func, bool joinable)
This function creates a new thread. The new thread executes the function
with the argument @data. If the thread was created successfully, it is returned. @error can be %NULL to ignore errors, or non-%NULL to report errors. The error is set, if and only if the function returns %NULL. This function returns a reference to the created thread only if @joinable is %TRUE. In that case, you must free this reference by calling g_thread_unref() or g_thread_join(). If @joinable is %FALSE then you should probably not touch the return value.func is a function to execute in the new thread.data is an argument to supply to the new thread.joinable is should this thread be joinable?.the new #GThread on success.thread_create_full (object func, int stack_size, bool joinable, bool bound, string priority)
This function creates a new thread.
func is a function to execute in the new thread..data is an argument to supply to the new thread..stack_size is a stack size for the new thread..joinable is should this thread be joinable?.bound is ignored.priority is ignored.the new #GThread on success..thread_exit (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
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.retval is the return value of this thread.None.thread_foreach (object thread_func)
Call @thread_func on all #GThreads that have been created with g_thread_create(). Note that threads may decide to exit while
is running, so without intimate knowledge about the lifetime of foreign threads, @thread_func shouldn't access the GThread* pointer passed in as first argument. However, @thread_func will not be called for threads which are known to have exited already. Due to thread lifetime checks, this function has an execution complexity which is quadratic in the number of existing threads.thread_func is function to call for all #GThread structures.user_data is second argument to @thread_func.None.thread_get_initialized ()
Indicates if g_thread_init() has been called.
%TRUE if threads have been initialized..thread_init (vtable)
If you use GLib from more than one thread, you must initialize the thread system by calling g_thread_init(). Since version 2.24, calling g_thread_init() multiple times is allowed, but nothing happens except for the first call. Since version 2.32, GLib does not support custom thread implementations anymore and the @vtable parameter is ignored and you should pass %NULL. ::: note g_thread_init() must not be called directly or indirectly in a callback from GLib. Also no mutexes may be currently locked while calling g_thread_init(). ::: note To use g_thread_init() in your program, you have to link with the libraries that the command
pkg-config --libs gthread-2.0outputs. This is not the case for all the other thread-related functions of GLib. Those can be used without having to link with the thread libraries.
vtable is a function table of type #GThreadFunctions, that provides the entry points to the thread system to be used. Since 2.32, this parameter is ignored and should always be %NULL.None.thread_init_with_errorcheck_mutexes (vtable)
Generated wrapper for GIR function
thread_init_with_errorcheck_mutexes. Native symbol:g_thread_init_with_errorcheck_mutexes.
None.thread_pool_get_max_idle_time ()
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.
the maximum @interval (milliseconds) to wait for new tasks in the thread pool before stopping the thread.thread_pool_get_max_unused_threads ()
Returns the maximal allowed number of unused threads.
the maximal number of unused threads.thread_pool_get_num_unused_threads ()
Returns the number of currently unused threads.
the number of currently unused threads.thread_pool_set_max_idle_time (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).
interval is the maximum @interval (in milliseconds) a thread can be idle.None.thread_pool_set_max_unused_threads (int max_threads)
Sets the maximal number of unused threads to @max_threads. If
is -1, no limit is imposed on the number of unused threads. The default value is 8 since GLib 2.84. Previously the default value was 2.max_threads is maximal number of unused threads.None.thread_pool_stop_unused_threads ()
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().
None.thread_self ()
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.
the #GThread representing the current thread.thread_yield ()
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.
None.time_val_from_iso8601 (string iso_date)
Converts a string containing an ISO 8601 encoded date and time to a #GTimeVal and puts it into @time_. @iso_date must include year, month, day, hours, minutes, and seconds. It can optionally include fractions of a second and a time zone indicator. (In the absence of any time zone indication, the timestamp is assumed to be in local time.) Any leading or trailing space in @iso_date is ignored. This function was deprecated, along with #GTimeVal itself, in GLib 2.62. Equivalent functionality is available using code like: |[ GDateTime *dt = g_date_time_new_from_iso8601 (iso8601_string, NULL); gint64 time_val = g_date_time_to_unix (dt); g_date_time_unref (dt); ]|
iso_date is an ISO 8601 encoded date string.time_ is a #GTimeVal.%TRUE if the conversion was successful..timeout_add (int interval, object function)
Sets a function to be called at regular intervals, with the default priority, [const@GLib.PRIORITY_DEFAULT]. The given @function is called repeatedly until it returns [const@GLib.SOURCE_REMOVE], 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 main loop 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 [func@GLib.timeout_add_seconds] function; this function allows for more optimizations and more efficient system power usage. This internally creates a main loop source using [func@GLib.timeout_source_new] and attaches it to the global [struct@GLib.MainContext] using [method@GLib.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 [func@GLib.get_monotonic_time].
interval is the time between calls to the function, in milliseconds.function is function to call.data is data to pass to @function.the ID (greater than 0) of the event source.timeout_add_full (int priority, int interval, object function)
Sets a function to be called at regular intervals, with the given priority. The function is called repeatedly until it returns [const@GLib.SOURCE_REMOVE], 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 main loop memory management for details on how to handle the return value and memory management of @data. This internally creates a main loop source using [func@GLib.timeout_source_new] and attaches it to the global [struct@GLib.MainContext] using [method@GLib.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 [func@GLib.get_monotonic_time].
priority is the priority of the timeout source; typically this will be in the range between [const@GLib.PRIORITY_DEFAULT] and [const@GLib.PRIORITY_HIGH].interval is the time between calls to the function, in milliseconds.function is function to call.data is data to pass to @function.notify is function to call when the timeout is removed.the ID (greater than 0) of the event source.timeout_add_once (int interval, object function)
Sets a function to be called after @interval milliseconds have elapsed, with the default priority, [const@GLib.PRIORITY_DEFAULT]. The given
is called once and then the source will be automatically removed from the main context. This function otherwise behaves like [func@GLib.timeout_add].interval is the time after which the function will be called, in milliseconds.function is function to call.data is data to pass to @function.the ID (greater than 0) of the event source.timeout_add_seconds (int interval, object function)
Sets a function to be called at regular intervals with the default priority, [const@GLib.PRIORITY_DEFAULT]. The function is called repeatedly until it returns [const@GLib.SOURCE_REMOVE], at which point the timeout is automatically destroyed and the function will not be called again. This internally creates a main loop source using [func@GLib.timeout_source_new_seconds] and attaches it to the main loop context using [method@GLib.Source.attach]. You can do these steps manually if you need greater control. Also see [func@GLib.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 [func@GLib.timeout_add] instead. See main loop 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 [func@GLib.get_monotonic_time].
interval is the time between calls to the function, in seconds.function is function to call.data is data to pass to @function.the ID (greater than 0) of the event source.timeout_add_seconds_full (int priority, int interval, object function)
Sets a function to be called at regular intervals, with @priority. The function is called repeatedly until it returns [const@GLib.SOURCE_REMOVE], at which point the timeout is automatically destroyed and the function will not be called again. Unlike [func@GLib.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 main loop 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 [func@GLib.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 [func@GLib.timeout_add_seconds] is preferred over [func@GLib.timeout_add]. This internally creates a main loop source using [func@GLib.timeout_source_new_seconds] and attaches it to the main loop context using [method@GLib.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 [func@GLib.get_monotonic_time].
priority is the priority of the timeout source; typically this will be in the range between [const@GLib.PRIORITY_DEFAULT] and [const@GLib.PRIORITY_HIGH].interval is the time between calls to the function, in seconds.function is function to call.data is data to pass to @function.notify is function to call when the timeout is removed.the ID (greater than 0) of the event source.timeout_add_seconds_once (int interval, object function)
This function behaves like [func@GLib.timeout_add_once] but with a range in seconds.
interval is the time after which the function will be called, in seconds.function is function to call.data is data to pass to @function.the ID (greater than 0) of the event source.timeout_source_new (int interval)
Creates a new timeout source. The source will not initially be associated with any [struct@GLib.MainContext] and must be added to one with [method@GLib.Source.attach] before it will be executed. The interval given is in terms of monotonic time, not wall clock time. See [func@GLib.get_monotonic_time].
interval is the timeout interval in milliseconds.the newly-created timeout source.timeout_source_new_seconds (int interval)
Creates a new timeout source. The source will not initially be associated with any [struct@GLib.MainContext] and must be added to one with [method@GLib.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 [func@GLib.get_monotonic_time].
interval is the timeout interval in seconds.the newly-created timeout source.trash_stack_height (object stack_p)
Returns the height of a #GTrashStack. Note that execution of this function is of O(N) complexity where N denotes the number of items on the stack.
stack_p is a #GTrashStack.the height of the stack.trash_stack_peek (object stack_p)
Returns the element at the top of a #GTrashStack which may be %NULL.
stack_p is a #GTrashStack.the element at the top of the stack.trash_stack_pop (object stack_p)
Pops a piece of memory off a #GTrashStack.
stack_p is a #GTrashStack.the element at the top of the stack.trash_stack_push (object stack_p, data_p)
Pushes a piece of memory onto a #GTrashStack.
stack_p is a #GTrashStack.data_p is the piece of memory to push on the stack.None.try_malloc (int n_bytes)
Attempts to allocate @n_bytes, and returns %NULL on failure. Contrast with g_malloc(), which aborts the program on failure.
n_bytes is number of bytes to allocate..the allocated memory, or %NULL..try_malloc0 (int 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.
n_bytes is number of bytes to allocate.the allocated memory, or %NULL.try_malloc0_n (int n_blocks, int n_block_bytes)
This function is similar to g_try_malloc0(), allocating (@n_blocks *
bytes, but care is taken to detect possible overflow during multiplication.n_blocks is the number of blocks to allocate.n_block_bytes is the size of each block in bytes.the allocated memory, or %NULL.try_malloc_n (int n_blocks, int n_block_bytes)
This function is similar to g_try_malloc(), allocating (@n_blocks *
bytes, but care is taken to detect possible overflow during multiplication.n_blocks is the number of blocks to allocate.n_block_bytes is the size of each block in bytes.the allocated memory, or %NULL..try_realloc (mem, int 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().
mem is previously-allocated memory, or %NULL..n_bytes is number of bytes to allocate..the allocated memory, or %NULL..try_realloc_n (mem, int n_blocks, int n_block_bytes)
This function is similar to g_try_realloc(), allocating (@n_blocks *
bytes, but care is taken to detect possible overflow during multiplication.mem is previously-allocated memory, or %NULL..n_blocks is the number of blocks to allocate.n_block_bytes is the size of each block in bytes.the allocated memory, or %NULL..ucs4_to_utf16 (list str)
Convert a string from UCS-4 to UTF-16. A nul character (U+0000) will be added to the result after the converted text.
str is a UCS-4 encoded string.len is the maximum length (number of characters) of @str to use. Ifis negative, then the string is nul-terminated..items_read is location to store number of bytes read, or NULL to ignore. If an error occurs then the index of the invalid input is stored here. The value stored here will never be negative..items_written is location to store number of gunichar2 written, or NULL to ignore. The value stored here does not include the trailing nul, and will never be negative..a pointer to a newly allocated UTF-16 string. This value must be freed with [func@GLib.free]..ucs4_to_utf8 (list str)
Convert a string from a 32-bit fixed width representation as UCS-4. to UTF-8. The result will be terminated with a nul byte.
str is a UCS-4 encoded string.len is the maximum length (number of characters) of @str to use. Ifis negative, then the string is nul-terminated..items_read is location to store number of characters read, or NULL to ignore. If an error occurs then the index of the invalid input is stored here. The value stored here will never be negative..items_written is location to store number of bytes written, or NULL to ignore. The value stored here does not include the trailing nul, and will never be negative..a pointer to a newly allocated UTF-8 string. This value must be freed with [func@GLib.free]..unichar_break_type (int 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.
c is a Unicode character.the break type of @c.unichar_combining_class (int uc)
Determines the canonical combining class of a Unicode character.
uc is a Unicode character.the combining class of the character.unichar_compose (int a, int b)
Performs a single composition step of the Unicode canonical composition algorithm. This function includes algorithmic Hangul Jamo composition, but it is not exactly the inverse of g_unichar_decompose(). No composition can have either of @a or @b equal to zero. To be precise, this function composes if and only if there exists a Primary Composite P which is canonically equivalent to the sequence <@a,@b>. See the Unicode Standard for the definition of Primary Composite. If @a and @b do not compose a new character, @ch is set to zero. See UAX#15 for details.
a is a Unicode character.b is a Unicode character.ch is return location for the composed character.%TRUE if the characters could be composed.unichar_decompose (int ch)
Performs a single decomposition step of the Unicode canonical decomposition algorithm. This function does not include compatibility decompositions. It does, however, include algorithmic Hangul Jamo decomposition, as well as 'singleton' decompositions which replace a character by a single other character. In the case of singletons
*bwill be set to zero. If @ch is not decomposable,*ais set to @ch and*bis set to zero. Note that the way Unicode decomposition pairs are defined, it is guaranteed that @b would not decompose further, but @a may itself decompose. To get the full canonical decomposition for @ch, one would need to recursively call this function on @a. Or use g_unichar_fully_decompose(). See UAX#15 for details.
ch is a Unicode character.a is return location for the first component of @ch.b is return location for the second component of @ch.%TRUE if the character could be decomposed.unichar_digit_value (int c)
Determines the numeric value of a character as a decimal digit.
c is a Unicode character.If @c is a decimal digit (according to g_unichar_isdigit()), its numeric value. Otherwise, -1..unichar_fully_decompose (int ch, bool compat, int result_len)
Computes the canonical or compatibility decomposition of a Unicode character. For compatibility decomposition, pass %TRUE for @compat; for canonical decomposition pass %FALSE for @compat. The decomposed sequence is placed in @result. Only up to @result_len characters are written into
The length of the full decomposition (irrespective ofis returned by the function. For canonical decomposition, currently all decompositions are of length at most 4, but this may change in the future (very unlikely though). At any rate, Unicode does guarantee that a buffer of length 18 is always enough for both compatibility and canonical decompositions, so that is the size recommended. This is provided as %G_UNICHAR_MAX_DECOMPOSITION_LENGTH. See UAX#15 for details.ch is a Unicode character..compat is whether perform canonical or compatibility decomposition.result is location to store decomposed result, or %NULL.result_len is length of @result.the length of the full decomposition..unichar_get_mirror_char (int ch)
In Unicode, some characters are "mirrored". This means that their images are mirrored horizontally in text that is laid out from right to left. For instance, "(" would become its mirror image, ")", in right-to-left text. If @ch has the Unicode mirrored property and there is another unicode character that typically has a glyph that is the mirror image of
glyph and @mirrored_ch is set, it puts that character in the address pointed to by @mirrored_ch. Otherwise the original character is put.ch is a Unicode character.mirrored_ch is location to store the mirrored character.%TRUE if @ch has a mirrored character, %FALSE otherwise.unichar_get_script (int 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.
ch is a Unicode character.the #GUnicodeScript for the character..unichar_isalnum (int c)
Determines whether a character is alphanumeric. Given some UTF-8 text, obtain a character value with g_utf8_get_char().
c is a Unicode character.%TRUE if @c is an alphanumeric character.unichar_isalpha (int 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().
c is a Unicode character.%TRUE if @c is an alphabetic character.unichar_iscntrl (int c)
Determines whether a character is a control character. Given some UTF-8 text, obtain a character value with g_utf8_get_char().
c is a Unicode character.%TRUE if @c is a control character.unichar_isdefined (int c)
Determines if a given character is assigned in the Unicode standard.
c is a Unicode character.%TRUE if the character has an assigned value.unichar_isdigit (int 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().
c is a Unicode character.%TRUE if @c is a digit.unichar_isgraph (int 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().
c is a Unicode character.%TRUE if @c is printable unless it's a space.unichar_islower (int c)
Determines whether a character is a lowercase letter. Given some UTF-8 text, obtain a character value with g_utf8_get_char().
c is a Unicode character.%TRUE if @c is a lowercase letter.unichar_ismark (int 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.
c is a Unicode character.%TRUE if @c is a mark character.unichar_isprint (int 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().
c is a Unicode character.%TRUE if @c is printable.unichar_ispunct (int c)
Determines whether a character is punctuation or a symbol. Given some UTF-8 text, obtain a character value with g_utf8_get_char().
c is a Unicode character.%TRUE if @c is a punctuation or symbol character.unichar_isspace (int 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.)
c is a Unicode character.%TRUE if @c is a space character.unichar_istitle (int 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.
c is a Unicode character.%TRUE if the character is titlecase.unichar_isupper (int c)
Determines if a character is uppercase.
c is a Unicode character.%TRUE if @c is an uppercase character.unichar_iswide (int c)
Determines if a character is typically rendered in a double-width cell.
c is a Unicode character.%TRUE if the character is wide.unichar_iswide_cjk (int 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 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().
c is a Unicode character.%TRUE if the character is wide in legacy East Asian locales.unichar_isxdigit (int c)
Determines if a character is a hexadecimal digit.
c is a Unicode character..%TRUE if the character is a hexadecimal digit.unichar_iszerowidth (int 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.
c is a Unicode character.%TRUE if the character has zero width.unichar_to_utf8 (int c)
Converts a single character to UTF-8.
c is a Unicode character code.outbuf is 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..number of bytes written, guaranteed to be in the range [1, 6].unichar_tolower (int c)
Converts a character to lower case.
c is a Unicode character..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..unichar_totitle (int c)
Converts a character to the titlecase.
c is a Unicode character.the result of converting @c to titlecase. If @c is not an uppercase or lowercase character, @c is returned unchanged..unichar_toupper (int c)
Converts a character to uppercase.
c is a Unicode character.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..unichar_type (int c)
Classifies a Unicode character by type.
c is a Unicode character.the type of the character..unichar_validate (int ch)
Checks whether @ch is a valid Unicode character. Some possible integer values of @ch will not be valid. U+0000 is considered a valid character, though it’s normally a string terminator.
ch is a Unicode character.TRUE if @ch is a valid Unicode character.unichar_xdigit_value (int c)
Determines the numeric value of a character as a hexadecimal digit.
c is a Unicode character.If @c is a hex digit (according to g_unichar_isxdigit()), its numeric value. Otherwise, -1..unicode_canonical_decomposition (int ch, int result_len)
Computes the canonical decomposition of a Unicode character.
ch is a Unicode character..result_len is location to store the length of the return value..a newly allocated string of Unicode characters. @result_len is set to the resulting length of the string..unicode_canonical_ordering (list arg0String)
Computes the canonical ordering of a string in-place. This rearranges decomposed characters in the string according to their combining classes. See the Unicode manual for more information.
string is a UCS-4 encoded string..len is the maximum length of @string to use..None.unicode_script_from_iso15924 (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 for details.
iso15924 is a Unicode script.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..unicode_script_to_iso15924 (string 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 for details.
script is a Unicode script.the ISO 15924 code for @script, encoded as an integer, of zero ifis %G_UNICODE_SCRIPT_INVALID_CODE or ISO 15924 code 'Zzzz' (script code for UNKNOWN) if @script is not understood..unlink (string 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.
filename is a pathname in the GLib file name encoding (UTF-8 on Windows).0 if the name was successfully deleted, -1 if an error occurred.unsetenv (string 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.
variable is the environment variable to remove, must not contain '='.None.uri_build (string flags, string scheme, string userinfo, string host, int port, string path, string query, string 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.
flags is flags describing how to build the #GUri.scheme is the URI scheme.userinfo is the userinfo component, or %NULL.host is the host component, or %NULL.port is the port, or -1.path is the path component.query is the query component, or %NULL.fragment is the fragment, or %NULL.a new #GUri.uri_build_with_user (string flags, string scheme, string user, string password, string auth_params, string host, int port, string path, string query, string 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
must be non-%NULL if either @password or @auth_params is non-%NULL.flags is flags describing how to build the #GUri.scheme is the URI scheme.user is the user component of the userinfo, or %NULL.password is the password component of the userinfo, or %NULL.auth_params is the auth params of the userinfo, or %NULL.host is the host component, or %NULL.port is the port, or -1.path is the path component.query is the query component, or %NULL.fragment is the fragment, or %NULL.a new #GUri.uri_escape_bytes (list unescaped, string reserved_chars_allowed)
Escapes arbitrary data 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
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. Though technically incorrect, this will also allow escaping nul bytes as %``00.unescaped is the unescaped input data..length is the length of @unescaped.reserved_chars_allowed is a string of reserved characters that are allowed to be used, or %NULL..an escaped version of @unescaped. The returned string should be freed when no longer needed..uri_escape_string (string unescaped, string reserved_chars_allowed, bool 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
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.unescaped is the unescaped input string..reserved_chars_allowed is a string of reserved characters that are allowed to be used, or %NULL..allow_utf8 is %TRUE if the result can include UTF-8 characters..an escaped version of @unescaped. The returned string should be freed when no longer needed..uri_is_valid (string uri_string, string flags)
Parses @uri_string according to @flags, to determine whether it is a valid absolute URI, 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.
uri_string is a string containing an absolute URI.flags is flags for parsing @uri_string.%TRUE if @uri_string is a valid absolute URI, %FALSE on error..uri_join (string flags, string scheme, string userinfo, string host, int port, string path, string query, string 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. 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.
flags is flags describing how to build the URI string.scheme is the URI scheme, or %NULL.userinfo is the userinfo component, or %NULL.host is the host component, or %NULL.port is the port, or -1.path is the path component.query is the query component, or %NULL.fragment is the fragment, or %NULL.an absolute URI string.uri_join_with_user (string flags, string scheme, string user, string password, string auth_params, string host, int port, string path, string query, string 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.
flags is flags describing how to build the URI string.scheme is the URI scheme, or %NULL.user is the user component of the userinfo, or %NULL.password is the password component of the userinfo, or %NULL.auth_params is the auth params of the userinfo, or %NULL.host is the host component, or %NULL.port is the port, or -1.path is the path component.query is the query component, or %NULL.fragment is the fragment, or %NULL.an absolute URI string.uri_list_extract_uris (string uri_list)
Splits an URI list conforming to the text/uri-list mime type defined in RFC 2483 into individual URIs, discarding any comments. The URIs are not validated.
uri_list is an URI list.a newly allocated %NULL-terminated list of strings holding the individual URIs. The array should be freed with g_strfreev()..uri_parse (string uri_string, string flags)
Parses @uri_string according to @flags. If the result is not a valid absolute URI, it will be discarded, and an error returned.
uri_string is a string representing an absolute URI.flags is flags describing how to parse @uri_string.a new #GUri, or NULL on error..uri_parse_params (string params, int length, string separators, string flags)
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
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 toattributes 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. Ifcannot be parsed (for example, it contains two @separators characters in a row), then @error is set and %NULL is returned.params is a %-encoded string containing attribute=value parameters.length is the length of @params, or -1 if it is nul-terminated.separators is 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 is flags to modify the way the parameters are handled..A hash table of attribute/value pairs, with both names and values fully-decoded; or %NULL on error..uri_parse_scheme (string uri)
Gets the scheme portion of a URI string. RFC 3986 decodes the scheme as: |[ URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ] ]| Common schemes include
file,https,svn+ssh, etc.
uri is a valid URI..The ‘scheme’ component of the URI, or %NULL on error. The returned string should be freed when no longer needed..uri_peek_scheme (string uri)
Gets the scheme portion of a URI string. RFC 3986 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.
uri is a valid URI..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..uri_resolve_relative (string base_uri_string, string uri_ref, string flags)
Parses @uri_ref according to @flags and, if it is a relative URI, resolves it relative to
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.)base_uri_string is a string representing a base URI.uri_ref is a string representing a relative or absolute URI.flags is flags describing how to parse @uri_ref.the resolved URI string, or NULL on error..uri_split (string uri_ref, string flags)
Parses @uri_ref (which can be an absolute or relative URI) according to @flags, and returns the pieces. Any component that doesn't appear in @uri_ref will be returned as %NULL (but note that all URIs always have a path component, though it may be the empty string). If @flags contains %G_URI_FLAGS_ENCODED, then
%-encoded characters in @uri_ref will remain encoded in the output strings. (If not, then all such characters will be decoded.) Note that decoding will only work if the URI components are ASCII or UTF-8, so you will need to use %G_URI_FLAGS_ENCODED if they are not. Note that the %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS @flags are ignored by g_uri_split(), since it always returns only the full userinfo; use g_uri_split_with_user() if you want it split up.
uri_ref is a string containing a relative or absolute URI.flags is flags for parsing @uri_ref.scheme is on return, contains the scheme (converted to lowercase), or %NULL.userinfo is on return, contains the userinfo, or %NULL.host is on return, contains the host, or %NULL.port is on return, contains the port, or -1.path is on return, contains the path.query is on return, contains the query, or %NULL.fragment is on return, contains the fragment, or %NULL.%TRUE if @uri_ref parsed successfully, %FALSE on error..uri_split_network (string uri_string, string flags)
Parses @uri_string (which must be an absolute URI) according to @flags, and returns the pieces relevant to connecting to a host. See the documentation for g_uri_split() for more details; this is mostly a wrapper around that function with simpler arguments. However, it will return an error if
is a relative URI, or does not contain a hostname component.uri_string is a string containing an absolute URI.flags is flags for parsing @uri_string.scheme is on return, contains the scheme (converted to lowercase), or %NULL.host is on return, contains the host, or %NULL.port is on return, contains the port, or -1.%TRUE if @uri_string parsed successfully, %FALSE on error..uri_split_with_user (string uri_ref, string flags)
Parses @uri_ref (which can be an absolute or relative URI) according to @flags, and returns the pieces. Any component that doesn't appear in @uri_ref will be returned as %NULL (but note that all URIs always have a path component, though it may be the empty string). See g_uri_split(), and the definition of #GUriFlags, for more information on the effect of @flags. Note that
will only be parsed out if @flags contains %G_URI_FLAGS_HAS_PASSWORD, and @auth_params will only be parsed out ifcontains %G_URI_FLAGS_HAS_AUTH_PARAMS.uri_ref is a string containing a relative or absolute URI.flags is flags for parsing @uri_ref.scheme is on return, contains the scheme (converted to lowercase), or %NULL.user is on return, contains the user, or %NULL.password is on return, contains the password, or %NULL.auth_params is on return, contains the auth_params, or %NULL.host is on return, contains the host, or %NULL.port is on return, contains the port, or -1.path is on return, contains the path.query is on return, contains the query, or %NULL.fragment is on return, contains the fragment, or %NULL.%TRUE if @uri_ref parsed successfully, %FALSE on error..uri_unescape_bytes (string escaped_string, int length, string illegal_characters)
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.
escaped_string is A URI-escaped string.length is the length (in bytes) of @escaped_string to escape, or -1 if it is nul-terminated..illegal_characters is a string of illegal characters not to be allowed, or %NULL..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..uri_unescape_segment (string escaped_string, string escaped_string_end, string illegal_characters)
Unescapes a segment of an escaped string. If any of the characters in
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().escaped_string is A string, may be %NULL.escaped_string_end is Pointer to end of @escaped_string, may be %NULL.illegal_characters is An optional string of illegal characters not to be allowed, may be %NULL.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..uri_unescape_string (string escaped_string, string illegal_characters)
Unescapes a whole escaped string. If any of the characters in
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.escaped_string is an escaped string to be unescaped..illegal_characters is a string of illegal characters not to be allowed, or %NULL..an unescaped version of @escaped_string. The returned string should be freed when no longer needed..usleep (int 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.
microseconds is number of microseconds to pause.None.utf16_to_ucs4 (list str)
Convert a string from UTF-16 to UCS-4. The result will be nul-terminated.
str is a UTF-16 encoded string.len is the maximum length (number of #gunichar2) of @str to use. Ifis negative, then the string is nul-terminated..items_read is location to store number of gunichar2 read, or NULL to ignore. If NULL, then [error@GLib.ConvertError.PARTIAL_INPUT] will be returned in case @str contains a trailing partial character. If an error occurs then the index of the invalid input is stored here. The value stored here will never be negative..items_written is location to store number of characters written, or NULL to ignore. The value stored here does not include the trailing nul, and will never be negative..a pointer to a newly allocated UCS-4 string. This value must be freed with [func@GLib.free]..utf16_to_utf8 (list str)
Convert a string from UTF-16 to UTF-8. The result will be terminated with a nul byte. Note that the input is expected to be already in native endianness, an initial byte-order-mark character is not handled specially. [func@GLib.convert] can be used to convert a byte buffer of UTF-16 data of ambiguous endianness. Further note that this function does not validate the result string; it may (for example) include embedded nul characters. The only validation done by this function is to ensure that the input can be correctly interpreted as UTF-16, i.e. it doesn’t contain unpaired surrogates or partial character sequences.
str is a UTF-16 encoded string.len is the maximum length (number of #gunichar2) of @str to use. Ifis negative, then the string is nul-terminated..items_read is location to store number of gunichar2 read, or NULL to ignore. If NULL, then [error@GLib.ConvertError.PARTIAL_INPUT] will be returned in case @str contains a trailing partial character. If an error occurs then the index of the invalid input is stored here. The value stored here will never be negative..items_written is location to store number of bytes written, or NULL to ignore. The value stored here does not include the trailing nul, and will never be negative..a pointer to a newly allocated UTF-8 string. This value must be freed with [func@GLib.free]..utf8_casefold (string str, int 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.
str is a UTF-8 encoded string.len is length of @str, in bytes, or -1 if @str is nul-terminated..a newly allocated string, that is a case independent form of @str..utf8_collate (string str1, string str2)
Compares two strings for ordering using the linguistically correct rules for the current locale. 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.
str1 is a UTF-8 encoded string.str2 is a UTF-8 encoded string.< 0 if @str1 compares before @str2, 0 if they compare equal, > 0 ifcompares after @str2..utf8_collate_key (string str, int 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. Note that the returned string is not guaranteed to be in any encoding, especially UTF-8. The returned value is meant to be used only for comparisons.
str is a UTF-8 encoded string..len is length of @str, in bytes, or -1 if @str is nul-terminated..a newly allocated string. The contents of the string are only meant to be used when sorting. This string should be freed with g_free() when you are done with it..utf8_collate_key_for_filename (string str, int 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. Note that the returned string is not guaranteed to be in any encoding, especially UTF-8. The returned value is meant to be used only for comparisons.
str is a UTF-8 encoded string..len is length of @str, in bytes, or -1 if @str is nul-terminated..a newly allocated string. The contents of the string are only meant to be used when sorting. This string should be freed with g_free() when you are done with it..utf8_find_next_char (string p, string 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 beNULL: 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 beNULLif the end of the string is reached.
p is a pointer to a position within a UTF-8 encoded string.end is a pointer to the byte following the end of the string, or NULL to indicate that the string is nul-terminated.a pointer to the found character or NULL if @end is set and is reached.utf8_find_prev_char (string str, string 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
NULLif 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.
str is pointer to the beginning of a UTF-8 encoded string.p is pointer to some position within @str.a pointer to the found character.utf8_get_char (string p)
Converts a sequence of bytes encoded as UTF-8 to a Unicode character. If
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 [func@GLib.utf8_get_char_validated] instead.p is a pointer to Unicode character encoded as UTF-8.the resulting character.utf8_get_char_validated (string p, int 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 [func@GLib.utf8_get_char_validated] returns
(gunichar)-2if @max_len is positive and any of the bytes in the first UTF-8 character sequence are nul.
p is a pointer to Unicode character encoded as UTF-8.max_len is the maximum number of bytes to read, or -1 if @p is nul-terminated.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..utf8_make_valid (string str, int 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.
str is string to coerce into UTF-8.len is the maximum length of @str to use, in bytes. If @len is negative, then the string is nul-terminated..a valid UTF-8 string whose content resembles @str.utf8_normalize (string str, int len, string 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.
str is a UTF-8 encoded string..len is length of @str, in bytes, or -1 if @str is nul-terminated..mode is the type of normalization to perform..a newly allocated string, that is the normalized form of @str, or %NULL if @str is not valid UTF-8..utf8_offset_to_pointer (string str, int 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
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 ofTherefore you should be sure that @offset is within string boundaries before calling that function. Call [func@GLib.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.str is a UTF-8 encoded string.offset is a character offset within @str.the resulting pointer.utf8_pointer_to_offset (string str, string 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
and returns a negative offset in this case.str is a UTF-8 encoded string.pos is a pointer to a position within @str.the resulting character offset.utf8_prev_char (string 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 [func@GLib.utf8_find_prev_char] instead.
p is a pointer to a position within a UTF-8 encoded string.a pointer to the found character.utf8_strchr (string p, int len, int 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.
p is a nul-terminated UTF-8 encoded string.len is the maximum length of @p.c is a Unicode character.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..utf8_strdown (string str, int 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.
str is a UTF-8 encoded string.len is length of @str, in bytes, or -1 if @str is nul-terminated..a newly allocated string, with all characters converted to lowercase..utf8_strlen (string p, int 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.
p is pointer to the start of a UTF-8 encoded string.max is 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 tobytes are examined.the length of the string in characters.utf8_strncpy (string dest, string src, int 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 [func@GLib.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
dest is buffer to fill with characters from @src.src is UTF-8 encoded string.n is character count.@dest.utf8_strrchr (string p, int len, int 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.
p is a nul-terminated UTF-8 encoded string.len is the maximum length of @p.c is a Unicode character.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..utf8_strreverse (string str, int len)
Reverses a UTF-8 string. @str must be valid UTF-8 encoded text. (Use [func@GLib.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 [func@GLib.strreverse], this function returns newly-allocated memory, which should be freed with [func@GLib.free] when no longer needed.
str is a UTF-8 encoded string.len is the maximum length of @str to use, in bytes. If @len is negative, then the string is nul-terminated..a newly-allocated string which is the reverse of @str.utf8_strup (string str, int 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.)
str is a UTF-8 encoded string.len is length of @str, in bytes, or -1 if @str is nul-terminated..a newly allocated string, with all characters converted to uppercase..utf8_substring (string str, int start_pos, int 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,
-1can be passed to @end_pos to indicate the end of the string.
str is a UTF-8 encoded string.start_pos is a character offset within @str.end_pos is another character offset within @str, or -1 to indicate the end of the string.a newly allocated copy of the requested substring. Free with [func@GLib.free] when no longer needed..utf8_to_ucs4 (string str, int len)
Convert a string from UTF-8 to a 32-bit fixed width representation as UCS-4. A trailing nul character (U+0000) will be added to the string after the converted text.
str is a UTF-8 encoded string.len is the maximum length of @str to use, in bytes. If @len is negative, then the string is nul-terminated..items_read is location to store number of bytes read, or NULL to ignore. If NULL, then [error@GLib.ConvertError.PARTIAL_INPUT] will be returned in case @str contains a trailing partial character. If an error occurs then the index of the invalid input is stored here. The value stored here will never be negative..items_written is location to store number of characters written, or NULL to ignore. The value stored here does not include the trailing nul, and will never be negative..a pointer to a newly allocated UCS-4 string. This value must be freed with [func@GLib.free]..utf8_to_ucs4_fast (string str, int len)
Convert a string from UTF-8 to a 32-bit fixed width representation as UCS-4, assuming valid UTF-8 input. This function is roughly twice as fast as [func@GLib.utf8_to_ucs4] but does no error checking on the input. A trailing nul character (U+0000) will be added to the string after the converted text.
str is a UTF-8 encoded string.len is the maximum length of @str to use, in bytes. If @len is negative, then the string is nul-terminated..items_written is location to store the number of characters in the result, or NULL..a pointer to a newly allocated UCS-4 string. This value must be freed with [func@GLib.free]..utf8_to_utf16 (string str, int len)
Convert a string from UTF-8 to UTF-16. A nul character (U+0000) will be added to the result after the converted text.
str is a UTF-8 encoded string.len is the maximum length (number of bytes) of @str to use. If @len is negative, then the string is nul-terminated..items_read is location to store number of bytes read, or NULL to ignore. If NULL, then [error@GLib.ConvertError.PARTIAL_INPUT] will be returned in case @str contains a trailing partial character. If an error occurs then the index of the invalid input is stored here. The value stored here will never be negative..items_written is location to store number of gunichar2 written, or NULL to ignore. The value stored here does not include the trailing nul, and will never be negative..a pointer to a newly allocated UTF-16 string. This value must be freed with [func@GLib.free]..utf8_truncate_middle (string arg0String, int truncate_length)
Cuts off the middle of the string, preserving half of @truncate_length characters at the beginning and half at the end. If @string is already short enough, this returns a copy of @string. If @truncate_length is
0, an empty string is returned.
string is a nul-terminated UTF-8 encoded string.truncate_length is the new size of @string, in characters, including the ellipsis character.a newly-allocated copy of @string ellipsized in the middle.utime (string filename, utb)
A wrapper for the POSIX utime() function. The utime() function sets the access and modification timestamps of a file. See your C library manual for more details about how utime() works on your system.
filename is a pathname in the GLib file name encoding (UTF-8 on Windows).utb is a pointer to a struct utimbuf..0 if the operation was successful, -1 if an error occurred.uuid_string_is_valid (string 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.
str is a string representing a UUID.%TRUE if @str is a valid UUID, %FALSE otherwise..uuid_string_random ()
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.
A string that should be freed with g_free()..variant_get_gtype ()
Generated wrapper for GIR function
variant_get_gtype. Native symbol:g_variant_get_gtype.
variant_is_object_path (string arg0String)
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.
string is a normal C nul-terminated string.%TRUE if @string is a D-Bus object path.variant_is_signature (string arg0String)
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.
string is a normal C nul-terminated string.%TRUE if @string is a D-Bus type signature.variant_parse (object type, string text, string limit, string endptr)
Parses a #GVariant from a text representation. A single #GVariant is parsed from the content of @text. The format is described here. The memory at @limit will never be accessed and the parser behaves as if the character at @limit is the nul terminator. This has the effect of bounding @text. If @endptr is non-%NULL then @text is permitted to contain data following the value that this function parses and @endptr will be updated to point to the first character past the end of the text parsed by this function. If
is %NULL and there is extra data then an error is returned. Ifis non-%NULL then the value will be parsed to have that type. This may result in additional parse errors (in the case that the parsed value doesn't fit the type) but may also result in fewer errors (in the case that the type would have been ambiguous, such as with empty arrays). In the event that the parsing is successful, the resulting #GVariant is returned. It is never floating, and must be freed with [method@GLib.Variant.unref]. In case of any error, %NULL will be returned. If @error is non-%NULL then it will be set to reflect the error that occurred. Officially, the language understood by the parser is “any string produced by [method@GLib.Variant.print]”. This explicitly includes g_variant_print()’s annotated types like int64 -1000. There may be implementation specific restrictions on deeply nested values, which would result in a %G_VARIANT_PARSE_ERROR_RECURSION error. #GVariant is guaranteed to handle nesting up to at least 64 levels.type is a #GVariantType, or %NULL.text is a string containing a GVariant in text form.limit is a pointer to the end of @text, or %NULL.endptr is a location to store the end pointer, or %NULL.a non-floating reference to a #GVariant, or %NULL.variant_parse_error_print_context (object error, string 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.
error is a #GError from the #GVariantParseError domain.source_str is the string that was given to the parser.the printed message.variant_type_checked_ (string type_string)
Generated wrapper for GIR function
variant_type_checked_. Native symbol:g_variant_type_checked_.
variant_type_string_get_depth_ (string type_string)
Generated wrapper for GIR function
variant_type_string_get_depth_. Native symbol:g_variant_type_string_get_depth_.
variant_type_string_is_valid (string type_string)
Checks if @type_string is a valid GVariant type string. This call is equivalent to calling [func@GLib.VariantType.string_scan] and confirming that the following character is a nul terminator.
type_string is a pointer to any string.true if @type_string is exactly one valid type string Since 2.24.variant_type_string_scan (string arg0String, string limit)
Scan for a single complete and valid GVariant type string in @string. The memory pointed to by @limit (or bytes beyond it) is never accessed. If a valid type string is found, @endptr is updated to point to the first character past the end of the string that was found and %TRUE is returned. If there is no valid type string starting at @string, or if the type string does not end before @limit then %FALSE is returned. For the simple case of checking if a string is a valid type string, see [func@GLib.VariantType.string_is_valid].
string is a pointer to any string.limit is the end of @string.endptr is location to store the end pointer.true if a valid type string was found.warn_message (string domain, string file, int line, string func, string warnexpr)
Internal function used to print messages from the public [func@GLib.warn_if_reached] and [func@GLib.warn_if_fail] macros.
domain is log domain.file is file containing the warning.line is line number of the warning.func is function containing the warning.warnexpr is expression which failed.None.uri_parse_params_list ()
Returns
uri_parse_paramsas an Aussom map. This companion materializes the full hash table up front; useuri_parse_params()for the raw native GHashTable handle.
An Aussom map of the hash table entries.[2341:7] extends: object
Writer function for log entries. A log entry is a collection of one or more
#GLogFields, using the standard field names from journal
specification.
See g_log_structured() for more information. Writer functions must ignore
fields which they do not recognise, unless they can write arbitrary binary
output, as field values may be arbitrary binary. @log_level is guaranteed to
be included in @fields as the PRIORITY field, but is provided separately
for convenience of deciding whether or where to output the log entry. Writer
functions should return %G_LOG_WRITER_HANDLED if they handled the log message
successfully or if they deliberately ignored it. If there was an error
handling the message (for example, if the writer function is meant to send
messages to a remote logging server and there is a network error), it should
return %G_LOG_WRITER_UNHANDLED. This allows writer functions to be chained
and fall back to simpler handlers in case of failure.
GLibLogWriterFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (log_level, fields, n_fields, user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[3949:7] extends: object
Specifies the prototype of fatal log handler functions.
GLibTestLogFatalFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (log_domain, log_level, message, user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[3199:7] extends: object
This is just a placeholder for #GClosureMarshal, which cannot be used here for dependency reasons.
GLibSourceDummyMarshalCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline ()
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[302:7] extends: object
Specifies the type of function passed to [func@GLib.clear_handle_id] The implementation is expected to free the resource identified by @handle_id; for instance, if @handle_id is a [struct@GLib.Source] ID, [func@GLib.Source.remove] can be used.
GLibClearHandleFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (handle_id)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[2258:7] extends: object
Specifies the prototype of log handler functions. The default log handler,
[func@GLib.log_default_handler], automatically appends a new-line character
to @message when printing it. It is advised that any custom log handler
functions behave similarly, so that logging calls in user code do not need
modifying to add a new-line character to the message if the log handler is
changed. The log_domain parameter can be set to NULL or an empty string
to use the default application domain. This is not used if structured logging
is enabled; see Using Structured
Logging.
GLibLogFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (log_domain, log_level, message, user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[728:7] extends: object
Specifies the type of function passed to g_dataset_foreach(). It is called with each #GQuark id and associated data element, together with the @user_data parameter supplied to g_dataset_foreach().
GLibDataForeachFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (key_id, data, user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[3056:7] extends: object
A #GSequenceIterCompareFunc is a function used to compare iterators. It must return zero if the iterators compare equal, a negative value if @a comes before @b, and a positive value if @b comes before @a.
GLibSequenceIterCompareFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (a, b, data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[3128:7] extends: object
Dispose function for @source. See [method@GLib.Source.set_dispose_function] for details.
GLibSourceDisposeFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (source)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[2983:7] extends: object
Specifies the type of the message handler function.
GLibScannerMsgFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (scanner, message, error)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[1160:7] extends: object
Specifies the type of function which is called when an extended error instance is copied. It is passed the pointer to the destination error and source error, and should copy only the fields of the private data from @src_error to @dest_error. Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it already takes care of getting the private data from @src_error and @dest_error.
GLibErrorCopyFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (src_error, dest_error)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[1614:7] extends: object
Specifies the type of the hash function which is passed to
[func@HashTable.new] when a [struct@HashTable] is created. The function is
passed a key and should return an unsigned int hash value. The functions
[func@direct_hash], [func@int_hash] and [func@str_hash] provide hash
functions which can be used when the key is a void*, int*, and char*
respectively. [func@direct_hash] is also the appropriate hash function for
keys of the form GINT_TO_POINTER (n) (or similar macros). A good
hash functions should produce hash values that are evenly distributed over a
fairly large range. The modulus is taken with the hash table size (a prime
number) to find the 'bucket' to place each key into. The function should also
be very fast, since it is called for each key lookup. Note that the hash
functions provided by GLib have these qualities, but are not particularly
robust against manufactured keys that cause hash collisions. Therefore, you
should consider choosing a more secure hash function when using a
[struct@HashTable] with keys that originate in untrusted data (such as HTTP
requests). Using [func@str_hash] in that situation might make your
application vulnerable to Algorithmic Complexity
Attacks. The key to choosing a good hash
is unpredictability. Even cryptographic hashes are very easy to find
collisions for when the remainder is taken modulo a somewhat predictable
prime number. There must be an element of randomness that an attacker is
unable to guess.
GLibHashFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (key)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[1307:7] extends: object
Declares a type of function which takes an arbitrary data pointer argument and has no return value. It is not currently used in GLib or GTK.
GLibFreeFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[3419:7] extends: object
Finalizes the source. Called when the source is finalized. At this point, the source will have been destroyed, had its callback cleared, and have been removed from its [type@GLib.MainContext], but it will still have its final reference count, so methods can be called on it from within this function.
GLibSourceFuncsFinalizeFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (source)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[3579:7] extends: object
A source function that is only called once before being removed from the main context automatically. See: [func@GLib.idle_add_once], [func@GLib.timeout_add_once]
GLibSourceOnceFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[1448:7] extends: object
Specifies the type of the function passed to g_hash_table_foreach(). It is called with each key/value pair, together with the @user_data parameter which is passed to g_hash_table_foreach().
GLibHFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (key, value, user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[3811:7] extends: object
The type used for functions that operate on test fixtures. This is used for the fixture setup and teardown functions as well as for the testcases themselves. @user_data is a pointer to the data that was given when registering the test case. @fixture will be a pointer to the area of memory allocated by the test framework, of the size requested. If the requested size was zero then @fixture will be equal to @user_data.
GLibTestFixtureFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (fixture, user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[657:7] extends: object
A function of this signature is used to copy the node data when doing a deep-copy of a tree.
GLibCopyFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (src, data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[1523:7] extends: object
Specifies the type of the function passed to [func@GLib.HashTable.find], [func@GLib.HashTable.foreach_remove], and [func@GLib.HashTable.foreach_steal]. The function is called with each key/value pair, together with the @user_data parameter passed to the calling function. The function should return true if the key/value pair should be selected, meaning it has been found or it should be removed from the [struct@GLib.HashTable], depending on the calling function.
GLibHRFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (key, value, user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[517:7] extends: object
Specifies the type of the function passed to g_completion_new(). It should return the string corresponding to the given target item. This is used when you use data structures as #GCompletion items.
GLibCompletionFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (item)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[1896:7] extends: object
Defines the type of function to be called when a hook in a list of hooks gets finalized.
GLibHookFinalizeFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (hook_list, hook)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[446:7] extends: object
Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second.
GLibCompareFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (a, b)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[3499:7] extends: object
Checks the source for readiness. Called before all the file descriptors are
polled. If the source can determine that it is ready here (without waiting
for the results of the poll call) it should return %TRUE. It can also return
a @timeout_ value which should be the maximum timeout (in milliseconds) which
should be passed to the poll call. The actual timeout used will be -1 if
all sources returned -1, or it will be the minimum of all the @timeout_
values returned which were greater than or equal to 0. If the prepare
function returns a timeout and the source also has a ready time set, then the
lower of the two will be used. Since 2.36 this may be NULL, in which case
the effect is as if the function always returns FALSE with a timeout of
-1.
GLibSourceFuncsPrepareFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (source, timeout_)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[3668:7] extends: object
Specifies the type of the setup function passed to g_spawn_async(),
g_spawn_sync() and g_spawn_async_with_pipes(), which can, in very limited
ways, be used to affect the child's execution. On POSIX platforms, the
function is called in the child after GLib has performed all the setup it
plans to perform, but before calling exec(). Actions taken in this function
will only affect the child, not the parent. On Windows, the function is
called in the parent. Its usefulness on Windows is thus questionable. In many
cases executing the child setup function in the parent can have ill effects,
and you should be very careful when porting software to Windows that uses
child setup functions. However, even on POSIX, you are extremely limited in
what you can safely do from a #GSpawnChildSetupFunc, because any mutexes that
were held by other threads in the parent process at the time of the fork()
will still be locked in the child process, and they will never be unlocked
(since the threads that held them don't exist in the child). POSIX allows
only async-signal-safe functions (see signal(7)) to be called in the child
between fork() and exec(), which drastically limits the usefulness of child
setup functions. In particular, it is not safe to call any function which may
call malloc(), which includes POSIX functions such as setenv(). If you need
to set up the child environment differently from the parent, you should use
g_get_environ(), g_environ_setenv(), and g_environ_unsetenv(), and then pass
the complete environment list to the g_spawn... function.
GLibSpawnChildSetupFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[2415:7] extends: object
Specifies the type of function passed to g_node_children_foreach(). The function is called with each child node, together with the user data passed to g_node_children_foreach().
GLibNodeForeachFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (node, data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[1377:7] extends: object
Specifies the type of functions passed to g_list_foreach() and g_slist_foreach().
GLibFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (data, user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[15:7] extends: object
Specifies the type of the @value_destroy_func and @key_destroy_func functions passed to g_cache_new(). The functions are passed a pointer to the #GCache key or #GCache value and should free any memory and other resources associated with it.
GLibCacheDestroyFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (value)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[1824:7] extends: object
Defines the type of function used to compare #GHook elements in g_hook_insert_sorted().
GLibHookCompareFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (new_hook, sibling)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[2699:7] extends: object
The type of function that can be called before and after parsing.
GLibOptionParseFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (context, group, data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[3346:7] extends: object
Checks if the source is ready to be dispatched. Called after all the file
descriptors are polled. The source should return %TRUE if it is ready to be
dispatched. Note that some time may have passed since the previous prepare
function was called, so the source should be checked again here. Since 2.36
this may be NULL, in which case the effect is as if the function always
returns FALSE.
GLibSourceFuncsCheckFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (source)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[1012:7] extends: object
Specifies the type of a function used to test two values for equality. The function should return %TRUE if both values are equal and %FALSE otherwise. This is a version of #GEqualFunc which provides a @user_data closure from the caller.
GLibEqualFuncFullCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (a, b, user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[230:7] extends: object
Prototype of a #GChildWatchSource callback, called when a child process has
exited. To interpret @wait_status, see the documentation for
[func@GLib.spawn_check_wait_status]. In particular, on Unix platforms, note
that it is usually not equal to the integer passed to exit() or returned
from main().
GLibChildWatchFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (pid, wait_status, user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[2912:7] extends: object
Specifies the type of the function passed to g_regex_replace_eval(). It is called for each occurrence of the pattern in the string passed to g_regex_replace_eval(), and it should append the replacement to @result.
GLibRegexEvalCallbackCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (match_info, result, user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[870:7] extends: object
The type of functions that are used to 'duplicate' an object. What this means depends on the context, it could just be incrementing the reference count, if @data is a ref-counted object.
GLibDuplicateFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (data, user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[2107:7] extends: object
Defines the type of function used by g_hook_list_marshal().
GLibHookMarshallerCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (hook, marshal_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[157:7] extends: object
Specifies the type of the @value_new_func function passed to g_cache_new(). It is passed a #GCache key and should create the value corresponding to the key.
GLibCacheNewFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (key)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[3737:7] extends: object
The type used for test case functions that take an extra pointer argument.
GLibTestDataFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[2628:7] extends: object
The type of function to be used as callback when a parse error occurs.
GLibOptionErrorFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (context, group, data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[1684:7] extends: object
Defines the type of a hook function that can be invoked by g_hook_list_invoke_check().
GLibHookCheckFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[2488:7] extends: object
Specifies the type of function passed to g_node_traverse(). The function is called with each of the nodes visited, together with the user data passed to g_node_traverse(). If the function returns %TRUE, then the traversal is stopped.
GLibNodeTraverseFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (node, data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[1753:7] extends: object
Defines the type of function used by g_hook_list_marshal_check().
GLibHookCheckMarshallerCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (hook, marshal_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[2179:7] extends: object
Specifies the type of function passed to g_io_add_watch() or g_io_add_watch_full(), which is called when the requested condition on a #GIOChannel is satisfied.
GLibIOFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (source, condition, data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[1085:7] extends: object
Specifies the type of function which is called when an extended error instance is freed. It is passed the error pointer about to be freed, and should free the error's private data fields. Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it already takes care of getting the private data from @error.
GLibErrorClearFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (error)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[4090:7] extends: object
The type of functions which are used to translate user-visible strings, for
output.GLibTranslateFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (str, data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[2841:7] extends: object
Specifies the type of the print handler functions. These are called with the complete formatted string to output.
GLibPrintFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (arg0String)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[374:7] extends: object
Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second.
GLibCompareDataFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (a, b, user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[3880:7] extends: object
The type used for test case functions.
GLibTestFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline ()
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[799:7] extends: object
Specifies the type of function which is called when a data element is destroyed. It is passed the pointer to the data element and should free any memory and resources allocated for it.
GLibDestroyNotifyCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[3272:7] extends: object
Specifies the type of function passed to [func@GLib.timeout_add], [func@GLib.timeout_add_full], [func@GLib.idle_add], and [func@GLib.idle_add_full]. When calling [method@GLib.Source.set_callback], you may need to cast a function of a different type to this type. Use [func@GLib.SOURCE_FUNC] to avoid warnings about incompatible function types.
GLibSourceFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (user_data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[4020:7] extends: object
Specifies the type of the @func functions passed to g_thread_new() or g_thread_try_new().
GLibThreadFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[86:7] extends: object
Specifies the type of the @key_dup_func function passed to g_cache_new(). The function is passed a key (not a value as the prototype implies) and should return a duplicate of the key.
GLibCacheDupFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (value)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[1967:7] extends: object
Defines the type of the function passed to g_hook_find().
GLibHookFindFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (hook, data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[2559:7] extends: object
The type of function to be passed as callback for %G_OPTION_ARG_CALLBACK options.
GLibOptionArgFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (option_name, value, data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[4304:7] extends: object
Declares a type of function which takes no arguments and has no return value. It is used to specify the type function passed to g_atexit().
GLibVoidFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline ()
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[2038:7] extends: object
Defines the type of a hook function that can be invoked by g_hook_list_invoke().
GLibHookFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[4233:7] extends: object
Specifies the type of function passed to g_tree_foreach_node(). It is passed each node, together with the @user_data parameter passed to g_tree_foreach_node(). If the function returns %TRUE, the traversal is stopped.
GLibTraverseNodeFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (node, data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[940:7] extends: object
Specifies the type of a function used to test two values for equality. The function should return %TRUE if both values are equal and %FALSE otherwise.
GLibEqualFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (a, b)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[587:7] extends: object
Specifies the type of the function passed to g_completion_set_compare(). This is used when you use strings as #GCompletion items.
GLibCompletionStrncmpFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (s1, s2, n)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[2771:7] extends: object
Specifies the type of function passed to g_main_context_set_poll_func(). The semantics of the function should match those of the poll() system call.
GLibPollFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (ufds, nfsd, timeout_)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
[4161:7] extends: object
Specifies the type of function passed to g_tree_traverse(). It is passed the key and value of each node, together with the @user_data parameter passed to g_tree_traverse(). If the function returns %TRUE, the traversal is stopped.
GLibTraverseFuncCallback (callback Fn, UserData = null)
Creates one native callback wrapper. The wrapper owns a trampoline that converts native pointers into generated wrapper objects before invoking
Fn.
Fn is the Aussom callback implementation.UserData is retained and passed through to Fn on each invocation when provided.trampoline (key, value, data)
Internal trampoline. Converts native pointer arguments into generated wrapper instances, then invokes the user's callback.
callback ()
Returns the wrapped NativeCallback.
handle ()
Returns the callback as a NativeHandle.
close ()
Closes the underlying NativeCallback.
isClosed ()
Returns true when the callback has been closed.
