Support for PangoFT2, PangoCairo, fontconfig2, freetype22, GL, Clutter, ClutterX11...

[girtod.git] / gtk2 / glib2.d

// *** DO NOT EDIT ***
// Automatically generated from "/usr/share/gir-1.0/GLib-2.0.gir"

module GLib2;

// package: "glib-2.0";
// C header: "glib.h";

// c:symbol-prefixes: ["g", "glib"]
// c:identifier-prefixes: ["G"]

// module GLib2;

//  --- mixin/GLib2__MODULE_HEAD.d --->

import core.stdc.limits: c_long, c_ulong;
alias  int c_int;  // Assumes 32-bit wide int.
alias uint c_uint; // Assumes 32-bit wide int.

import core.sys.posix.sys.types : time_t, ssize_t;
import std.c.stdarg : va_list;
import std.c.stdio : FILE;

alias int gboolean;


// A wrapper that makes type <S> behave like a reference type.

struct Ref(S) {
   S* __refpointer;
   
   alias __refpointer this;
   
   this(S:S)(ref S s) { __refpointer = &s; }
   this(SP:S*)(SP s)  { __refpointer = s; }
   this(A...)(A s)    { __refpointer = new S(s); }
   
   void toString(FT)(scope void delegate(const(char)[]) sink, FT fmt) {
      import std.format;
      formatValue(sink, *__refpointer, fmt);
   }
}

// <--- mixin/GLib2__MODULE_HEAD.d ---

alias ubyte DateDay;
alias ushort DateYear;

// A type which is used to hold a process identification.
// 
// On UNIX, processes are identified by a process id (an integer),
// while Windows uses process handles (which are pointers).
alias int Pid;

// A GQuark is a non-zero integer which uniquely identifies a
// particular string. A GQuark value of zero is associated to %NULL.
alias uint Quark;
// A C representable type name for #G_TYPE_STRV.
alias void* Strv;
alias int Time;
// A value representing an interval of time, in microseconds.
alias long TimeSpan;

// A numerical value which represents the unique identifier of a registered
// type.
alias size_t Type;
enum int ALLOCATOR_LIST = 1;
enum int ALLOCATOR_NODE = 3;
enum int ALLOCATOR_SLIST = 2;
enum int ALLOC_AND_FREE = 2;
enum int ALLOC_ONLY = 1;
enum int ASCII_DTOSTR_BUF_SIZE = 39;
enum int ATOMIC_OP_USE_GCC_BUILTINS = 1;

// The #GAllocator struct contains private data. and should only be
// accessed using the following functions.
struct Allocator {

   // Frees all of the memory allocated by the #GAllocator.
   // 
   // Deprecated:2.10: Use the <link linkend="glib-Memory-Slices">slice
   // allocator</link> instead
   void free() {
      g_allocator_free(&this);
   }

   // Unintrospectable function: new() / g_allocator_new()
   // Creates a new #GAllocator.
   // 
   // Deprecated:2.10: Use the <link linkend="glib-Memory-Slices">slice
   // allocator</link> instead
   // <name>: the name of the #GAllocator. This name is used to set the name of the #GMemChunk used by the #GAllocator, and is only used for debugging.
   // <n_preallocs>: the number of elements in each block of memory allocated.  Larger blocks mean less calls to g_malloc(), but some memory may be wasted.  (GLib uses 128 elements per block by default.) The value must be between 1 and 65535.
   static Allocator* new_(char* name, uint n_preallocs) {
      return g_allocator_new(name, n_preallocs);
   }
}

// Contains the public fields of an <link linkend="glib-Arrays">Array</link>.
struct Array {
   char* data;
   uint len;


   // Unintrospectable function: append_vals() / g_array_append_vals()
   // Adds @len elements onto the end of the array.
   // <array>: a #GArray.
   // <data>: a pointer to the elements to append to the end of the array.
   // <len>: the number of elements to append.
   static Array* append_vals(Array* array, const(void)* data, uint len) {
      return g_array_append_vals(array, data, len);
   }

   // Frees the memory allocated for the #GArray. If @free_segment is
   // %TRUE it frees the memory block holding the elements as well and
   // also each element if @array has a @element_free_func set. Pass
   // %FALSE if you want to free the #GArray wrapper but preserve the
   // underlying array for use elsewhere. If the reference count of @array
   // is greater than one, the #GArray wrapper is preserved but the size
   // of @array will be set to zero.
   // 
   // <note><para>If array elements contain dynamically-allocated memory,
   // they should be freed separately.</para></note>
   // <array>: a #GArray.
   // <free_segment>: if %TRUE the actual element data is freed as well.
   static char* /*new*/ free(Array* array, int free_segment) {
      return g_array_free(array, free_segment);
   }

   // Gets the size of the elements in @array.
   // RETURNS: Size of each element, in bytes.
   // <array>: A #GArray.
   static uint get_element_size(Array* array) {
      return g_array_get_element_size(array);
   }

   // Unintrospectable function: insert_vals() / g_array_insert_vals()
   // Inserts @len elements into a #GArray at the given index.
   // <array>: a #GArray.
   // <index_>: the index to place the elements at.
   // <data>: a pointer to the elements to insert.
   // <len>: the number of elements to insert.
   static Array* insert_vals(Array* array, uint index_, const(void)* data, uint len) {
      return g_array_insert_vals(array, index_, data, len);
   }

   // Unintrospectable function: new() / g_array_new()
   // Creates a new #GArray with a reference count of 1.
   // <zero_terminated>: %TRUE if the array should have an extra element at the end which is set to 0.
   // <clear_>: %TRUE if #GArray elements should be automatically cleared to 0 when they are allocated.
   // <element_size>: the size of each element in bytes.
   static Array* new_(int zero_terminated, int clear_, uint element_size) {
      return g_array_new(zero_terminated, clear_, element_size);
   }

   // Unintrospectable function: prepend_vals() / g_array_prepend_vals()
   // Adds @len elements onto the start of the array.
   // 
   // This operation is slower than g_array_append_vals() since the
   // existing elements in the array have to be moved to make space for
   // the new elements.
   // <array>: a #GArray.
   // <data>: a pointer to the elements to prepend to the start of the array.
   // <len>: the number of elements to prepend.
   static Array* prepend_vals(Array* array, const(void)* data, uint len) {
      return g_array_prepend_vals(array, data, len);
   }

   // Unintrospectable function: ref() / g_array_ref()
   // Atomically increments the reference count of @array by one. This
   // function is MT-safe and may be called from any thread.
   // RETURNS: The passed in #GArray.
   // <array>: A #GArray.
   static Array* ref_(Array* array) {
      return g_array_ref(array);
   }

   // Unintrospectable function: remove_index() / g_array_remove_index()
   // Removes the element at the given index from a #GArray. The following
   // elements are moved down one place.
   // <array>: a #GArray.
   // <index_>: the index of the element to remove.
   static Array* remove_index(Array* array, uint index_) {
      return g_array_remove_index(array, index_);
   }

   // Unintrospectable function: remove_index_fast() / g_array_remove_index_fast()
   // Removes the element at the given index from a #GArray. The last
   // element in the array is used to fill in the space, so this function
   // does not preserve the order of the #GArray. But it is faster than
   // g_array_remove_index().
   // <array>: a @GArray.
   // <index_>: the index of the element to remove.
   static Array* remove_index_fast(Array* array, uint index_) {
      return g_array_remove_index_fast(array, index_);
   }

   // Unintrospectable function: remove_range() / g_array_remove_range()
   // Removes the given number of elements starting at the given index
   // from a #GArray.  The following elements are moved to close the gap.
   // <array>: a @GArray.
   // <index_>: the index of the first element to remove.
   // <length>: the number of elements to remove.
   static Array* remove_range(Array* array, uint index_, uint length) {
      return g_array_remove_range(array, index_, length);
   }

   // Unintrospectable function: set_size() / g_array_set_size()
   // Sets the size of the array, expanding it if necessary. If the array
   // was created with @clear_ set to %TRUE, the new elements are set to 0.
   // <array>: a #GArray.
   // <length>: the new size of the #GArray.
   static Array* set_size(Array* array, uint length) {
      return g_array_set_size(array, length);
   }

   // Unintrospectable function: sized_new() / g_array_sized_new()
   // Creates a new #GArray with @reserved_size elements preallocated and
   // a reference count of 1. This avoids frequent reallocation, if you
   // are going to add many elements to the array. Note however that the
   // size of the array is still 0.
   // <zero_terminated>: %TRUE if the array should have an extra element at the end with all bits cleared.
   // <clear_>: %TRUE if all bits in the array should be cleared to 0 on allocation.
   // <element_size>: size of each element in the array.
   // <reserved_size>: number of elements preallocated.
   static Array* sized_new(int zero_terminated, int clear_, uint element_size, uint reserved_size) {
      return g_array_sized_new(zero_terminated, clear_, element_size, reserved_size);
   }

   // Unintrospectable function: sort() / g_array_sort()
   // Sorts a #GArray 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 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 &#8211; i.e.
   // you want a stable sort &#8211; you can write a comparison function that,
   // if two elements would otherwise compare equal, compares them by
   // their addresses.
   // <array>: a #GArray.
   // <compare_func>: comparison function.
   static void sort(Array* array, CompareFunc compare_func) {
      g_array_sort(array, compare_func);
   }

   // Unintrospectable function: sort_with_data() / g_array_sort_with_data()
   // Like g_array_sort(), but the comparison function receives an extra
   // user data argument.
   // <array>: a #GArray.
   // <compare_func>: comparison function.
   // <user_data>: data to pass to @compare_func.
   static void sort_with_data(Array* array, CompareDataFunc compare_func, void* user_data) {
      g_array_sort_with_data(array, compare_func, user_data);
   }

   // 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 MT-safe and may be called from any
   // thread.
   // <array>: A #GArray.
   static void unref(Array* array) {
      g_array_unref(array);
   }
}

enum AsciiType {
   ALNUM = 1,
   ALPHA = 2,
   CNTRL = 4,
   DIGIT = 8,
   GRAPH = 16,
   LOWER = 32,
   PRINT = 64,
   PUNCT = 128,
   SPACE = 256,
   UPPER = 512,
   XDIGIT = 1024
}

// The GAsyncQueue struct is an opaque data structure, which represents
// an asynchronous queue. It should only be accessed through the
// <function>g_async_queue_*</function> functions.
struct AsyncQueue {

   // Returns the length of the queue, negative values mean waiting
   // threads, positive values mean available entries in the
   // @queue. Actually this function returns the number of data items in
   // the queue minus the number of waiting threads. Thus a return value
   // of 0 could mean 'n' entries in the queue and 'n' thread waiting.
   // That can happen due to locking of the queue or due to
   // scheduling.
   // RETURNS: the length of the @queue.
   int length() {
      return g_async_queue_length(&this);
   }

   // Returns the length of the queue, negative values mean waiting
   // threads, positive values mean available entries in the
   // @queue. Actually this function returns the number of data items in
   // the queue minus the number of waiting threads. Thus a return value
   // of 0 could mean 'n' entries in the queue and 'n' thread waiting.
   // That can happen due to locking of the queue or due to
   // scheduling. This function must be called while holding the @queue's
   // lock.
   // RETURNS: the length of the @queue.
   int length_unlocked() {
      return g_async_queue_length_unlocked(&this);
   }

   // Acquires the @queue's lock. After that you can only call the
   // <function>g_async_queue_*_unlocked()</function> function variants on that
   // @queue. Otherwise it will deadlock.
   void lock() {
      g_async_queue_lock(&this);
   }

   // Unintrospectable method: pop() / g_async_queue_pop()
   // Pops data from the @queue. This function blocks until data become
   // available.
   // RETURNS: data from the queue.
   void* pop() {
      return g_async_queue_pop(&this);
   }

   // Unintrospectable method: pop_unlocked() / g_async_queue_pop_unlocked()
   // Pops data from the @queue. This function blocks until data become
   // available. This function must be called while holding the @queue's
   // lock.
   // RETURNS: data from the queue.
   void* pop_unlocked() {
      return g_async_queue_pop_unlocked(&this);
   }

   // Pushes the @data into the @queue. @data must not be %NULL.
   // <data>: @data to push into the @queue.
   void push(void* data) {
      g_async_queue_push(&this, data);
   }

   // Unintrospectable method: push_sorted() / g_async_queue_push_sorted()
   // Inserts @data into @queue using @func to determine the new
   // position.
   // 
   // This function requires that the @queue is sorted before pushing on
   // new elements.
   // 
   // This function will lock @queue before it sorts the queue and unlock
   // it when it is finished.
   // 
   // For an example of @func see g_async_queue_sort().
   // <data>: the @data to push into the @queue
   // <func>: the #GCompareDataFunc is used to sort @queue. This function is passed two elements of the @queue. The function should return 0 if they are equal, a negative value if the first element should be higher in the @queue or a positive value if the first element should be lower in the @queue than the second element.
   // <user_data>: user data passed to @func.
   void push_sorted(void* data, CompareDataFunc func, void* user_data) {
      g_async_queue_push_sorted(&this, data, func, user_data);
   }

   // Unintrospectable method: push_sorted_unlocked() / g_async_queue_push_sorted_unlocked()
   // Inserts @data into @queue using @func to determine the new
   // position.
   // 
   // This function requires that the @queue is sorted before pushing on
   // new elements.
   // 
   // This function is called while holding the @queue's lock.
   // 
   // For an example of @func see g_async_queue_sort().
   // <data>: the @data to push into the @queue
   // <func>: the #GCompareDataFunc is used to sort @queue. This function is passed two elements of the @queue. The function should return 0 if they are equal, a negative value if the first element should be higher in the @queue or a positive value if the first element should be lower in the @queue than the second element.
   // <user_data>: user data passed to @func.
   void push_sorted_unlocked(void* data, CompareDataFunc func, void* user_data) {
      g_async_queue_push_sorted_unlocked(&this, data, func, user_data);
   }

   // Pushes the @data into the @queue. @data must not be %NULL. This
   // function must be called while holding the @queue's lock.
   // <data>: @data to push into the @queue.
   void push_unlocked(void* data) {
      g_async_queue_push_unlocked(&this, data);
   }

   // Unintrospectable method: ref() / g_async_queue_ref()
   // Increases the reference count of the asynchronous @queue by 1. You
   // do not need to hold the lock to call this function.
   // RETURNS: the @queue that was passed in (since 2.6)
   AsyncQueue* ref_() {
      return g_async_queue_ref(&this);
   }

   // Increases the reference count of the asynchronous @queue by 1.
   // 
   // so g_async_queue_ref() can be used regardless of the @queue's
   // lock.
   void ref_unlocked() {
      g_async_queue_ref_unlocked(&this);
   }

   // Unintrospectable method: sort() / g_async_queue_sort()
   // Sorts @queue using @func.
   // 
   // This function will lock @queue before it sorts the queue and unlock
   // it when it is finished.
   // 
   // If you were sorting a list of priority numbers to make sure the
   // lowest priority would be at the top of the queue, you could use:
   // |[
   // gint32 id1;
   // gint32 id2;
   // 
   // id1 = GPOINTER_TO_INT (element1);
   // id2 = GPOINTER_TO_INT (element2);
   // 
   // return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1);
   // ]|
   // <func>: the #GCompareDataFunc is used to sort @queue. This function is passed two elements of the @queue. The function should return 0 if they are equal, a negative value if the first element should be higher in the @queue or a positive value if the first element should be lower in the @queue than the second element.
   // <user_data>: user data passed to @func
   void sort(CompareDataFunc func, void* user_data) {
      g_async_queue_sort(&this, func, user_data);
   }

   // Unintrospectable method: sort_unlocked() / g_async_queue_sort_unlocked()
   // Sorts @queue using @func.
   // 
   // This function is called while holding the @queue's lock.
   // <func>: the #GCompareDataFunc is used to sort @queue. This function is passed two elements of the @queue. The function should return 0 if they are equal, a negative value if the first element should be higher in the @queue or a positive value if the first element should be lower in the @queue than the second element.
   // <user_data>: user data passed to @func
   void sort_unlocked(CompareDataFunc func, void* user_data) {
      g_async_queue_sort_unlocked(&this, func, user_data);
   }

   // Unintrospectable method: timed_pop() / g_async_queue_timed_pop()
   // Pops data from the @queue. If no data is received before @end_time,
   // %NULL is returned.
   // 
   // To easily calculate @end_time a combination of g_get_current_time()
   // and g_time_val_add() can be used.
   // 
   // received before @end_time.
   // RETURNS: data from the queue or %NULL, when no data is
   // <end_time>: a #GTimeVal, determining the final time.
   void* timed_pop(TimeVal* end_time) {
      return g_async_queue_timed_pop(&this, end_time);
   }

   // Unintrospectable method: timed_pop_unlocked() / g_async_queue_timed_pop_unlocked()
   // Pops data from the @queue. If no data is received before @end_time,
   // %NULL is returned. This function must be called while holding the
   // @queue's lock.
   // 
   // To easily calculate @end_time a combination of g_get_current_time()
   // and g_time_val_add() can be used.
   // 
   // received before @end_time.
   // RETURNS: data from the queue or %NULL, when no data is
   // <end_time>: a #GTimeVal, determining the final time.
   void* timed_pop_unlocked(TimeVal* end_time) {
      return g_async_queue_timed_pop_unlocked(&this, end_time);
   }

   // Unintrospectable method: try_pop() / g_async_queue_try_pop()
   // Tries to pop data from the @queue. If no data is available, %NULL is
   // returned.
   // 
   // available immediately.
   // RETURNS: data from the queue or %NULL, when no data is
   void* try_pop() {
      return g_async_queue_try_pop(&this);
   }

   // Unintrospectable method: try_pop_unlocked() / g_async_queue_try_pop_unlocked()
   // Tries to pop data from the @queue. If no data is available, %NULL is
   // returned. This function must be called while holding the @queue's
   // lock.
   // 
   // available immediately.
   // RETURNS: data from the queue or %NULL, when no data is
   void* try_pop_unlocked() {
      return g_async_queue_try_pop_unlocked(&this);
   }
   // Releases the queue's lock.
   void unlock() {
      g_async_queue_unlock(&this);
   }

   // Decreases the reference count of the asynchronous @queue by 1. If
   // the reference count went to 0, the @queue will be destroyed and the
   // memory allocated will be freed. So you are not allowed to use the
   // @queue afterwards, as it might have disappeared. You do not need to
   // hold the lock to call this function.
   void unref() {
      g_async_queue_unref(&this);
   }

   // Decreases the reference count of the asynchronous @queue by 1 and
   // releases the lock. This function must be called while holding the
   // @queue's lock. If the reference count went to 0, the @queue will be
   // destroyed and the memory allocated will be freed.
   // 
   // so g_async_queue_unref() can be used regardless of the @queue's
   // lock.
   void unref_and_unlock() {
      g_async_queue_unref_and_unlock(&this);
   }

   // Unintrospectable function: new() / g_async_queue_new()
   // Creates a new asynchronous queue with the initial reference count of 1.
   // RETURNS: the new #GAsyncQueue.
   static AsyncQueue* new_() {
      return g_async_queue_new();
   }

   // Unintrospectable function: new_full() / g_async_queue_new_full()
   // Creates a new asynchronous queue with an initial reference count of 1 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.
   // RETURNS: the new #GAsyncQueue.
   // <item_free_func>: function to free queue elements
   static AsyncQueue* new_full(DestroyNotify item_free_func) {
      return g_async_queue_new_full(item_free_func);
   }
}

enum int BIG_ENDIAN = 4321;

// The <structname>GBookmarkFile</structname> struct contains only
// private data and should not be directly accessed.
struct BookmarkFile {

   // Adds the application with @name and @exec to the list of
   // applications that have registered a bookmark for @uri into
   // @bookmark.
   // 
   // Every bookmark inside a #GBookmarkFile must have at least an
   // application registered.  Each application must provide a name, a
   // command line useful for launching the bookmark, the number of times
   // the bookmark has been registered by the application and the last
   // time the application registered this bookmark.
   // 
   // If @name is %NULL, the name of the application will be the
   // same returned by g_get_application_name(); if @exec is %NULL, the
   // command line will be a composition of the program name as
   // returned by g_get_prgname() and the "%u" modifier, which will be
   // expanded to the bookmark's URI.
   // 
   // This function will automatically take care of updating the
   // registrations count and timestamping in case an application
   // with the same @name had already registered a bookmark for
   // @uri inside @bookmark.
   // 
   // If no bookmark for @uri is found, one is created.
   // <uri>: a valid URI
   // <name>: the name of the application registering the bookmark or %NULL
   // <exec>: command line to be used to launch the bookmark or %NULL
   void add_application(char* uri, char* name, char* exec) {
      g_bookmark_file_add_application(&this, uri, name, exec);
   }

   // Adds @group to the list of groups to which the bookmark for @uri
   // belongs to.
   // 
   // If no bookmark for @uri is found then it is created.
   // <uri>: a valid URI
   // <group>: the group name to be added
   void add_group(char* uri, char* group) {
      g_bookmark_file_add_group(&this, uri, group);
   }
   // Frees a #GBookmarkFile.
   void free() {
      g_bookmark_file_free(&this);
   }

   // Gets the time the bookmark for @uri was added to @bookmark
   // 
   // In the event the URI cannot be found, -1 is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
   // RETURNS: a timestamp
   // <uri>: a valid URI
   time_t get_added(char* uri, GLib2.Error** error=null) {
      return g_bookmark_file_get_added(&this, uri, error);
   }

   // Gets the registration informations of @app_name for the bookmark for
   // @uri.  See g_bookmark_file_set_app_info() for more informations about
   // the returned data.
   // 
   // The string returned in @app_exec must be freed.
   // 
   // In the event the URI cannot be found, %FALSE is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
   // event that no application with name @app_name has registered a bookmark
   // for @uri,  %FALSE is returned and error is set to
   // #G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting
   // the command line fails, an error of the #G_SHELL_ERROR domain is
   // set and %FALSE is returned.
   // RETURNS: %TRUE on success.
   // <uri>: a valid URI
   // <name>: an application's name
   // <exec>: location for the command line of the application, or %NULL
   // <count>: return location for the registration count, or %NULL
   // <stamp>: return location for the last registration time, or %NULL
   int get_app_info(char* uri, char* name, char** exec, uint* count, time_t* stamp, GLib2.Error** error=null) {
      return g_bookmark_file_get_app_info(&this, uri, name, exec, count, stamp, error);
   }

   // Unintrospectable method: get_applications() / g_bookmark_file_get_applications()
   // Retrieves the names of the applications that have registered the
   // bookmark for @uri.
   // 
   // In the event the URI cannot be found, %NULL is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
   // 
   // Use g_strfreev() to free it.
   // RETURNS: a newly allocated %NULL-terminated array of strings.
   // <uri>: a valid URI
   // <length>: return location of the length of the returned list, or %NULL
   char** get_applications(char* uri, size_t* length, GLib2.Error** error=null) {
      return g_bookmark_file_get_applications(&this, uri, length, error);
   }

   // Retrieves the description of the bookmark for @uri.
   // 
   // In the event the URI cannot be found, %NULL is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
   // 
   // URI cannot be found.
   // RETURNS: a newly allocated string or %NULL if the specified
   // <uri>: a valid URI
   char* /*new*/ get_description(char* uri, GLib2.Error** error=null) {
      return g_bookmark_file_get_description(&this, uri, error);
   }

   // Unintrospectable method: get_groups() / g_bookmark_file_get_groups()
   // Retrieves the list of group names of the bookmark for @uri.
   // 
   // In the event the URI cannot be found, %NULL is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
   // 
   // The returned array is %NULL terminated, so @length may optionally
   // be %NULL.
   // 
   // Use g_strfreev() to free it.
   // RETURNS: a newly allocated %NULL-terminated array of group names.
   // <uri>: a valid URI
   // <length>: return location for the length of the returned string, or %NULL
   char** get_groups(char* uri, size_t* length, GLib2.Error** error=null) {
      return g_bookmark_file_get_groups(&this, uri, length, error);
   }

   // Gets the icon of the bookmark for @uri.
   // 
   // In the event the URI cannot be found, %FALSE is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
   // 
   // You should free the returned strings.
   // RETURNS: %TRUE if the icon for the bookmark for the URI was found.
   // <uri>: a valid URI
   // <href>: return location for the icon's location or %NULL
   // <mime_type>: return location for the icon's MIME type or %NULL
   int get_icon(char* uri, char** href, char** mime_type, GLib2.Error** error=null) {
      return g_bookmark_file_get_icon(&this, uri, href, mime_type, error);
   }

   // Gets whether the private flag of the bookmark for @uri is set.
   // 
   // In the event the URI cannot be found, %FALSE is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
   // event that the private flag cannot be found, %FALSE is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE.
   // RETURNS: %TRUE if the private flag is set, %FALSE otherwise.
   // <uri>: a valid URI
   int get_is_private(char* uri, GLib2.Error** error=null) {
      return g_bookmark_file_get_is_private(&this, uri, error);
   }

   // Retrieves the MIME type of the resource pointed by @uri.
   // 
   // In the event the URI cannot be found, %NULL is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
   // event that the MIME type cannot be found, %NULL is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE.
   // 
   // URI cannot be found.
   // RETURNS: a newly allocated string or %NULL if the specified
   // <uri>: a valid URI
   char* /*new*/ get_mime_type(char* uri, GLib2.Error** error=null) {
      return g_bookmark_file_get_mime_type(&this, uri, error);
   }

   // Gets the time when the bookmark for @uri was last modified.
   // 
   // In the event the URI cannot be found, -1 is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
   // RETURNS: a timestamp
   // <uri>: a valid URI
   time_t get_modified(char* uri, GLib2.Error** error=null) {
      return g_bookmark_file_get_modified(&this, uri, error);
   }

   // Gets the number of bookmarks inside @bookmark.
   // RETURNS: the number of bookmarks
   int get_size() {
      return g_bookmark_file_get_size(&this);
   }

   // Returns the title of the bookmark for @uri.
   // 
   // If @uri is %NULL, the title of @bookmark is returned.
   // 
   // In the event the URI cannot be found, %NULL is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
   // 
   // URI cannot be found.
   // RETURNS: a newly allocated string or %NULL if the specified
   // <uri>: a valid URI or %NULL
   char* /*new*/ get_title(char* uri, GLib2.Error** error=null) {
      return g_bookmark_file_get_title(&this, uri, error);
   }

   // Unintrospectable method: get_uris() / g_bookmark_file_get_uris()
   // Returns all URIs of the bookmarks in the bookmark file @bookmark.
   // The array of returned URIs will be %NULL-terminated, so @length may
   // optionally be %NULL.
   // 
   // Use g_strfreev() to free it.
   // RETURNS: a newly allocated %NULL-terminated array of strings.
   // <length>: return location for the number of returned URIs, or %NULL
   char** get_uris(size_t* length) {
      return g_bookmark_file_get_uris(&this, length);
   }

   // Gets the time the bookmark for @uri was last visited.
   // 
   // In the event the URI cannot be found, -1 is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
   // RETURNS: a timestamp.
   // <uri>: a valid URI
   time_t get_visited(char* uri, GLib2.Error** error=null) {
      return g_bookmark_file_get_visited(&this, uri, error);
   }

   // Checks whether the bookmark for @uri inside @bookmark has been
   // registered by application @name.
   // 
   // In the event the URI cannot be found, %FALSE is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
   // RETURNS: %TRUE if the application @name was found
   // <uri>: a valid URI
   // <name>: the name of the application
   int has_application(char* uri, char* name, GLib2.Error** error=null) {
      return g_bookmark_file_has_application(&this, uri, name, error);
   }

   // Checks whether @group appears in the list of groups to which
   // the bookmark for @uri belongs to.
   // 
   // In the event the URI cannot be found, %FALSE is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
   // RETURNS: %TRUE if @group was found.
   // <uri>: a valid URI
   // <group>: the group name to be searched
   int has_group(char* uri, char* group, GLib2.Error** error=null) {
      return g_bookmark_file_has_group(&this, uri, group, error);
   }

   // Looks whether the desktop bookmark has an item with its URI set to @uri.
   // RETURNS: %TRUE if @uri is inside @bookmark, %FALSE otherwise
   // <uri>: a valid URI
   int has_item(char* uri) {
      return g_bookmark_file_has_item(&this, uri);
   }

   // Loads a bookmark file from memory into an empty #GBookmarkFile
   // structure.  If the object cannot be created then @error is set to a
   // #GBookmarkFileError.
   // RETURNS: %TRUE if a desktop bookmark could be loaded.
   // <data>: desktop bookmarks loaded in memory
   // <length>: the length of @data in bytes
   int load_from_data(char* data, size_t length, GLib2.Error** error=null) {
      return g_bookmark_file_load_from_data(&this, data, length, error);
   }

   // This function looks for a desktop bookmark file named @file in the
   // paths returned from g_get_user_data_dir() and g_get_system_data_dirs(),
   // loads the file into @bookmark and returns the file's full path in
   // @full_path.  If the file could not be loaded then an %error is
   // set to either a #GFileError or #GBookmarkFileError.
   // RETURNS: %TRUE if a key file could be loaded, %FALSE othewise
   // <file>: a relative path to a filename to open and parse
   // <full_path>: return location for a string containing the full path of the file, or %NULL
   int load_from_data_dirs(char* file, char** full_path, GLib2.Error** error=null) {
      return g_bookmark_file_load_from_data_dirs(&this, file, full_path, error);
   }

   // Loads a desktop bookmark file into an empty #GBookmarkFile structure.
   // If the file could not be loaded then @error is set to either a #GFileError
   // or #GBookmarkFileError.
   // RETURNS: %TRUE if a desktop bookmark file could be loaded
   // <filename>: the path of a filename to load, in the GLib file name encoding
   int load_from_file(char* filename, GLib2.Error** error=null) {
      return g_bookmark_file_load_from_file(&this, filename, error);
   }

   // Changes the URI of a bookmark item from @old_uri to @new_uri.  Any
   // existing bookmark for @new_uri will be overwritten.  If @new_uri is
   // %NULL, then the bookmark is removed.
   // 
   // In the event the URI cannot be found, %FALSE is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
   // RETURNS: %TRUE if the URI was successfully changed
   // <old_uri>: a valid URI
   // <new_uri>: a valid URI, or %NULL
   int move_item(char* old_uri, char* new_uri, GLib2.Error** error=null) {
      return g_bookmark_file_move_item(&this, old_uri, new_uri, error);
   }

   // Removes application registered with @name from the list of applications
   // that have registered a bookmark for @uri inside @bookmark.
   // 
   // In the event the URI cannot be found, %FALSE is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
   // In the event that no application with name @app_name has registered
   // a bookmark for @uri,  %FALSE is returned and error is set to
   // #G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED.
   // RETURNS: %TRUE if the application was successfully removed.
   // <uri>: a valid URI
   // <name>: the name of the application
   int remove_application(char* uri, char* name, GLib2.Error** error=null) {
      return g_bookmark_file_remove_application(&this, uri, name, error);
   }

   // Removes @group from the list of groups to which the bookmark
   // for @uri belongs to.
   // 
   // In the event the URI cannot be found, %FALSE is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
   // In the event no group was defined, %FALSE is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE.
   // RETURNS: %TRUE if @group was successfully removed.
   // <uri>: a valid URI
   // <group>: the group name to be removed
   int remove_group(char* uri, char* group, GLib2.Error** error=null) {
      return g_bookmark_file_remove_group(&this, uri, group, error);
   }

   // Removes the bookmark for @uri from the bookmark file @bookmark.
   // RETURNS: %TRUE if the bookmark was removed successfully.
   // <uri>: a valid URI
   int remove_item(char* uri, GLib2.Error** error=null) {
      return g_bookmark_file_remove_item(&this, uri, error);
   }

   // Sets the time the bookmark for @uri was added into @bookmark.
   // 
   // If no bookmark for @uri is found then it is created.
   // <uri>: a valid URI
   // <added>: a timestamp or -1 to use the current time
   void set_added(char* uri, time_t added) {
      g_bookmark_file_set_added(&this, uri, added);
   }

   // Sets the meta-data of application @name inside the list of
   // applications that have registered a bookmark for @uri inside
   // @bookmark.
   // 
   // You should rarely use this function; use g_bookmark_file_add_application()
   // and g_bookmark_file_remove_application() instead.
   // 
   // @name can be any UTF-8 encoded string used to identify an
   // application.
   // be expanded as the local file name retrieved from the bookmark's
   // URI; "%u", which will be expanded as the bookmark's URI.
   // The expansion is done automatically when retrieving the stored
   // command line using the g_bookmark_file_get_app_info() function.
   // @count is the number of times the application has registered the
   // bookmark; if is < 0, the current registration count will be increased
   // by one, if is 0, the application with @name will be removed from
   // the list of registered applications.
   // @stamp is the Unix time of the last registration; if it is -1, the
   // current time will be used.
   // 
   // If you try to remove an application by setting its registration count to
   // zero, and no bookmark for @uri is found, %FALSE is returned and
   // @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND; similarly,
   // in the event that no application @name has registered a bookmark
   // for @uri,  %FALSE is returned and error is set to
   // #G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED.  Otherwise, if no bookmark
   // for @uri is found, one is created.
   // 
   // changed.
   // RETURNS: %TRUE if the application's meta-data was successfully
   // <uri>: a valid URI
   // <name>: an application's name
   // <exec>: an application's command line
   // <count>: the number of registrations done for this application
   // <stamp>: the time of the last registration for this application
   int set_app_info(char* uri, char* name, char* exec, int count, time_t stamp, GLib2.Error** error=null) {
      return g_bookmark_file_set_app_info(&this, uri, name, exec, count, stamp, error);
   }

   // Sets @description as the description of the bookmark for @uri.
   // 
   // If @uri is %NULL, the description of @bookmark is set.
   // 
   // If a bookmark for @uri cannot be found then it is created.
   // <uri>: a valid URI or %NULL
   // <description>: a string
   void set_description(char* uri, char* description) {
      g_bookmark_file_set_description(&this, uri, description);
   }

   // Sets a list of group names for the item with URI @uri.  Each previously
   // set group name list is removed.
   // 
   // If @uri cannot be found then an item for it is created.
   // <uri>: an item's URI
   // <groups>: an array of group names, or %NULL to remove all groups
   // <length>: number of group name values in @groups
   void set_groups(char* uri, char** groups, size_t length) {
      g_bookmark_file_set_groups(&this, uri, groups, length);
   }

   // Sets the icon for the bookmark for @uri. If @href is %NULL, unsets
   // the currently set icon. @href can either be a full URL for the icon
   // file or the icon name following the Icon Naming specification.
   // 
   // If no bookmark for @uri is found one is created.
   // <uri>: a valid URI
   // <href>: the URI of the icon for the bookmark, or %NULL
   // <mime_type>: the MIME type of the icon for the bookmark
   void set_icon(char* uri, char* href, char* mime_type) {
      g_bookmark_file_set_icon(&this, uri, href, mime_type);
   }

   // Sets the private flag of the bookmark for @uri.
   // 
   // If a bookmark for @uri cannot be found then it is created.
   // <uri>: a valid URI
   // <is_private>: %TRUE if the bookmark should be marked as private
   void set_is_private(char* uri, int is_private) {
      g_bookmark_file_set_is_private(&this, uri, is_private);
   }

   // Sets @mime_type as the MIME type of the bookmark for @uri.
   // 
   // If a bookmark for @uri cannot be found then it is created.
   // <uri>: a valid URI
   // <mime_type>: a MIME type
   void set_mime_type(char* uri, char* mime_type) {
      g_bookmark_file_set_mime_type(&this, uri, mime_type);
   }

   // Sets the last time the bookmark for @uri was last modified.
   // 
   // If no bookmark for @uri is found then it is created.
   // 
   // The "modified" time should only be set when the bookmark's meta-data
   // was actually changed.  Every function of #GBookmarkFile that
   // modifies a bookmark also changes the modification time, except for
   // g_bookmark_file_set_visited().
   // <uri>: a valid URI
   // <modified>: a timestamp or -1 to use the current time
   void set_modified(char* uri, time_t modified) {
      g_bookmark_file_set_modified(&this, uri, modified);
   }

   // Sets @title as the title of the bookmark for @uri inside the
   // bookmark file @bookmark.
   // 
   // If @uri is %NULL, the title of @bookmark is set.
   // 
   // If a bookmark for @uri cannot be found then it is created.
   // <uri>: a valid URI or %NULL
   // <title>: a UTF-8 encoded string
   void set_title(char* uri, char* title) {
      g_bookmark_file_set_title(&this, uri, title);
   }

   // Sets the time the bookmark for @uri was last visited.
   // 
   // If no bookmark for @uri is found then it is created.
   // 
   // The "visited" time should only be set if the bookmark was launched,
   // either using the command line retrieved by g_bookmark_file_get_app_info()
   // or by the default application for the bookmark's MIME type, retrieved
   // using g_bookmark_file_get_mime_type().  Changing the "visited" time
   // does not affect the "modified" time.
   // <uri>: a valid URI
   // <visited>: a timestamp or -1 to use the current time
   void set_visited(char* uri, time_t visited) {
      g_bookmark_file_set_visited(&this, uri, visited);
   }

   // This function outputs @bookmark as a string.
   // 
   // the contents of the #GBookmarkFile
   // RETURNS: a newly allocated string holding
   // <length>: return location for the length of the returned string, or %NULL
   char* /*new*/ to_data(size_t* length, GLib2.Error** error=null) {
      return g_bookmark_file_to_data(&this, length, error);
   }

   // This function outputs @bookmark into a file.  The write process is
   // guaranteed to be atomic by using g_file_set_contents() internally.
   // RETURNS: %TRUE if the file was successfully written.
   // <filename>: path of the output file
   int to_file(char* filename, GLib2.Error** error=null) {
      return g_bookmark_file_to_file(&this, filename, error);
   }
   static Quark error_quark() {
      return g_bookmark_file_error_quark();
   }

   // Unintrospectable function: new() / g_bookmark_file_new()
   // Creates a new empty #GBookmarkFile object.
   // 
   // Use g_bookmark_file_load_from_file(), g_bookmark_file_load_from_data()
   // or g_bookmark_file_load_from_data_dirs() to read an existing bookmark
   // file.
   // RETURNS: an empty #GBookmarkFile
   static BookmarkFile* new_() {
      return g_bookmark_file_new();
   }
}

// Error codes returned by bookmark file parsing.
enum BookmarkFileError {
   INVALID_URI = 0,
   INVALID_VALUE = 1,
   APP_NOT_REGISTERED = 2,
   URI_NOT_FOUND = 3,
   READ = 4,
   UNKNOWN_ENCODING = 5,
   WRITE = 6,
   FILE_NOT_FOUND = 7
}

// The <structname>GByteArray</structname> struct allows access to the
// public fields of a <structname>GByteArray</structname>.
struct ByteArray {
   ubyte* data;
   uint len;


   // Unintrospectable function: append() / g_byte_array_append()
   // Adds the given bytes to the end of the #GByteArray. The array will
   // grow in size automatically if necessary.
   // <array>: a #GByteArray.
   // <data>: the byte data to be added.
   // <len>: the number of bytes to add.
   static ByteArray* append(ByteArray* array, ubyte* data, uint len) {
      return g_byte_array_append(array, data, len);
   }

   // 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, the #GByteArray wrapper is preserved but
   // the size of @array will be set to zero.
   // <array>: a #GByteArray.
   // <free_segment>: if %TRUE the actual byte data is freed as well.
   static ubyte* free(ByteArray* array, int free_segment) {
      return g_byte_array_free(array, free_segment);
   }

   // Unintrospectable function: new() / g_byte_array_new()
   // Creates a new #GByteArray with a reference count of 1.
   static ByteArray* new_() {
      return g_byte_array_new();
   }

   // Unintrospectable function: prepend() / g_byte_array_prepend()
   // Adds the given data to the start of the #GByteArray. The array will
   // grow in size automatically if necessary.
   // <array>: a #GByteArray.
   // <data>: the byte data to be added.
   // <len>: the number of bytes to add.
   static ByteArray* prepend(ByteArray* array, ubyte* data, uint len) {
      return g_byte_array_prepend(array, data, len);
   }

   // Unintrospectable function: ref() / g_byte_array_ref()
   // Atomically increments the reference count of @array by one. This
   // function is MT-safe and may be called from any thread.
   // RETURNS: The passed in #GByteArray.
   // <array>: A #GByteArray.
   static ByteArray* ref_(ByteArray* array) {
      return g_byte_array_ref(array);
   }

   // Unintrospectable function: remove_index() / g_byte_array_remove_index()
   // Removes the byte at the given index from a #GByteArray. The
   // following bytes are moved down one place.
   // <array>: a #GByteArray.
   // <index_>: the index of the byte to remove.
   static ByteArray* remove_index(ByteArray* array, uint index_) {
      return g_byte_array_remove_index(array, index_);
   }

   // Unintrospectable function: remove_index_fast() / g_byte_array_remove_index_fast()
   // 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 the #GByteArray. But it is faster
   // than g_byte_array_remove_index().
   // <array>: a #GByteArray.
   // <index_>: the index of the byte to remove.
   static ByteArray* remove_index_fast(ByteArray* array, uint index_) {
      return g_byte_array_remove_index_fast(array, index_);
   }

   // Unintrospectable function: remove_range() / g_byte_array_remove_range()
   // Removes the given number of bytes starting at the given index from a
   // #GByteArray.  The following elements are moved to close the gap.
   // <array>: a @GByteArray.
   // <index_>: the index of the first byte to remove.
   // <length>: the number of bytes to remove.
   static ByteArray* remove_range(ByteArray* array, uint index_, uint length) {
      return g_byte_array_remove_range(array, index_, length);
   }

   // Unintrospectable function: set_size() / g_byte_array_set_size()
   // Sets the size of the #GByteArray, expanding it if necessary.
   // <array>: a #GByteArray.
   // <length>: the new size of the #GByteArray.
   static ByteArray* set_size(ByteArray* array, uint length) {
      return g_byte_array_set_size(array, length);
   }

   // Unintrospectable function: sized_new() / g_byte_array_sized_new()
   // Creates a new #GByteArray with @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>: number of bytes preallocated.
   static ByteArray* sized_new(uint reserved_size) {
      return g_byte_array_sized_new(reserved_size);
   }

   // Unintrospectable function: sort() / g_byte_array_sort()
   // 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 &#8211; i.e.
   // you want a stable sort &#8211; you can write a comparison function that,
   // if two elements would otherwise compare equal, compares them by
   // their addresses.
   // <array>: a #GByteArray.
   // <compare_func>: comparison function.
   static void sort(ByteArray* array, CompareFunc compare_func) {
      g_byte_array_sort(array, compare_func);
   }

   // Unintrospectable function: sort_with_data() / g_byte_array_sort_with_data()
   // Like g_byte_array_sort(), but the comparison function takes an extra
   // user data argument.
   // <array>: a #GByteArray.
   // <compare_func>: comparison function.
   // <user_data>: data to pass to @compare_func.
   static void sort_with_data(ByteArray* array, CompareDataFunc compare_func, void* user_data) {
      g_byte_array_sort_with_data(array, compare_func, user_data);
   }

   // 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 MT-safe and may be called from any
   // thread.
   // <array>: A #GByteArray.
   static void unref(ByteArray* array) {
      g_byte_array_unref(array);
   }
}

enum int CAN_INLINE = 1;
enum CSET_A_2_Z = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
enum CSET_DIGITS = "0123456789";
enum CSET_a_2_z = "abcdefghijklmnopqrstuvwxyz";

// The #GCache struct is an opaque data structure containing
// information about a #GCache. It should only be accessed via the
// following functions.
struct Cache {

   // Frees the memory allocated for the #GCache.
   // 
   // Note that it does not destroy the keys and values which were
   // contained in the #GCache.
   void destroy() {
      g_cache_destroy(&this);
   }

   // Unintrospectable method: insert() / g_cache_insert()
   // Gets the value corresponding to the given key, creating it if
   // necessary. It first checks if the value already exists in the
   // #GCache, by using the @key_equal_func function passed to
   // g_cache_new(). If it does already exist it is returned, and its
   // reference count is increased by one. If the value does not currently
   // exist, if is created by calling the @value_new_func. The key is
   // duplicated by calling @key_dup_func and the duplicated key and value
   // are inserted into the #GCache.
   // <key>: a key describing a #GCache object.
   void* insert(void* key) {
      return g_cache_insert(&this, key);
   }

   // Unintrospectable method: key_foreach() / g_cache_key_foreach()
   // Calls the given function for each of the keys in the #GCache.
   // 
   // NOTE @func is passed three parameters, the value and key of a cache
   // entry and the @user_data. The order of value and key is different
   // from the order in which g_hash_table_foreach() passes key-value
   // pairs to its callback function !
   // <func>: the function to call with each #GCache key.
   // <user_data>: user data to pass to the function.
   void key_foreach(HFunc func, void* user_data) {
      g_cache_key_foreach(&this, func, user_data);
   }

   // Decreases the reference count of the given value. If it drops to 0
   // then the value and its corresponding key are destroyed, using the
   // @value_destroy_func and @key_destroy_func passed to g_cache_new().
   // <value>: the value to remove.
   void remove(const(void)* value) {
      g_cache_remove(&this, value);
   }

   // Unintrospectable method: value_foreach() / g_cache_value_foreach()
   // Calls the given function for each of the values in the #GCache.
   // 
   // Deprecated:2.10: The reason is that it passes pointers to internal
   // data structures to @func; use g_cache_key_foreach()
   // instead
   // <func>: the function to call with each #GCache value.
   // <user_data>: user data to pass to the function.
   void value_foreach(HFunc func, void* user_data) {
      g_cache_value_foreach(&this, func, user_data);
   }

   // Unintrospectable function: new() / g_cache_new()
   // Creates a new #GCache.
   // <value_new_func>: a function to create a new object given a key. This is called by g_cache_insert() if an object with the given key does not already exist.
   // <value_destroy_func>: a function to destroy an object. It is called by g_cache_remove() when the object is no longer needed (i.e. its reference count drops to 0).
   // <key_dup_func>: a function to copy a key. It is called by g_cache_insert() if the key does not already exist in the #GCache.
   // <key_destroy_func>: a function to destroy a key. It is called by g_cache_remove() when the object is no longer needed (i.e. its reference count drops to 0).
   // <hash_key_func>: a function to create a hash value from a key.
   // <hash_value_func>: a function to create a hash value from a value.
   // <key_equal_func>: a function to compare two keys. It should return %TRUE if the two keys are equivalent.
   static Cache* new_(CacheNewFunc value_new_func, CacheDestroyFunc value_destroy_func, CacheDupFunc key_dup_func, CacheDestroyFunc key_destroy_func, HashFunc hash_key_func, HashFunc hash_value_func, EqualFunc key_equal_func) {
      return g_cache_new(value_new_func, value_destroy_func, key_dup_func, key_destroy_func, hash_key_func, hash_value_func, key_equal_func);
   }
}


// 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.
// <value>: the #GCache value to destroy.
extern (C) alias void function (void* value) CacheDestroyFunc;


// Unintrospectable callback: CacheDupFunc() / ()
// Specifies the type of the @key_dup_func function passed to
// g_cache_new(). The function is passed a key
// (<emphasis>not</emphasis> a value as the prototype implies) and
// should return a duplicate of the key.
// <value>: the #GCache key to destroy (<emphasis>not</emphasis> a #GCache value as it seems).
extern (C) alias void* function (void* value) CacheDupFunc;


// Unintrospectable callback: CacheNewFunc() / ()
// 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.
// <key>: a #GCache key.
extern (C) alias void* function (void* key) CacheNewFunc;


// An opaque structure representing a checksumming operation.
// To create a new GChecksum, use g_checksum_new(). To free
// a GChecksum, use g_checksum_free().
struct Checksum /* Version 2.16 */ {

   // Unintrospectable method: copy() / g_checksum_copy()
   // Copies a #GChecksum. If @checksum has been closed, by calling
   // g_checksum_get_string() or g_checksum_get_digest(), the copied
   // checksum will be closed as well.
   // 
   // when finished using it.
   // RETURNS: the copy of the passed #GChecksum. Use g_checksum_free()
   Checksum* copy() {
      return g_checksum_copy(&this);
   }
   // Frees the memory allocated for @checksum.
   void free() {
      g_checksum_free(&this);
   }

   // Gets the digest from @checksum as a raw binary vector and places it
   // into @buffer. The size of the digest depends on the type of checksum.
   // 
   // Once this function has been called, the #GChecksum is closed and can
   // no longer be updated with g_checksum_update().
   // <buffer>: output buffer
   // <digest_len>: an inout parameter. The caller initializes it to the size of @buffer. After the call it contains the length of the digest.
   void get_digest(ubyte* buffer, size_t* digest_len) {
      g_checksum_get_digest(&this, buffer, digest_len);
   }

   // Gets the digest as an hexadecimal string.
   // 
   // Once this function has been called the #GChecksum can no longer be
   // updated with g_checksum_update().
   // 
   // The hexadecimal characters will be lower case.
   // 
   // returned string is owned by the checksum and should not be modified
   // or freed.
   // RETURNS: the hexadecimal representation of the checksum. The
   char* get_string() {
      return g_checksum_get_string(&this);
   }
   // Resets the state of the @checksum back to its initial state.
   void reset() {
      g_checksum_reset(&this);
   }

   // Feeds @data into an existing #GChecksum. The checksum must still be
   // open, that is g_checksum_get_string() or g_checksum_get_digest() must
   // not have been called on @checksum.
   // <data>: buffer used to compute the checksum
   // <length>: size of the buffer, or -1 if it is a null-terminated string.
   void update(ubyte* data, ssize_t length) {
      g_checksum_update(&this, data, length);
   }

   // Unintrospectable function: new() / g_checksum_new()
   // Creates a new #GChecksum, using the checksum algorithm @checksum_type.
   // If the @checksum_type is not known, %NULL is returned.
   // A #GChecksum can be used to compute the checksum, or digest, of an
   // arbitrary binary blob, using different hashing algorithms.
   // 
   // A #GChecksum works by feeding a binary blob through g_checksum_update()
   // until there is data to be checked; the digest can then be extracted
   // using g_checksum_get_string(), which will return the checksum as a
   // hexadecimal string; or g_checksum_get_digest(), which will return a
   // vector of raw bytes. Once either g_checksum_get_string() or
   // g_checksum_get_digest() have been called on a #GChecksum, the checksum
   // will be closed and it won't be possible to call g_checksum_update()
   // on it anymore.
   // 
   // Use g_checksum_free() to free the memory allocated by it.
   // RETURNS: the newly created #GChecksum, or %NULL.
   // <checksum_type>: the desired type of checksum
   static Checksum* new_(ChecksumType checksum_type) {
      return g_checksum_new(checksum_type);
   }

   // Gets the length in bytes of digests of type @checksum_type
   // 
   // not supported.
   // RETURNS: the checksum length, or -1 if @checksum_type is
   // <checksum_type>: a #GChecksumType
   static ssize_t type_get_length(ChecksumType checksum_type) {
      return g_checksum_type_get_length(checksum_type);
   }
}


// The hashing algorithm to be used by #GChecksum when performing the
// digest of some data.
// 
// Note that the #GChecksumType enumeration may be extended at a later
// date to include new hashing algorithm types.
enum ChecksumType /* Version 2.16 */ {
   MD5 = 0,
   SHA1 = 1,
   SHA256 = 2
}

// The type of functions to be called when a child exists.
// <pid>: the process id of the child process
// <status>: Status information about the child process, see waitpid(2) for more information about this field
// <user_data>: user data passed to g_child_watch_add()
extern (C) alias void function (Pid pid, int status, void* user_data) ChildWatchFunc;


// 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.
// <a>: a value.
// <b>: a value to compare with.
// <user_data>: user data to pass to comparison function.
extern (C) alias int function (const(void)* a, const(void)* b, void* user_data) CompareDataFunc;


// 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.
// <a>: a value.
// <b>: a value to compare with.
extern (C) alias int function (const(void)* a, const(void)* b) CompareFunc;

// The data structure used for automatic completion.
struct Completion {
   GLib2.List* items;
   CompletionFunc func;
   char* prefix;
   GLib2.List* cache;
   CompletionStrncmpFunc strncmp_func;


   // Unintrospectable method: add_items() / g_completion_add_items()
   // Adds items to the #GCompletion.
   // <items>: the list of items to add.
   void add_items(GLib2.List* items) {
      g_completion_add_items(&this, items);
   }
   // Removes all items from the #GCompletion.
   void clear_items() {
      g_completion_clear_items(&this);
   }

   // Unintrospectable method: complete() / g_completion_complete()
   // Attempts to complete the string @prefix using the #GCompletion
   // target items.
   // <prefix>: the prefix string, typically typed by the user, which is compared with each of the items.
   // <new_prefix>: if non-%NULL, returns the longest prefix which is common to all items that matched @prefix, or %NULL if no items matched @prefix.  This string should be freed when no longer needed.
   GLib2.List* complete(char* prefix, char** new_prefix) {
      return g_completion_complete(&this, prefix, new_prefix);
   }

   // Attempts to complete the string @prefix using the #GCompletion target items.
   // In contrast to g_completion_complete(), this function returns the largest common
   // prefix that is a valid UTF-8 string, omitting a possible common partial
   // character.
   // 
   // You should use this function instead of g_completion_complete() if your
   // items are UTF-8 strings.
   // 
   // not be changed.
   // RETURNS: the list of items whose strings begin with @prefix. This should
   // <prefix>: the prefix string, typically used by the user, which is compared with each of the items
   // <new_prefix>: if non-%NULL, returns the longest prefix which is common to all items that matched @prefix, or %NULL if no items matched @prefix. This string should be freed when no longer needed.
   GLib2.List* complete_utf8(char* prefix, char** new_prefix) {
      return g_completion_complete_utf8(&this, prefix, new_prefix);
   }
   // Frees all memory used by the #GCompletion.
   void free() {
      g_completion_free(&this);
   }

   // Unintrospectable method: remove_items() / g_completion_remove_items()
   // Removes items from a #GCompletion.
   // <items>: the items to remove.
   void remove_items(GLib2.List* items) {
      g_completion_remove_items(&this, items);
   }

   // Unintrospectable method: set_compare() / g_completion_set_compare()
   // Sets the function to use for string comparisons. The default string
   // comparison function is strncmp().
   // <strncmp_func>: the string comparison function.
   void set_compare(CompletionStrncmpFunc strncmp_func) {
      g_completion_set_compare(&this, strncmp_func);
   }

   // Unintrospectable function: new() / g_completion_new()
   // Creates a new #GCompletion.
   // <func>: the function to be called to return the string representing an item in the #GCompletion, or %NULL if strings are going to be used as the #GCompletion items.
   static Completion* new_(CompletionFunc func) {
      return g_completion_new(func);
   }
}


// 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.
extern (C) alias char* /*new*/ function (void* arg_a) CompletionFunc;


// Specifies the type of the function passed to
// g_completion_set_compare(). This is used when you use strings as
// #GCompletion items.
// <s1>: string to compare with @s2.
// <s2>: string to compare with @s1.
// <n>: maximal number of bytes to compare.
extern (C) alias int function (char* s1, char* s2, size_t n) CompletionStrncmpFunc;


// The #GCond struct is an opaque data structure that represents a
// condition. Threads can block on a #GCond if they find a certain
// condition to be false. If other threads change the state of this
// condition they signal the #GCond, and that causes the waiting
// threads to be woken up.
// 
// <example>
// <title>
// Using GCond to block a thread until a condition is satisfied
// </title>
// <programlisting>
// GCond* data_cond = NULL; /<!-- -->* Must be initialized somewhere *<!-- -->/
// GMutex* data_mutex = NULL; /<!-- -->* Must be initialized somewhere *<!-- -->/
// gpointer current_data = NULL;
// 
// void
// push_data (gpointer data)
// {
// g_mutex_lock (data_mutex);
// current_data = data;
// g_cond_signal (data_cond);
// g_mutex_unlock (data_mutex);
// }
// 
// gpointer
// pop_data (void)
// {
// gpointer data;
// 
// g_mutex_lock (data_mutex);
// while (!current_data)
// g_cond_wait (data_cond, data_mutex);
// data = current_data;
// current_data = NULL;
// g_mutex_unlock (data_mutex);
// 
// return data;
// }
// </programlisting>
// </example>
// 
// Whenever a thread calls <function>pop_data()</function> now, it will
// wait until current_data is non-%NULL, i.e. until some other thread
// has called <function>push_data()</function>.
// 
// <note><para>It is important to use the g_cond_wait() and
// g_cond_timed_wait() functions only inside a loop which checks for the
// condition to be true.  It is not guaranteed that the waiting thread
// will find the condition fulfilled after it wakes up, even if the
// signaling thread left the condition in that state: another thread may
// have altered the condition before the waiting thread got the chance
// to be woken up, even if the condition itself is protected by a
// #GMutex, like above.</para></note>
// 
// A #GCond should only be accessed via the following functions.
// 
// <note><para>All of the <function>g_cond_*</function> functions are
// actually macros. Apart from taking their addresses, you can however
// use them as if they were functions.</para></note>
struct Cond {
}

// Error codes returned by character set conversion routines.
enum ConvertError {
   NO_CONVERSION = 0,
   ILLEGAL_SEQUENCE = 1,
   FAILED = 2,
   PARTIAL_INPUT = 3,
   BAD_URI = 4,
   NOT_ABSOLUTE_PATH = 5
}

// Unintrospectable callback: CopyFunc() / ()
// A function of this signature is used to copy the node data 
// when doing a deep-copy of a tree.
// RETURNS: A pointer to the copy
// <src>: A pointer to the data which should be copied
// <data>: Additional data
extern (C) alias void* function (const(void)* src, void* data) CopyFunc;

enum int DATALIST_FLAGS_MASK = 3;
enum int DATE_BAD_DAY = 0;
enum int DATE_BAD_JULIAN = 0;
enum int DATE_BAD_YEAR = 0;
enum int DIR_SEPARATOR = 92;
enum DIR_SEPARATOR_S = "\\";

// The #GData struct is an opaque data structure to represent a <link
// linkend="glib-Keyed-Data-Lists">Keyed Data List</link>. It should
// only be accessed via the following functions.
struct Data {
}


// 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().
// <key_id>: the #GQuark id to identifying the data element.
// <data>: the data element.
// <user_data>: user data passed to g_dataset_foreach().
extern (C) alias void function (Quark key_id, void* data, void* user_data) DataForeachFunc;

struct Date {
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "julian_days", 32,
   uint, "julian", 1,
   uint, "dmy", 1,
   uint, "day", 6,
   uint, "month", 4,
   uint, "year", 16,
    uint, "__dummy64A", 4));

   static Date* /*new*/ new_() {
      return g_date_new();
   }
   static Date* /*new*/ new_dmy(DateDay day, DateMonth month, DateYear year) {
      return g_date_new_dmy(day, month, year);
   }
   static Date* /*new*/ new_julian(uint julian_day) {
      return g_date_new_julian(julian_day);
   }
   void add_days(uint n_days) {
      g_date_add_days(&this, n_days);
   }
   void add_months(uint n_months) {
      g_date_add_months(&this, n_months);
   }
   void add_years(uint n_years) {
      g_date_add_years(&this, n_years);
   }
   void clamp(Date* min_date, Date* max_date) {
      g_date_clamp(&this, min_date, max_date);
   }
   void clear(uint n_dates) {
      g_date_clear(&this, n_dates);
   }
   int compare(Date* rhs) {
      return g_date_compare(&this, rhs);
   }
   int days_between(Date* date2) {
      return g_date_days_between(&this, date2);
   }
   void free() {
      g_date_free(&this);
   }
   DateDay get_day() {
      return g_date_get_day(&this);
   }
   uint get_day_of_year() {
      return g_date_get_day_of_year(&this);
   }

   // Returns the week of the year, where weeks are interpreted according
   // to ISO 8601.
   // RETURNS: ISO 8601 week number of the year.
   uint get_iso8601_week_of_year() {
      return g_date_get_iso8601_week_of_year(&this);
   }
   uint get_julian() {
      return g_date_get_julian(&this);
   }
   uint get_monday_week_of_year() {
      return g_date_get_monday_week_of_year(&this);
   }
   DateMonth get_month() {
      return g_date_get_month(&this);
   }
   uint get_sunday_week_of_year() {
      return g_date_get_sunday_week_of_year(&this);
   }
   DateWeekday get_weekday() {
      return g_date_get_weekday(&this);
   }
   DateYear get_year() {
      return g_date_get_year(&this);
   }
   int is_first_of_month() {
      return g_date_is_first_of_month(&this);
   }
   int is_last_of_month() {
      return g_date_is_last_of_month(&this);
   }
   void order(Date* date2) {
      g_date_order(&this, date2);
   }
   void set_day(DateDay day) {
      g_date_set_day(&this, day);
   }
   void set_dmy(DateDay day, DateMonth month, DateYear y) {
      g_date_set_dmy(&this, day, month, y);
   }
   void set_julian(uint julian_date) {
      g_date_set_julian(&this, julian_date);
   }
   void set_month(DateMonth month) {
      g_date_set_month(&this, month);
   }
   void set_parse(char* str) {
      g_date_set_parse(&this, str);
   }

   // Sets the value of a date from a #GTime value.
   // The time to date conversion is done using the user's current timezone.
   // <time_>: #GTime value to set.
   void set_time(Time time_) {
      g_date_set_time(&this, time_);
   }

   // Sets the value of a date to the date corresponding to a time
   // specified as a time_t. The time to date conversion is done using
   // the user's current timezone.
   // 
   // To set the value of a date to the current day, you could write:
   // |[
   // g_date_set_time_t (date, time (NULL));
   // ]|
   // <timet>: <type>time_t</type> value to set
   void set_time_t(time_t timet) {
      g_date_set_time_t(&this, timet);
   }

   // Sets the value of a date from a #GTimeVal value.  Note that the
   // @tv_usec member is ignored, because #GDate can't make use of the
   // additional precision.
   // 
   // The time to date conversion is done using the user's current timezone.
   // <timeval>: #GTimeVal value to set
   void set_time_val(TimeVal* timeval) {
      g_date_set_time_val(&this, timeval);
   }
   void set_year(DateYear year) {
      g_date_set_year(&this, year);
   }
   void subtract_days(uint n_days) {
      g_date_subtract_days(&this, n_days);
   }
   void subtract_months(uint n_months) {
      g_date_subtract_months(&this, n_months);
   }
   void subtract_years(uint n_years) {
      g_date_subtract_years(&this, n_years);
   }
   void to_struct_tm(void** tm) {
      g_date_to_struct_tm(&this, tm);
   }
   int valid() {
      return g_date_valid(&this);
   }
   static ubyte get_days_in_month(DateMonth month, DateYear year) {
      return g_date_get_days_in_month(month, year);
   }
   static ubyte get_monday_weeks_in_year(DateYear year) {
      return g_date_get_monday_weeks_in_year(year);
   }
   static ubyte get_sunday_weeks_in_year(DateYear year) {
      return g_date_get_sunday_weeks_in_year(year);
   }
   static int is_leap_year(DateYear year) {
      return g_date_is_leap_year(year);
   }
   static size_t strftime(char* s, size_t slen, char* format, Date* date) {
      return g_date_strftime(s, slen, format, date);
   }
   static int valid_day(DateDay day) {
      return g_date_valid_day(day);
   }
   static int valid_dmy(DateDay day, DateMonth month, DateYear year) {
      return g_date_valid_dmy(day, month, year);
   }
   static int valid_julian(uint julian_date) {
      return g_date_valid_julian(julian_date);
   }
   static int valid_month(DateMonth month) {
      return g_date_valid_month(month);
   }
   static int valid_weekday(DateWeekday weekday) {
      return g_date_valid_weekday(weekday);
   }
   static int valid_year(DateYear year) {
      return g_date_valid_year(year);
   }
}

enum DateDMY {
   DAY = 0,
   MONTH = 1,
   YEAR = 2
}
enum DateMonth {
   BAD_MONTH = 0,
   JANUARY = 1,
   FEBRUARY = 2,
   MARCH = 3,
   APRIL = 4,
   MAY = 5,
   JUNE = 6,
   JULY = 7,
   AUGUST = 8,
   SEPTEMBER = 9,
   OCTOBER = 10,
   NOVEMBER = 11,
   DECEMBER = 12
}

// <structname>GDateTime</structname> is an opaque structure whose members
// cannot be accessed directly.
struct DateTime /* Version 2.26 */ {

   // Creates a new #GDateTime corresponding to the given date and time in
   // the time zone @tz.
   // 
   // The @year must be between 1 and 9999, @month between 1 and 12 and @day
   // between 1 and 28, 29, 30 or 31 depending on the month and the year.
   // 
   // @hour must be between 0 and 23 and @minute must be between 0 and 59.
   // 
   // @seconds must be at least 0.0 and must be strictly less than 60.0.
   // It will be rounded down to the nearest microsecond.
   // 
   // If the given time is not representable in the given time zone (for
   // example, 02:30 on March 14th 2010 in Toronto, due to daylight savings
   // time) then the time will be rounded up to the nearest existing time
   // (in this case, 03:00).  If this matters to you then you should verify
   // the return value for containing the same as the numbers you gave.
   // 
   // In the case that the given time is ambiguous in the given time zone
   // (for example, 01:30 on November 7th 2010 in Toronto, due to daylight
   // savings time) then the time falling within standard (ie:
   // non-daylight) time is taken.
   // 
   // It not considered a programmer error for the values to this function
   // to be out of range, but in the case that they are, the function will
   // return %NULL.
   // 
   // You should release the return value by calling g_date_time_unref()
   // when you are done with it.
   // RETURNS: a new #GDateTime, or %NULL
   // <tz>: a #GTimeZone
   // <year>: the year component of the date
   // <month>: the month component of the date
   // <day>: the day component of the date
   // <hour>: the hour component of the date
   // <minute>: the minute component of the date
   // <seconds>: the number of seconds past the minute
   static DateTime* /*new*/ new_(TimeZone* tz, int year, int month, int day, int hour, int minute, double seconds) {
      return g_date_time_new(tz, year, month, day, hour, minute, seconds);
   }

   // Creates a #GDateTime corresponding to the given #GTimeVal @tv in the
   // local time zone.
   // 
   // The time contained in a #GTimeVal is always stored in the form of
   // seconds elapsed since 1970-01-01 00:00:00 UTC, regardless of the
   // local time offset.
   // 
   // This call can fail (returning %NULL) if @tv represents a time outside
   // of the supported range of #GDateTime.
   // 
   // You should release the return value by calling g_date_time_unref()
   // when you are done with it.
   // RETURNS: a new #GDateTime, or %NULL
   // <tv>: a #GTimeVal
   static DateTime* /*new*/ new_from_timeval_local(TimeVal* tv) {
      return g_date_time_new_from_timeval_local(tv);
   }

   // Creates a #GDateTime corresponding to the given #GTimeVal @tv in UTC.
   // 
   // The time contained in a #GTimeVal is always stored in the form of
   // seconds elapsed since 1970-01-01 00:00:00 UTC.
   // 
   // This call can fail (returning %NULL) if @tv represents a time outside
   // of the supported range of #GDateTime.
   // 
   // You should release the return value by calling g_date_time_unref()
   // when you are done with it.
   // RETURNS: a new #GDateTime, or %NULL
   // <tv>: a #GTimeVal
   static DateTime* /*new*/ new_from_timeval_utc(TimeVal* tv) {
      return g_date_time_new_from_timeval_utc(tv);
   }

   // Creates a #GDateTime corresponding to the given Unix time @t in the
   // local time zone.
   // 
   // Unix time is the number of seconds that have elapsed since 1970-01-01
   // 00:00:00 UTC, regardless of the local time offset.
   // 
   // This call can fail (returning %NULL) if @t represents a time outside
   // of the supported range of #GDateTime.
   // 
   // You should release the return value by calling g_date_time_unref()
   // when you are done with it.
   // RETURNS: a new #GDateTime, or %NULL
   // <t>: the Unix time
   static DateTime* /*new*/ new_from_unix_local(long t) {
      return g_date_time_new_from_unix_local(t);
   }

   // Creates a #GDateTime corresponding to the given Unix time @t in UTC.
   // 
   // Unix time is the number of seconds that have elapsed since 1970-01-01
   // 00:00:00 UTC.
   // 
   // This call can fail (returning %NULL) if @t represents a time outside
   // of the supported range of #GDateTime.
   // 
   // You should release the return value by calling g_date_time_unref()
   // when you are done with it.
   // RETURNS: a new #GDateTime, or %NULL
   // <t>: the Unix time
   static DateTime* /*new*/ new_from_unix_utc(long t) {
      return g_date_time_new_from_unix_utc(t);
   }

   // Creates a new #GDateTime corresponding to the given date and time in
   // the local time zone.
   // 
   // This call is equivalent to calling g_date_time_new() with the time
   // zone returned by g_time_zone_new_local().
   // RETURNS: a #GDateTime, or %NULL
   // <year>: the year component of the date
   // <month>: the month component of the date
   // <day>: the day component of the date
   // <hour>: the hour component of the date
   // <minute>: the minute component of the date
   // <seconds>: the number of seconds past the minute
   static DateTime* /*new*/ new_local(int year, int month, int day, int hour, int minute, double seconds) {
      return g_date_time_new_local(year, month, day, hour, minute, seconds);
   }

   // Creates a #GDateTime corresponding to this exact instant in the given
   // time zone @tz.  The time is as accurate as the system allows, to a
   // maximum accuracy of 1 microsecond.
   // 
   // This function will always succeed unless the system clock is set to
   // truly insane values (or unless GLib is still being used after the
   // year 9999).
   // 
   // You should release the return value by calling g_date_time_unref()
   // when you are done with it.
   // RETURNS: a new #GDateTime, or %NULL
   // <tz>: a #GTimeZone
   static DateTime* /*new*/ new_now(TimeZone* tz) {
      return g_date_time_new_now(tz);
   }

   // Creates a #GDateTime corresponding to this exact instant in the local
   // time zone.
   // 
   // This is equivalent to calling g_date_time_new_now() with the time
   // zone returned by g_time_zone_new_local().
   // RETURNS: a new #GDateTime, or %NULL
   static DateTime* /*new*/ new_now_local() {
      return g_date_time_new_now_local();
   }

   // Creates a #GDateTime corresponding to this exact instant in UTC.
   // 
   // This is equivalent to calling g_date_time_new_now() with the time
   // zone returned by g_time_zone_new_utc().
   // RETURNS: a new #GDateTime, or %NULL
   static DateTime* /*new*/ new_now_utc() {
      return g_date_time_new_now_utc();
   }

   // Creates a new #GDateTime corresponding to the given date and time in
   // UTC.
   // 
   // This call is equivalent to calling g_date_time_new() with the time
   // zone returned by g_time_zone_new_utc().
   // RETURNS: a #GDateTime, or %NULL
   // <year>: the year component of the date
   // <month>: the month component of the date
   // <day>: the day component of the date
   // <hour>: the hour component of the date
   // <minute>: the minute component of the date
   // <seconds>: the number of seconds past the minute
   static DateTime* /*new*/ new_utc(int year, int month, int day, int hour, int minute, double seconds) {
      return g_date_time_new_utc(year, month, day, hour, minute, seconds);
   }

   // Creates a copy of @datetime and adds the specified timespan to the copy.
   // 
   // g_date_time_unref().
   // RETURNS: the newly created #GDateTime which should be freed with
   // <timespan>: a #GTimeSpan
   DateTime* /*new*/ add(TimeSpan timespan) {
      return g_date_time_add(&this, timespan);
   }

   // Creates a copy of @datetime and adds the specified number of days to the
   // copy.
   // 
   // g_date_time_unref().
   // RETURNS: the newly created #GDateTime which should be freed with
   // <days>: the number of days
   DateTime* /*new*/ add_days(int days) {
      return g_date_time_add_days(&this, days);
   }

   // Creates a new #GDateTime adding the specified values to the current date and
   // time in @datetime.
   // 
   // g_date_time_unref().
   // RETURNS: the newly created #GDateTime that should be freed with
   // <years>: the number of years to add
   // <months>: the number of months to add
   // <days>: the number of days to add
   // <hours>: the number of hours to add
   // <minutes>: the number of minutes to add
   // <seconds>: the number of seconds to add
   DateTime* /*new*/ add_full(int years, int months, int days, int hours, int minutes, double seconds) {
      return g_date_time_add_full(&this, years, months, days, hours, minutes, seconds);
   }

   // Creates a copy of @datetime and adds the specified number of hours
   // 
   // g_date_time_unref().
   // RETURNS: the newly created #GDateTime which should be freed with
   // <hours>: the number of hours to add
   DateTime* /*new*/ add_hours(int hours) {
      return g_date_time_add_hours(&this, hours);
   }

   // Creates a copy of @datetime adding the specified number of minutes.
   // 
   // g_date_time_unref().
   // RETURNS: the newly created #GDateTime which should be freed with
   // <minutes>: the number of minutes to add
   DateTime* /*new*/ add_minutes(int minutes) {
      return g_date_time_add_minutes(&this, minutes);
   }

   // Creates a copy of @datetime and adds the specified number of months to the
   // copy.
   // 
   // g_date_time_unref().
   // RETURNS: the newly created #GDateTime which should be freed with
   // <months>: the number of months
   DateTime* /*new*/ add_months(int months) {
      return g_date_time_add_months(&this, months);
   }

   // Creates a copy of @datetime and adds the specified number of seconds.
   // 
   // g_date_time_unref().
   // RETURNS: the newly created #GDateTime which should be freed with
   // <seconds>: the number of seconds to add
   DateTime* /*new*/ add_seconds(double seconds) {
      return g_date_time_add_seconds(&this, seconds);
   }

   // Creates a copy of @datetime and adds the specified number of weeks to the
   // copy.
   // 
   // g_date_time_unref().
   // RETURNS: the newly created #GDateTime which should be freed with
   // <weeks>: the number of weeks
   DateTime* /*new*/ add_weeks(int weeks) {
      return g_date_time_add_weeks(&this, weeks);
   }

   // Creates a copy of @datetime and adds the specified number of years to the
   // copy.
   // 
   // g_date_time_unref().
   // RETURNS: the newly created #GDateTime which should be freed with
   // <years>: the number of years
   DateTime* /*new*/ add_years(int years) {
      return g_date_time_add_years(&this, years);
   }

   // Calculates the difference in time between @end and @begin.  The
   // #GTimeSpan that is returned is effectively @end - @begin (ie:
   // positive if the first simparameter is larger).
   // 
   // span expressed in microseconds.
   // RETURNS: the difference between the two #GDateTime, as a time
   // <begin>: a #GDateTime
   TimeSpan difference(DateTime* begin) {
      return g_date_time_difference(&this, begin);
   }

   // Creates a newly allocated string representing the requested @format.
   // 
   // The format strings understood by this function are a subset of the
   // strftime() format language. In contrast to strftime(), this function
   // always produces a UTF-8 string, regardless of the current locale.
   // Note that the rendering of many formats is locale-dependent and may
   // not match the strftime() output exactly.
   // 
   // The following format specifiers are supported:
   // 
   // <variablelist>
   // <varlistentry><term>
   // <literal>%%a</literal>:
   // </term><listitem><simpara>
   // the abbreviated weekday name according to the current locale
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%A</literal>:
   // </term><listitem><simpara>
   // the full weekday name according to the current locale
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%b</literal>:
   // </term><listitem><simpara>
   // the abbreviated month name according to the current locale
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%B</literal>:
   // </term><listitem><simpara>
   // the full month name according to the current locale
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%d</literal>:
   // </term><listitem><simpara>
   // the day of the month as a decimal number (range 01 to 31)
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%e</literal>:
   // </term><listitem><simpara>
   // the day of the month as a decimal number (range  1 to 31)
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%F</literal>:
   // </term><listitem><simpara>
   // equivalent to <literal>%%Y-%%m-%%d</literal> (the ISO 8601 date
   // format)
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%h</literal>:
   // </term><listitem><simpara>
   // equivalent to <literal>%%b</literal>
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%H</literal>:
   // </term><listitem><simpara>
   // the hour as a decimal number using a 24-hour clock (range 00 to
   // 23)
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%I</literal>:
   // </term><listitem><simpara>
   // the hour as a decimal number using a 12-hour clock (range 01 to
   // 12)
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%j</literal>:
   // </term><listitem><simpara>
   // the day of the year as a decimal number (range 001 to 366)
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%k</literal>:
   // </term><listitem><simpara>
   // the hour (24-hour clock) as a decimal number (range 0 to 23);
   // single digits are preceded by a blank
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%l</literal>:
   // </term><listitem><simpara>
   // the hour (12-hour clock) as a decimal number (range 1 to 12);
   // single digits are preceded by a blank
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%m</literal>:
   // </term><listitem><simpara>
   // the month as a decimal number (range 01 to 12)
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%M</literal>:
   // </term><listitem><simpara>
   // the minute as a decimal number (range 00 to 59)
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%N</literal>:
   // </term><listitem><simpara>
   // the micro-seconds as a decimal number
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%p</literal>:
   // </term><listitem><simpara>
   // either "AM" or "PM" according to the given time value, or the
   // corresponding  strings for the current locale.  Noon is treated as
   // "PM" and midnight as "AM".
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%P</literal>:
   // </term><listitem><simpara>
   // like %%p but lowercase: "am" or "pm" or a corresponding string for
   // the current locale
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%r</literal>:
   // </term><listitem><simpara>
   // the time in a.m. or p.m. notation
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%R</literal>:
   // </term><listitem><simpara>
   // the time in 24-hour notation (<literal>%%H:%%M</literal>)
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%s</literal>:
   // </term><listitem><simpara>
   // the number of seconds since the Epoch, that is, since 1970-01-01
   // 00:00:00 UTC
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%S</literal>:
   // </term><listitem><simpara>
   // the second as a decimal number (range 00 to 60)
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%t</literal>:
   // </term><listitem><simpara>
   // a tab character
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%T</literal>:
   // </term><listitem><simpara>
   // the time in 24-hour notation with seconds (<literal>%%H:%%M:%%S</literal>)
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%u</literal>:
   // </term><listitem><simpara>
   // the day of the week as a decimal, range 1 to 7, Monday being 1
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%W</literal>:
   // </term><listitem><simpara>
   // the week number of the current year as a decimal number
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%x</literal>:
   // </term><listitem><simpara>
   // the preferred date representation for the current locale without
   // the time
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%X</literal>:
   // </term><listitem><simpara>
   // the preferred time representation for the current locale without
   // the date
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%y</literal>:
   // </term><listitem><simpara>
   // the year as a decimal number without the century
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%Y</literal>:
   // </term><listitem><simpara>
   // the year as a decimal number including the century
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%z</literal>:
   // </term><listitem><simpara>
   // the time-zone as hour offset from UTC
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%Z</literal>:
   // </term><listitem><simpara>
   // the time zone or name or abbreviation
   // </simpara></listitem></varlistentry>
   // <varlistentry><term>
   // <literal>%%%</literal>:
   // </term><listitem><simpara>
   // a literal <literal>%%</literal> character
   // </simpara></listitem></varlistentry>
   // </variablelist>
   // 
   // Some conversion specifications can be modified by preceding the
   // conversion specifier by one or more modifier characters. The
   // following modifiers are supported for many of the numeric
   // conversions:
   // <variablelist>
   // <varlistentry>
   // <term>O</term>
   // <listitem>
   // Use alternative numeric symbols, if the current locale
   // supports those.
   // </listitem>
   // </varlistentry>
   // <varlistentry>
   // <term>_</term>
   // <listitem>
   // Pad a numeric result with spaces.
   // This overrides the default padding for the specifier.
   // </listitem>
   // </varlistentry>
   // <varlistentry>
   // <term>-</term>
   // <listitem>
   // Do not pad a numeric result.
   // This overrides the default padding for the specifier.
   // </listitem>
   // </varlistentry>
   // <varlistentry>
   // <term>0</term>
   // <listitem>
   // Pad a numeric result with zeros.
   // This overrides the default padding for the specifier.
   // </listitem>
   // </varlistentry>
   // </variablelist>
   // 
   // or %NULL in the case that there was an error.  The string
   // should be freed with g_free().
   // RETURNS: a newly allocated string formatted to the requested format
   // <format>: a valid UTF-8 string, containing the format for the #GDateTime
   char* /*new*/ format(char* format) {
      return g_date_time_format(&this, format);
   }

   // Retrieves the day of the month represented by @datetime in the gregorian
   // calendar.
   // RETURNS: the day of the month
   int get_day_of_month() {
      return g_date_time_get_day_of_month(&this);
   }

   // Retrieves the ISO 8601 day of the week on which @datetime falls (1 is
   // Monday, 2 is Tuesday... 7 is Sunday).
   // RETURNS: the day of the week
   int get_day_of_week() {
      return g_date_time_get_day_of_week(&this);
   }

   // Retrieves the day of the year represented by @datetime in the Gregorian
   // calendar.
   // RETURNS: the day of the year
   int get_day_of_year() {
      return g_date_time_get_day_of_year(&this);
   }

   // Retrieves the hour of the day represented by @datetime
   // RETURNS: the hour of the day
   int get_hour() {
      return g_date_time_get_hour(&this);
   }

   // Retrieves the microsecond of the date represented by @datetime
   // RETURNS: the microsecond of the second
   int get_microsecond() {
      return g_date_time_get_microsecond(&this);
   }

   // Retrieves the minute of the hour represented by @datetime
   // RETURNS: the minute of the hour
   int get_minute() {
      return g_date_time_get_minute(&this);
   }

   // Retrieves the month of the year represented by @datetime in the Gregorian
   // calendar.
   // RETURNS: the month represented by @datetime
   int get_month() {
      return g_date_time_get_month(&this);
   }

   // Retrieves the second of the minute represented by @datetime
   // RETURNS: the second represented by @datetime
   int get_second() {
      return g_date_time_get_second(&this);
   }

   // Retrieves the number of seconds since the start of the last minute,
   // including the fractional part.
   // RETURNS: the number of seconds
   double get_seconds() {
      return g_date_time_get_seconds(&this);
   }

   // Determines the time zone abbreviation to be used at the time and in
   // the time zone of @datetime.
   // 
   // For example, in Toronto this is currently "EST" during the winter
   // months and "EDT" during the summer months when daylight savings
   // time is in effect.
   // 
   // string is owned by the #GDateTime and it should not be
   // modified or freed
   // RETURNS: the time zone abbreviation. The returned
   char* get_timezone_abbreviation() {
      return g_date_time_get_timezone_abbreviation(&this);
   }

   // Determines the offset to UTC in effect at the time and in the time
   // zone of @datetime.
   // 
   // The offset is the number of microseconds that you add to UTC time to
   // arrive at local time for the time zone (ie: negative numbers for time
   // zones west of GMT, positive numbers for east).
   // 
   // If @datetime represents UTC time, then the offset is always zero.
   // 
   // get the local time
   // RETURNS: the number of microseconds that should be added to UTC to
   TimeSpan get_utc_offset() {
      return g_date_time_get_utc_offset(&this);
   }

   // Returns the ISO 8601 week-numbering year in which the week containing
   // @datetime falls.
   // 
   // This function, taken together with g_date_time_get_week_of_year() and
   // g_date_time_get_day_of_week() can be used to determine the full ISO
   // week date on which @datetime falls.
   // 
   // This is usually equal to the normal Gregorian year (as returned by
   // g_date_time_get_year()), except as detailed below:
   // 
   // For Thursday, the week-numbering year is always equal to the usual
   // calendar year.  For other days, the number is such that every day
   // within a complete week (Monday to Sunday) is contained within the
   // same week-numbering year.
   // 
   // For Monday, Tuesday and Wednesday occurring near the end of the year,
   // this may mean that the week-numbering year is one greater than the
   // calendar year (so that these days have the same week-numbering year
   // as the Thursday occurring early in the next year).
   // 
   // For Friday, Saturaday and Sunday occurring near the start of the year,
   // this may mean that the week-numbering year is one less than the
   // calendar year (so that these days have the same week-numbering year
   // as the Thursday occurring late in the previous year).
   // 
   // An equivalent description is that the week-numbering year is equal to
   // the calendar year containing the majority of the days in the current
   // week (Monday to Sunday).
   // 
   // Note that January 1 0001 in the proleptic Gregorian calendar is a
   // Monday, so this function never returns 0.
   // RETURNS: the ISO 8601 week-numbering year for @datetime
   int get_week_numbering_year() {
      return g_date_time_get_week_numbering_year(&this);
   }

   // Returns the ISO 8601 week number for the week containing @datetime.
   // The ISO 8601 week number is the same for every day of the week (from
   // Moday through Sunday).  That can produce some unusual results
   // (described below).
   // 
   // The first week of the year is week 1.  This is the week that contains
   // the first Thursday of the year.  Equivalently, this is the first week
   // that has more than 4 of its days falling within the calendar year.
   // 
   // The value 0 is never returned by this function.  Days contained
   // within a year but occurring before the first ISO 8601 week of that
   // year are considered as being contained in the last week of the
   // previous year.  Similarly, the final days of a calendar year may be
   // considered as being part of the first ISO 8601 week of the next year
   // if 4 or more days of that week are contained within the new year.
   // RETURNS: the ISO 8601 week number for @datetime.
   int get_week_of_year() {
      return g_date_time_get_week_of_year(&this);
   }

   // Retrieves the year represented by @datetime in the Gregorian calendar.
   // RETURNS: the year represented by @datetime
   int get_year() {
      return g_date_time_get_year(&this);
   }

   // Retrieves the Gregorian day, month, and year of a given #GDateTime.
   // <year>: the return location for the gregorian year, or %NULL.
   // <month>: the return location for the month of the year, or %NULL.
   // <day>: the return location for the day of the month, or %NULL.
   void get_ymd(/*out*/ int* year, /*out*/ int* month, /*out*/ int* day) {
      g_date_time_get_ymd(&this, year, month, day);
   }

   // Determines if daylight savings time is in effect at the time and in
   // the time zone of @datetime.
   // RETURNS: %TRUE if daylight savings time is in effect
   int is_daylight_savings() {
      return g_date_time_is_daylight_savings(&this);
   }

   // Atomically increments the reference count of @datetime by one.
   // RETURNS: the #GDateTime with the reference count increased
   DateTime* /*new*/ ref_() {
      return g_date_time_ref(&this);
   }

   // Creates a new #GDateTime corresponding to the same instant in time as
   // @datetime, but in the local time zone.
   // 
   // This call is equivalent to calling g_date_time_to_timezone() with the
   // time zone returned by g_time_zone_new_local().
   // RETURNS: the newly created #GDateTime
   DateTime* /*new*/ to_local() {
      return g_date_time_to_local(&this);
   }

   // Stores the instant in time that @datetime represents into @tv.
   // 
   // The time contained in a #GTimeVal is always stored in the form of
   // seconds elapsed since 1970-01-01 00:00:00 UTC, regardless of the time
   // zone associated with @datetime.
   // 
   // On systems where 'long' is 32bit (ie: all 32bit systems and all
   // Windows systems), a #GTimeVal is incapable of storing the entire
   // range of values that #GDateTime is capable of expressing.  On those
   // systems, this function returns %FALSE to indicate that the time is
   // out of range.
   // 
   // On systems where 'long' is 64bit, this function never fails.
   // RETURNS: %TRUE if successful, else %FALSE
   // <tv>: a #GTimeVal to modify
   int to_timeval(TimeVal* tv) {
      return g_date_time_to_timeval(&this, tv);
   }

   // Create a new #GDateTime corresponding to the same instant in time as
   // @datetime, but in the time zone @tz.
   // 
   // This call can fail in the case that the time goes out of bounds.  For
   // example, converting 0001-01-01 00:00:00 UTC to a time zone west of
   // Greenwich will fail (due to the year 0 being out of range).
   // 
   // You should release the return value by calling g_date_time_unref()
   // when you are done with it.
   // RETURNS: a new #GDateTime, or %NULL
   // <tz>: the new #GTimeZone
   DateTime* /*new*/ to_timezone(TimeZone* tz) {
      return g_date_time_to_timezone(&this, tz);
   }

   // Gives the Unix time corresponding to @datetime, rounding down to the
   // nearest second.
   // 
   // Unix time is the number of seconds that have elapsed since 1970-01-01
   // 00:00:00 UTC, regardless of the time zone associated with @datetime.
   // RETURNS: the Unix time corresponding to @datetime
   long to_unix() {
      return g_date_time_to_unix(&this);
   }

   // Creates a new #GDateTime corresponding to the same instant in time as
   // @datetime, but in UTC.
   // 
   // This call is equivalent to calling g_date_time_to_timezone() with the
   // time zone returned by g_time_zone_new_utc().
   // RETURNS: the newly created #GDateTime
   DateTime* /*new*/ to_utc() {
      return g_date_time_to_utc(&this);
   }

   // Atomically decrements the reference count of @datetime by one.
   // 
   // When the reference count reaches zero, the resources allocated by
   // @datetime are freed
   void unref() {
      g_date_time_unref(&this);
   }

   // A comparison function for #GDateTimes that is suitable
   // as a #GCompareFunc. Both #GDateTimes must be non-%NULL.
   // 
   // than @dt2.
   // RETURNS: -1, 0 or 1 if @dt1 is less than, equal to or greater
   // <dt1>: first #GDateTime to compare
   // <dt2>: second #GDateTime to compare
   static int compare(const(void)* dt1, const(void)* dt2) {
      return g_date_time_compare(dt1, dt2);
   }

   // Checks to see if @dt1 and @dt2 are equal.
   // 
   // Equal here means that they represent the same moment after converting
   // them to the same time zone.
   // RETURNS: %TRUE if @dt1 and @dt2 are equal
   // <dt1>: a #GDateTime
   // <dt2>: a #GDateTime
   static int equal(const(void)* dt1, const(void)* dt2) {
      return g_date_time_equal(dt1, dt2);
   }

   // Hashes @datetime into a #guint, suitable for use within #GHashTable.
   // RETURNS: a #guint containing the hash
   // <datetime>: a #GDateTime
   static uint hash(const(void)* datetime) {
      return g_date_time_hash(datetime);
   }
}

enum DateWeekday {
   BAD_WEEKDAY = 0,
   MONDAY = 1,
   TUESDAY = 2,
   WEDNESDAY = 3,
   THURSDAY = 4,
   FRIDAY = 5,
   SATURDAY = 6,
   SUNDAY = 7
}

// Associates a string with a bit flag.
// Used in g_parse_debug_string().
struct DebugKey {
   char* key;
   uint value;
}


// 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.
// <data>: the data element.
extern (C) alias void function (void* data) DestroyNotify;

struct Dir {
   // Closes the directory and deallocates all related resources.
   void close() {
      g_dir_close(&this);
   }

   // Retrieves the name of another entry in the directory, or %NULL.
   // The order of entries returned from this function is not defined,
   // and may vary by file system or other operating-system dependent
   // factors.
   // 
   // On Unix, the '.' and '..' entries are omitted, and the returned
   // name is in the on-disk encoding.
   // 
   // On Windows, as is true of all GLib functions which operate on
   // filenames, the returned name is in UTF-8.
   // 
   // more entries. The return value is owned by GLib and
   // must not be modified or freed.
   // RETURNS: The entry's name or %NULL if there are no
   char* read_name() {
      return g_dir_read_name(&this);
   }

   // Resets the given directory. The next call to g_dir_read_name()
   // will return the first entry again.
   void rewind() {
      g_dir_rewind(&this);
   }

   // 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.
   // 
   // 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.
   // RETURNS: The actual name used. This string
   // <tmpl>: Template for directory name, as in g_mkdtemp(), basename only, or %NULL for a default template
   static char* /*new*/ make_tmp(char* tmpl, GLib2.Error** error=null) {
      return g_dir_make_tmp(tmpl, error);
   }

   // Unintrospectable function: open() / g_dir_open()
   // Opens a directory for reading. The names of the files in the
   // directory can then be retrieved using g_dir_read_name().  Note
   // that the ordering is not defined.
   // 
   // If non-%NULL, you must free the result with g_dir_close()
   // when you are finished with it.
   // RETURNS: a newly allocated #GDir on success, %NULL on failure.
   // <path>: the path to the directory you are interested in. On Unix in the on-disk encoding. On Windows in UTF-8
   // <flags>: Currently must be set to 0. Reserved for future use.
   static Dir* open(char* path, uint flags, GLib2.Error** error=null) {
      return g_dir_open(path, flags, error);
   }
}

union DoubleIEEE754 {
   double v_double;

   struct mpn {
       static import std.bitmanip; mixin(std.bitmanip.bitfields!(
      uint, "mantissa_low", 32,
      uint, "mantissa_high", 20,
      uint, "biased_exponent", 11,
      uint, "sign", 1));
   }
}

enum double E = 2.718282;

// 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.
// <a>: a value.
// <b>: a value to compare with.
extern (C) alias int function (const(void)* a, const(void)* b) EqualFunc;


// The <structname>GError</structname> structure contains
// information about an error that has occurred.
struct Error {
   Quark domain;
   int code;
   char* message;


   // Unintrospectable constructor: new() / g_error_new()
   // Creates a new #GError with the given @domain and @code,
   // and a message formatted with @format.
   // RETURNS: a new #GError
   // <domain>: error domain
   // <code>: error code
   // <format>: printf()-style format for error message
   alias g_error_new new_; // Variadic

   // Creates a new #GError; unlike g_error_new(), @message is
   // not a printf()-style format string. Use this function if
   // @message contains text you don't have control over,
   // that could include printf() escape sequences.
   // RETURNS: a new #GError
   // <domain>: error domain
   // <code>: error code
   // <message>: error message
   static Error* /*new*/ new_literal(Quark domain, int code, char* message) {
      return g_error_new_literal(domain, code, message);
   }

   // Unintrospectable constructor: new_valist() / g_error_new_valist()
   // Creates a new #GError with the given @domain and @code,
   // and a message formatted with @format.
   // RETURNS: a new #GError
   // <domain>: error domain
   // <code>: error code
   // <format>: printf()-style format for error message
   // <args>: #va_list of parameters for the message format
   static Error* /*new*/ new_valist(Quark domain, int code, char* format, va_list args) {
      return g_error_new_valist(domain, code, format, args);
   }

   // Makes a copy of @error.
   // RETURNS: a new #GError
   Error* /*new*/ copy() {
      return g_error_copy(&this);
   }
   // Frees a #GError and associated resources.
   void free() {
      g_error_free(&this);
   }

   // Returns %TRUE if @error matches @domain and @code, %FALSE
   // otherwise. In particular, when @error is %NULL, %FALSE will
   // be returned.
   // RETURNS: whether @error has @domain and @code
   // <domain>: an error domain
   // <code>: an error code
   int matches(Quark domain, int code) {
      return g_error_matches(&this, domain, code);
   }
}

enum ErrorType {
   UNKNOWN = 0,
   UNEXP_EOF = 1,
   UNEXP_EOF_IN_STRING = 2,
   UNEXP_EOF_IN_COMMENT = 3,
   NON_DIGIT_IN_CONST = 4,
   DIGIT_RADIX = 5,
   FLOAT_RADIX = 6,
   FLOAT_MALFORMED = 7
}
enum FileError {
   EXIST = 0,
   ISDIR = 1,
   ACCES = 2,
   NAMETOOLONG = 3,
   NOENT = 4,
   NOTDIR = 5,
   NXIO = 6,
   NODEV = 7,
   ROFS = 8,
   TXTBSY = 9,
   FAULT = 10,
   LOOP = 11,
   NOSPC = 12,
   NOMEM = 13,
   MFILE = 14,
   NFILE = 15,
   BADF = 16,
   INVAL = 17,
   PIPE = 18,
   AGAIN = 19,
   INTR = 20,
   IO = 21,
   PERM = 22,
   NOSYS = 23,
   FAILED = 24
}
enum FileTest {
   IS_REGULAR = 1,
   IS_SYMLINK = 2,
   IS_DIR = 4,
   IS_EXECUTABLE = 8,
   EXISTS = 16
}
union FloatIEEE754 {
   float v_float;

   struct mpn {
       static import std.bitmanip; mixin(std.bitmanip.bitfields!(
      uint, "mantissa", 23,
      uint, "biased_exponent", 8,
      uint, "sign", 1));
   }
}


// Flags to modify the format of the string returned by
// g_format_size_full().
enum FormatSizeFlags {
   DEFAULT = 0,
   LONG_FORMAT = 1,
   IEC_UNITS = 2
}

// 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+.
// <data>: a data pointer
extern (C) alias void function (void* data) FreeFunc;


// Specifies the type of functions passed to g_list_foreach() and
// g_slist_foreach().
// <data>: the element's data.
// <user_data>: user data passed to g_list_foreach() or g_slist_foreach().
extern (C) alias void function (void* data, void* user_data) Func;

enum GINT16_FORMAT = "hi";
enum GINT16_MODIFIER = "h";
enum GINT32_FORMAT = "i";
enum GINT32_MODIFIER = "";
enum GINT64_FORMAT = "lli";
enum GINT64_MODIFIER = "ll";
enum GINTPTR_FORMAT = "i";
enum GINTPTR_MODIFIER = "";
enum GNUC_FUNCTION = "";
enum GNUC_PRETTY_FUNCTION = "";
enum GSIZE_FORMAT = "u";
enum GSIZE_MODIFIER = "";
enum GSSIZE_FORMAT = "i";
enum GUINT16_FORMAT = "hu";
enum GUINT32_FORMAT = "u";
enum GUINT64_FORMAT = "llu";
enum GUINTPTR_FORMAT = "u";
enum int HAVE_GINT64 = 1;
enum int HAVE_GNUC_VARARGS = 1;
enum int HAVE_GNUC_VISIBILITY = 1;
enum int HAVE_GROWING_STACK = 1;
enum int HAVE_INLINE = 1;
enum int HAVE_ISO_VARARGS = 1;
enum int HAVE___INLINE = 1;
enum int HAVE___INLINE__ = 1;

// 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().
// <key>: a key.
// <value>: the value corresponding to the key.
// <user_data>: user data passed to g_hash_table_foreach().
extern (C) alias void function (void* key, void* value, void* user_data) HFunc;

enum int HOOK_FLAG_USER_SHIFT = 4;

// Specifies the type of the function passed to
// g_hash_table_foreach_remove(). It is called with each key/value
// pair, together with the @user_data parameter passed to
// g_hash_table_foreach_remove(). It should return %TRUE if the
// key/value pair should be removed from the #GHashTable.
// <key>: a key.
// <value>: the value associated with the key.
// <user_data>: user data passed to g_hash_table_remove().
extern (C) alias int function (void* key, void* value, void* user_data) HRFunc;


// Specifies the type of the hash function which is passed to
// g_hash_table_new() when a #GHashTable is created.
// 
// The function is passed a key and should return a #guint hash value.
// The functions g_direct_hash(), g_int_hash() and g_str_hash() provide
// hash functions which can be used when the key is a #gpointer, #gint,
// and #gchar* respectively.
// 
// <!-- FIXME: Need more here. --> The hash values should be 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.
// <key>: a key.
extern (C) alias uint function (const(void)* key) HashFunc;


// The #GHashTable struct is an opaque data structure to represent a
// <link linkend="glib-Hash-Tables">Hash Table</link>. It should only be
// accessed via the following functions.
struct HashTable {

   // 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>: a #GHashTable.
   static void destroy(GLib2.HashTable* hash_table) {
      g_hash_table_destroy(hash_table);
   }

   // Unintrospectable function: find() / g_hash_table_find()
   // Calls the given function for key/value pairs in the #GHashTable until
   // @predicate 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).
   // 
   // for which @predicate evaluates to %TRUE. If no pair with the
   // requested property is found, %NULL is returned.
   // RETURNS: The value of the first key/value pair is returned,
   // <hash_table>: a #GHashTable.
   // <predicate>: function to test the key/value pairs for a certain property.
   // <user_data>: user data to pass to the function.
   static void* find(GLib2.HashTable* hash_table, HRFunc predicate, void* user_data) {
      return g_hash_table_find(hash_table, predicate, user_data);
   }

   // Unintrospectable function: foreach() / g_hash_table_foreach()
   // 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().
   // 
   // See g_hash_table_find() for performance caveats for linear
   // order searches in contrast to g_hash_table_lookup().
   // <hash_table>: a #GHashTable.
   // <func>: the function to call for each key/value pair.
   // <user_data>: user data to pass to the function.
   static void foreach_(GLib2.HashTable* hash_table, HFunc func, void* user_data) {
      g_hash_table_foreach(hash_table, func, user_data);
   }

   // Unintrospectable function: foreach_remove() / g_hash_table_foreach_remove()
   // 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.
   // RETURNS: the number of key/value pairs removed.
   // <hash_table>: a #GHashTable.
   // <func>: the function to call for each key/value pair.
   // <user_data>: user data to pass to the function.
   static uint foreach_remove(GLib2.HashTable* hash_table, HRFunc func, void* user_data) {
      return g_hash_table_foreach_remove(hash_table, func, user_data);
   }

   // Unintrospectable function: foreach_steal() / g_hash_table_foreach_steal()
   // 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.
   // RETURNS: the number of key/value pairs removed.
   // <hash_table>: a #GHashTable.
   // <func>: the function to call for each key/value pair.
   // <user_data>: user data to pass to the function.
   static uint foreach_steal(GLib2.HashTable* hash_table, HRFunc func, void* user_data) {
      return g_hash_table_foreach_steal(hash_table, func, user_data);
   }

   // Unintrospectable function: get_keys() / g_hash_table_get_keys()
   // Retrieves every key inside @hash_table. The returned data is valid
   // until @hash_table is modified.
   // 
   // table. The content of the list is owned by the hash table and
   // should not be modified or freed. Use g_list_free() when done
   // using the list.
   // RETURNS: a #GList containing all the keys inside the hash
   // <hash_table>: a #GHashTable
   static GLib2.List* get_keys(GLib2.HashTable* hash_table) {
      return g_hash_table_get_keys(hash_table);
   }

   // Unintrospectable function: get_values() / g_hash_table_get_values()
   // Retrieves every value inside @hash_table. The returned data is
   // valid until @hash_table is modified.
   // 
   // table. The content of the list is owned by the hash table and
   // should not be modified or freed. Use g_list_free() when done
   // using the list.
   // RETURNS: a #GList containing all the values inside the hash
   // <hash_table>: a #GHashTable
   static GLib2.List* get_values(GLib2.HashTable* hash_table) {
      return g_hash_table_get_values(hash_table);
   }

   // 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.
   // <hash_table>: a #GHashTable.
   // <key>: a key to insert.
   // <value>: the value to associate with the key.
   static void insert(GLib2.HashTable* hash_table, void* key, void* value) {
      g_hash_table_insert(hash_table, key, value);
   }

   // Unintrospectable function: lookup() / g_hash_table_lookup()
   // 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().
   // RETURNS: the associated value, or %NULL if the key is not found.
   // <hash_table>: a #GHashTable.
   // <key>: the key to look up.
   static void* lookup(GLib2.HashTable* hash_table, const(void)* key) {
      return g_hash_table_lookup(hash_table, 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.
   // RETURNS: %TRUE if the key was found in the #GHashTable.
   // <hash_table>: a #GHashTable
   // <lookup_key>: the key to look up
   // <orig_key>: return location for the original key, or %NULL
   // <value>: return location for the value associated with the key, or %NULL
   static int lookup_extended(GLib2.HashTable* hash_table, const(void)* lookup_key, void** orig_key, void** value) {
      return g_hash_table_lookup_extended(hash_table, lookup_key, orig_key, value);
   }

   // Unintrospectable function: new() / g_hash_table_new()
   // Creates a new #GHashTable with a reference count of 1.
   // RETURNS: a new #GHashTable.
   // <hash_func>: a function to create a hash value from a key. Hash values are used to determine where keys are stored within the #GHashTable data structure. The g_direct_hash(), g_int_hash(), g_int64_hash(), g_double_hash() and g_str_hash() functions are provided for some common types of keys. If hash_func is %NULL, g_direct_hash() is used.
   // <key_equal_func>: a function to check two keys for equality.  This is used when looking up keys in the #GHashTable.  The g_direct_equal(), g_int_equal(), g_int64_equal(), g_double_equal() and g_str_equal() functions are provided for the most common types of keys. If @key_equal_func is %NULL, keys are compared directly in a similar fashion to g_direct_equal(), but without the overhead of a function call.
   static GLib2.HashTable* new_(HashFunc hash_func, EqualFunc key_equal_func) {
      return g_hash_table_new(hash_func, key_equal_func);
   }

   // Unintrospectable function: new_full() / g_hash_table_new_full()
   // Creates a new #GHashTable like g_hash_table_new() with a reference count
   // of 1 and allows to specify functions to free the memory allocated for the
   // key and value that get called when removing the entry from the #GHashTable.
   // RETURNS: a new #GHashTable.
   // <hash_func>: a function to create a hash value from a key.
   // <key_equal_func>: a function to check two keys for equality.
   // <key_destroy_func>: a function to free the memory allocated for the key used when removing the entry from the #GHashTable or %NULL if you don't want to supply such a function.
   // <value_destroy_func>: a function to free the memory allocated for the value used when removing the entry from the #GHashTable or %NULL if you don't want to supply such a function.
   static GLib2.HashTable* new_full(HashFunc hash_func, EqualFunc key_equal_func, DestroyNotify key_destroy_func, DestroyNotify value_destroy_func) {
      return g_hash_table_new_full(hash_func, key_equal_func, key_destroy_func, value_destroy_func);
   }

   // Unintrospectable function: ref() / g_hash_table_ref()
   // Atomically increments the reference count of @hash_table by one.
   // This function is MT-safe and may be called from any thread.
   // RETURNS: the passed in #GHashTable.
   // <hash_table>: a valid #GHashTable.
   static GLib2.HashTable* ref_(GLib2.HashTable* hash_table) {
      return g_hash_table_ref(hash_table);
   }

   // 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.
   // RETURNS: %TRUE if the key was found and removed from the #GHashTable.
   // <hash_table>: a #GHashTable.
   // <key>: the key to remove.
   static int remove(GLib2.HashTable* hash_table, const(void)* key) {
      return g_hash_table_remove(hash_table, key);
   }

   // 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>: a #GHashTable
   static void remove_all(GLib2.HashTable* hash_table) {
      g_hash_table_remove_all(hash_table);
   }

   // Inserts a new key and value into a #GHashTable similar to
   // g_hash_table_insert(). The difference is that if the key already exists
   // in the #GHashTable, it gets replaced by the new key. If you supplied a
   // @value_destroy_func when creating the #GHashTable, the old value is freed
   // using that function. If you supplied a @key_destroy_func when creating the
   // #GHashTable, the old key is freed using that function.
   // <hash_table>: a #GHashTable.
   // <key>: a key to insert.
   // <value>: the value to associate with the key.
   static void replace(GLib2.HashTable* hash_table, void* key, void* value) {
      g_hash_table_replace(hash_table, key, value);
   }

   // Returns the number of elements contained in the #GHashTable.
   // RETURNS: the number of key/value pairs in the #GHashTable.
   // <hash_table>: a #GHashTable.
   static uint size(GLib2.HashTable* hash_table) {
      return g_hash_table_size(hash_table);
   }

   // Removes a key and its associated value from a #GHashTable without
   // calling the key and value destroy functions.
   // RETURNS: %TRUE if the key was found and removed from the #GHashTable.
   // <hash_table>: a #GHashTable.
   // <key>: the key to remove.
   static int steal(GLib2.HashTable* hash_table, const(void)* key) {
      return g_hash_table_steal(hash_table, key);
   }

   // Removes all keys and their associated values from a #GHashTable
   // without calling the key and value destroy functions.
   // <hash_table>: a #GHashTable.
   static void steal_all(GLib2.HashTable* hash_table) {
      g_hash_table_steal_all(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>: a valid #GHashTable.
   static void unref(GLib2.HashTable* hash_table) {
      g_hash_table_unref(hash_table);
   }
}


// A GHashTableIter structure represents an iterator that can be used
// to iterate over the elements of a #GHashTable. GHashTableIter
// structures are typically allocated on the stack and then initialized
// with g_hash_table_iter_init().
struct HashTableIter {
   private void* dummy1, dummy2, dummy3;
   private int dummy4;
   private int dummy5;
   private void* dummy6;


   // Unintrospectable method: get_hash_table() / g_hash_table_iter_get_hash_table()
   // Returns the #GHashTable associated with @iter.
   // RETURNS: the #GHashTable associated with @iter.
   GLib2.HashTable* get_hash_table() {
      return g_hash_table_iter_get_hash_table(&this);
   }

   // Initializes a key/value pair iterator and associates it with
   // @hash_table. Modifying the hash table after calling this function
   // invalidates the returned iterator.
   // |[
   // GHashTableIter iter;
   // gpointer key, value;
   // 
   // g_hash_table_iter_init (&iter, hash_table);
   // while (g_hash_table_iter_next (&iter, &key, &value))
   // {
   // /&ast; do something with key and value &ast;/
   // }
   // ]|
   // <hash_table>: a #GHashTable.
   void init(GLib2.HashTable* hash_table) {
      g_hash_table_iter_init(&this, hash_table);
   }

   // Advances @iter and retrieves the key and/or value that are now
   // pointed to as a result of this advancement. If %FALSE is returned,
   // @key and @value are not set, and the iterator becomes invalid.
   // RETURNS: %FALSE if the end of the #GHashTable has been reached.
   // <key>: a location to store the key, or %NULL.
   // <value>: a location to store the value, or %NULL.
   int next(void** key, void** value) {
      return g_hash_table_iter_next(&this, key, value);
   }

   // Removes the key/value pair currently pointed to by the iterator
   // from its associated #GHashTable. Can only be called after
   // g_hash_table_iter_next() returned %TRUE, and cannot be called more
   // than once for the same key/value pair.
   // 
   // 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.
   void remove() {
      g_hash_table_iter_remove(&this);
   }

   // Replaces the value currently pointed to by the iterator
   // from its associated #GHashTable. Can only be called after
   // g_hash_table_iter_next() returned %TRUE.
   // 
   // If you supplied a @value_destroy_func when creating the #GHashTable,
   // the old value is freed using that function.
   // <value>: the value to replace with
   void replace(void* value) {
      g_hash_table_iter_replace(&this, value);
   }

   // Removes the key/value pair currently pointed to by the iterator
   // from its associated #GHashTable, without calling the key and value
   // destroy functions. Can only be called after
   // g_hash_table_iter_next() returned %TRUE, and cannot be called more
   // than once for the same key/value pair.
   void steal() {
      g_hash_table_iter_steal(&this);
   }
}


// An opaque structure representing a HMAC operation.
// To create a new GHmac, use g_hmac_new(). To free
// a GHmac, use g_hmac_unref().
struct Hmac /* Version 2.30 */ {

   // Unintrospectable method: copy() / g_hmac_copy()
   // Copies a #GHmac. If @hmac has been closed, by calling
   // g_hmac_get_string() or g_hmac_get_digest(), the copied
   // HMAC will be closed as well.
   // 
   // when finished using it.
   // RETURNS: the copy of the passed #GHmac. Use g_hmac_unref()
   Hmac* copy() {
      return g_hmac_copy(&this);
   }

   // Gets the digest from @checksum as a raw binary array and places it
   // into @buffer. The size of the digest depends on the type of checksum.
   // 
   // Once this function has been called, the #GHmac is closed and can
   // no longer be updated with g_checksum_update().
   // <buffer>: output buffer
   // <digest_len>: an inout parameter. The caller initializes it to the size of @buffer. After the call it contains the length of the digest
   void get_digest(ubyte* buffer, size_t* digest_len) {
      g_hmac_get_digest(&this, buffer, digest_len);
   }

   // Gets the HMAC as an hexadecimal string.
   // 
   // Once this function has been called the #GHmac can no longer be
   // updated with g_hmac_update().
   // 
   // The hexadecimal characters will be lower case.
   // 
   // returned string is owned by the HMAC and should not be modified
   // or freed.
   // RETURNS: the hexadecimal representation of the HMAC. The
   char* get_string() {
      return g_hmac_get_string(&this);
   }

   // Unintrospectable method: ref() / g_hmac_ref()
   // Atomically increments the reference count of @hmac by one.
   // 
   // This function is MT-safe and may be called from any thread.
   // RETURNS: the passed in #GHmac.
   Hmac* ref_() {
      return g_hmac_ref(&this);
   }

   // Atomically decrements the reference count of @hmac 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.
   // Frees the memory allocated for @hmac.
   void unref() {
      g_hmac_unref(&this);
   }

   // Feeds @data into an existing #GHmac.
   // 
   // The HMAC must still be open, that is g_hmac_get_string() or
   // g_hmac_get_digest() must not have been called on @hmac.
   // <data>: buffer used to compute the checksum
   // <length>: size of the buffer, or -1 if it is a nul-terminated string
   void update(ubyte* data, ssize_t length) {
      g_hmac_update(&this, data, length);
   }

   // Unintrospectable function: new() / g_hmac_new()
   // Creates a new #GHmac, using the digest algorithm @digest_type.
   // If the @digest_type is not known, %NULL is returned.
   // A #GHmac can be used to compute the HMAC of a key and an
   // arbitrary binary blob, using different hashing algorithms.
   // 
   // A #GHmac works by feeding a binary blob through g_hmac_update()
   // until the data is complete; the digest can then be extracted
   // using g_hmac_get_string(), which will return the checksum as a
   // hexadecimal string; or g_hmac_get_digest(), which will return a
   // array of raw bytes. Once either g_hmac_get_string() or
   // g_hmac_get_digest() have been called on a #GHmac, the HMAC
   // will be closed and it won't be possible to call g_hmac_update()
   // on it anymore.
   // 
   // Use g_hmac_unref() to free the memory allocated by it.
   // RETURNS: the newly created #GHmac, or %NULL.
   // <digest_type>: the desired type of digest
   // <key>: the key for the HMAC
   // <key_len>: the length of the keys
   static Hmac* new_(ChecksumType digest_type, ubyte* key, size_t key_len) {
      return g_hmac_new(digest_type, key, key_len);
   }
}

struct Hook {
   void* data;
   Hook* next, prev;
   uint ref_count;
   c_ulong hook_id;
   uint flags;
   void* func;
   DestroyNotify destroy_;

   int compare_ids(Hook* sibling) {
      return g_hook_compare_ids(&this, sibling);
   }
   // Unintrospectable function: alloc() / g_hook_alloc()
   static Hook* alloc(HookList* hook_list) {
      return g_hook_alloc(hook_list);
   }
   static int destroy(HookList* hook_list, c_ulong hook_id) {
      return g_hook_destroy(hook_list, hook_id);
   }
   static void destroy_link(HookList* hook_list, Hook* hook) {
      g_hook_destroy_link(hook_list, hook);
   }
   // Unintrospectable function: find() / g_hook_find()
   static Hook* find(HookList* hook_list, int need_valids, HookFindFunc func, void* data) {
      return g_hook_find(hook_list, need_valids, func, data);
   }
   // Unintrospectable function: find_data() / g_hook_find_data()
   static Hook* find_data(HookList* hook_list, int need_valids, void* data) {
      return g_hook_find_data(hook_list, need_valids, data);
   }
   // Unintrospectable function: find_func() / g_hook_find_func()
   static Hook* find_func(HookList* hook_list, int need_valids, void* func) {
      return g_hook_find_func(hook_list, need_valids, func);
   }
   // Unintrospectable function: find_func_data() / g_hook_find_func_data()
   static Hook* find_func_data(HookList* hook_list, int need_valids, void* func, void* data) {
      return g_hook_find_func_data(hook_list, need_valids, func, data);
   }
   // Unintrospectable function: first_valid() / g_hook_first_valid()
   static Hook* first_valid(HookList* hook_list, int may_be_in_call) {
      return g_hook_first_valid(hook_list, may_be_in_call);
   }
   static void free(HookList* hook_list, Hook* hook) {
      g_hook_free(hook_list, hook);
   }
   // Unintrospectable function: get() / g_hook_get()
   static Hook* get(HookList* hook_list, c_ulong hook_id) {
      return g_hook_get(hook_list, hook_id);
   }
   static void insert_before(HookList* hook_list, Hook* sibling, Hook* hook) {
      g_hook_insert_before(hook_list, sibling, hook);
   }
   // Unintrospectable function: insert_sorted() / g_hook_insert_sorted()
   static void insert_sorted(HookList* hook_list, Hook* hook, HookCompareFunc func) {
      g_hook_insert_sorted(hook_list, hook, func);
   }
   // Unintrospectable function: next_valid() / g_hook_next_valid()
   static Hook* next_valid(HookList* hook_list, Hook* hook, int may_be_in_call) {
      return g_hook_next_valid(hook_list, hook, may_be_in_call);
   }
   static void prepend(HookList* hook_list, Hook* hook) {
      g_hook_prepend(hook_list, hook);
   }
   // Unintrospectable function: ref() / g_hook_ref()
   static Hook* ref_(HookList* hook_list, Hook* hook) {
      return g_hook_ref(hook_list, hook);
   }
   static void unref(HookList* hook_list, Hook* hook) {
      g_hook_unref(hook_list, hook);
   }
}

extern (C) alias int function (void* data) HookCheckFunc;

extern (C) alias int function (Hook* hook, void* marshal_data) HookCheckMarshaller;

extern (C) alias int function (Hook* new_hook, Hook* sibling) HookCompareFunc;

extern (C) alias void function (HookList* hook_list, Hook* hook) HookFinalizeFunc;

extern (C) alias int function (Hook* hook, void* data) HookFindFunc;

enum HookFlagMask {
   ACTIVE = 1,
   IN_CALL = 2,
   MASK = 15
}
extern (C) alias void function (void* data) HookFunc;

struct HookList {
   c_ulong seq_id;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "hook_size", 16,
   uint, "is_setup", 1,
    uint, "__dummy32A", 15));
   Hook* hooks;
   void* dummy3;
   HookFinalizeFunc finalize_hook;
   void*[2] dummy;

   void clear() {
      g_hook_list_clear(&this);
   }
   void init(uint hook_size) {
      g_hook_list_init(&this, hook_size);
   }
   void invoke(int may_recurse) {
      g_hook_list_invoke(&this, may_recurse);
   }
   void invoke_check(int may_recurse) {
      g_hook_list_invoke_check(&this, may_recurse);
   }
   // Unintrospectable method: marshal() / g_hook_list_marshal()
   void marshal(int may_recurse, HookMarshaller marshaller, void* marshal_data) {
      g_hook_list_marshal(&this, may_recurse, marshaller, marshal_data);
   }
   // Unintrospectable method: marshal_check() / g_hook_list_marshal_check()
   void marshal_check(int may_recurse, HookCheckMarshaller marshaller, void* marshal_data) {
      g_hook_list_marshal_check(&this, may_recurse, marshaller, marshal_data);
   }
}

extern (C) alias void function (Hook* hook, void* marshal_data) HookMarshaller;

struct IConv {

   // 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.
   // RETURNS: count of non-reversible conversions, or -1 on error
   // <inbuf>: bytes to convert
   // <inbytes_left>: inout parameter, bytes remaining to convert in @inbuf
   // <outbuf>: converted output bytes
   // <outbytes_left>: inout parameter, bytes available to fill in @outbuf
   size_t /*NAME MISSING IN GIR*/ iconv(char** inbuf, size_t* inbytes_left, char** outbuf, size_t* outbytes_left) {
      return g_iconv(&this, inbuf, inbytes_left, outbuf, outbytes_left);
   }

   // Same as the standard UNIX routine iconv_close(), but
   // may be implemented via libiconv on UNIX flavors that lack
   // a native implementation. Should be called to clean up
   // the conversion descriptor from g_iconv_open() when
   // you are done converting things.
   // 
   // GLib provides g_convert() and g_locale_to_utf8() which are likely
   // more convenient than the raw iconv wrappers.
   // RETURNS: -1 on error, 0 on success
   int close() {
      return g_iconv_close(&this);
   }

   // Unintrospectable function: open() / g_iconv_open()
   // 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.
   // 
   // opening the converter failed.
   // RETURNS: a "conversion descriptor", or (GIConv)-1 if
   // <to_codeset>: destination codeset
   // <from_codeset>: source codeset
   static IConv open(char* to_codeset, char* from_codeset) {
      return g_iconv_open(to_codeset, from_codeset);
   }
}

enum int IEEE754_DOUBLE_BIAS = 1023;
enum int IEEE754_FLOAT_BIAS = 127;

// A data structure representing an IO Channel. The fields should be
// considered private and should only be accessed with the following
// functions.
struct IOChannel {
   private int ref_count;
   private IOFuncs* funcs;
   private char* encoding;
   private IConv read_cd, write_cd;
   private char* line_term;
   private uint line_term_len;
   private size_t buf_size;
   private String* read_buf, encoded_read_buf, write_buf;
   private char[6] partial_write_buf;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "use_buffer", 1,
   uint, "do_encode", 1,
   uint, "close_on_unref", 1,
   uint, "is_readable", 1,
   uint, "is_writeable", 1,
   uint, "is_seekable", 1,
    uint, "__dummy32A", 26));
   private void* reserved1, reserved2;


   // Open a file @filename as a #GIOChannel using mode @mode. This
   // channel will be closed when the last reference to it is dropped,
   // so there is no need to call g_io_channel_close() (though doing
   // so will not cause problems, as long as no attempt is made to
   // access the channel after it is closed).
   // RETURNS: A #GIOChannel on success, %NULL on failure.
   // <filename>: A string containing the name of a file
   // <mode>: One of "r", "w", "a", "r+", "w+", "a+". These have the same meaning as in fopen()
   static IOChannel* /*new*/ new_file(char* filename, char* mode, GLib2.Error** error=null) {
      return g_io_channel_new_file(filename, mode, error);
   }

   // Creates a new #GIOChannel given a file descriptor. On UNIX systems
   // this works for plain files, pipes, and sockets.
   // 
   // The returned #GIOChannel has a reference count of 1.
   // 
   // The default encoding for #GIOChannel is UTF-8. If your application
   // is reading output from a command using via pipe, you may need to set
   // the encoding to the encoding of the current locale (see
   // g_get_charset()) with the g_io_channel_set_encoding() function.
   // 
   // If you want to read raw binary data without interpretation, then
   // call the g_io_channel_set_encoding() function with %NULL for the
   // encoding argument.
   // 
   // This function is available in GLib on Windows, too, but you should
   // avoid using it on Windows. The domain of file descriptors and
   // sockets overlap. There is no way for GLib to know which one you mean
   // in case the argument you pass to this function happens to be both a
   // valid file descriptor and socket. If that happens a warning is
   // issued, and GLib assumes that it is the file descriptor you mean.
   // <fd>: a file descriptor.
   static IOChannel* /*new*/ unix_new(int fd) {
      return g_io_channel_unix_new(fd);
   }

   // Close an IO channel. Any pending data to be written will be
   // flushed, ignoring errors. The channel will not be freed until the
   // last reference is dropped using g_io_channel_unref().
   // 
   // Deprecated:2.2: Use g_io_channel_shutdown() instead.
   void close() {
      g_io_channel_close(&this);
   }

   // Flushes the write buffer for the GIOChannel.
   // 
   // #G_IO_STATUS_NORMAL, #G_IO_STATUS_AGAIN, or
   // #G_IO_STATUS_ERROR.
   // RETURNS: the status of the operation: One of
   IOStatus flush(GLib2.Error** error=null) {
      return g_io_channel_flush(&this, error);
   }

   // This function returns a #GIOCondition depending on whether there
   // is data to be read/space to write data in the internal buffers in
   // the #GIOChannel. Only the flags %G_IO_IN and %G_IO_OUT may be set.
   // RETURNS: A #GIOCondition
   IOCondition get_buffer_condition() {
      return g_io_channel_get_buffer_condition(&this);
   }

   // Gets the buffer size.
   // RETURNS: the size of the buffer.
   size_t get_buffer_size() {
      return g_io_channel_get_buffer_size(&this);
   }

   // Returns whether @channel is buffered.
   // RETURNS: %TRUE if the @channel is buffered.
   int get_buffered() {
      return g_io_channel_get_buffered(&this);
   }

   // Returns whether the file/socket/whatever associated with @channel
   // will be closed when @channel receives its final unref and is
   // destroyed. The default value of this is %TRUE for channels created
   // by g_io_channel_new_file (), and %FALSE for all other channels.
   // 
   // the GIOChannel data structure.
   // RETURNS: Whether the channel will be closed on the final unref of
   int get_close_on_unref() {
      return g_io_channel_get_close_on_unref(&this);
   }

   // Gets the encoding for the input/output of the channel.
   // The internal encoding is always UTF-8. The encoding %NULL
   // makes the channel safe for binary data.
   // 
   // owned by GLib and must not be freed.
   // RETURNS: A string containing the encoding, this string is
   char* get_encoding() {
      return g_io_channel_get_encoding(&this);
   }

   // Gets the current flags for a #GIOChannel, including read-only
   // flags such as %G_IO_FLAG_IS_READABLE.
   // 
   // The values of the flags %G_IO_FLAG_IS_READABLE and %G_IO_FLAG_IS_WRITEABLE
   // are cached for internal use by the channel when it is created.
   // If they should change at some later point (e.g. partial shutdown
   // of a socket with the UNIX shutdown() function), the user
   // should immediately call g_io_channel_get_flags() to update
   // the internal values of these flags.
   // RETURNS: the flags which are set on the channel
   IOFlags get_flags() {
      return g_io_channel_get_flags(&this);
   }

   // This returns the string that #GIOChannel uses to determine
   // where in the file a line break occurs. A value of %NULL
   // indicates autodetection.
   // 
   // is owned by GLib and must not be freed.
   // RETURNS: The line termination string. This value
   // <length>: a location to return the length of the line terminator
   char* get_line_term(int* length) {
      return g_io_channel_get_line_term(&this, length);
   }

   // Initializes a #GIOChannel struct.
   // 
   // This is called by each of the above functions when creating a
   // #GIOChannel, and so is not often needed by the application
   // programmer (unless you are creating a new type of #GIOChannel).
   void init() {
      g_io_channel_init(&this);
   }

   // Reads data from a #GIOChannel.
   // 
   // 
   // Deprecated:2.2: Use g_io_channel_read_chars() instead.
   // RETURNS: %G_IO_ERROR_NONE if the operation was successful.
   // <buf>: a buffer to read the data into (which should be at least count bytes long)
   // <count>: the number of bytes to read from the #GIOChannel
   // <bytes_read>: returns the number of bytes actually read
   IOError read(char* buf, size_t count, size_t* bytes_read) {
      return g_io_channel_read(&this, buf, count, bytes_read);
   }

   // Replacement for g_io_channel_read() with the new API.
   // RETURNS: the status of the operation.
   // <buf>: a buffer to read data into
   // <count>: the size of the buffer. Note that the buffer may not be complelely filled even if there is data in the buffer if the remaining data is not a complete character.
   // <bytes_read>: The number of bytes read. This may be zero even on success if count < 6 and the channel's encoding is non-%NULL. This indicates that the next UTF-8 character is too wide for the buffer.
   IOStatus read_chars(char* buf, size_t count, size_t* bytes_read, GLib2.Error** error=null) {
      return g_io_channel_read_chars(&this, buf, count, bytes_read, error);
   }

   // Reads a line, including the terminating character(s),
   // from a #GIOChannel into a newly-allocated string.
   // @str_return will contain allocated memory if the return
   // is %G_IO_STATUS_NORMAL.
   // RETURNS: the status of the operation.
   // <str_return>: The line read from the #GIOChannel, including the line terminator. This data should be freed with g_free() when no longer needed. This is a nul-terminated string. If a @length of zero is returned, this will be %NULL instead.
   // <length>: location to store length of the read data, or %NULL
   // <terminator_pos>: location to store position of line terminator, or %NULL
   IOStatus read_line(char** str_return, size_t* length, size_t* terminator_pos, GLib2.Error** error=null) {
      return g_io_channel_read_line(&this, str_return, length, terminator_pos, error);
   }

   // Reads a line from a #GIOChannel, using a #GString as a buffer.
   // RETURNS: the status of the operation.
   // <buffer>: a #GString into which the line will be written. If @buffer already contains data, the old data will be overwritten.
   // <terminator_pos>: location to store position of line terminator, or %NULL
   IOStatus read_line_string(String* buffer, size_t* terminator_pos, GLib2.Error** error=null) {
      return g_io_channel_read_line_string(&this, buffer, terminator_pos, error);
   }

   // Reads all the remaining data from the file.
   // 
   // This function never returns %G_IO_STATUS_EOF.
   // RETURNS: %G_IO_STATUS_NORMAL on success.
   // <str_return>: Location to store a pointer to a string holding the remaining data in the #GIOChannel. This data should be freed with g_free() when no longer needed. This data is terminated by an extra nul character, but there may be other nuls in the intervening data.
   // <length>: location to store length of the data
   IOStatus read_to_end(char** str_return, size_t* length, GLib2.Error** error=null) {
      return g_io_channel_read_to_end(&this, str_return, length, error);
   }

   // Reads a Unicode character from @channel.
   // This function cannot be called on a channel with %NULL encoding.
   // RETURNS: a #GIOStatus
   // <thechar>: a location to return a character
   IOStatus read_unichar(dchar* thechar, GLib2.Error** error=null) {
      return g_io_channel_read_unichar(&this, thechar, error);
   }

   // Increments the reference count of a #GIOChannel.
   // RETURNS: the @channel that was passed in (since 2.6)
   IOChannel* /*new*/ ref_() {
      return g_io_channel_ref(&this);
   }

   // Sets the current position in the #GIOChannel, similar to the standard
   // library function fseek().
   // 
   // 
   // Deprecated:2.2: Use g_io_channel_seek_position() instead.
   // RETURNS: %G_IO_ERROR_NONE if the operation was successful.
   // <offset>: an offset, in bytes, which is added to the position specified by @type
   // <type>: the position in the file, which can be %G_SEEK_CUR (the current position), %G_SEEK_SET (the start of the file), or %G_SEEK_END (the end of the file)
   IOError seek(long offset, SeekType type) {
      return g_io_channel_seek(&this, offset, type);
   }

   // Replacement for g_io_channel_seek() with the new API.
   // RETURNS: the status of the operation.
   // <offset>: The offset in bytes from the position specified by @type
   // <type>: a #GSeekType. The type %G_SEEK_CUR is only allowed in those cases where a call to g_io_channel_set_encoding () is allowed. See the documentation for g_io_channel_set_encoding () for details.
   IOStatus seek_position(long offset, SeekType type, GLib2.Error** error=null) {
      return g_io_channel_seek_position(&this, offset, type, error);
   }

   // Sets the buffer size.
   // <size>: the size of the buffer, or 0 to let GLib pick a good size
   void set_buffer_size(size_t size) {
      g_io_channel_set_buffer_size(&this, size);
   }

   // The buffering state can only be set if the channel's encoding
   // is %NULL. For any other encoding, the channel must be buffered.
   // 
   // A buffered channel can only be set unbuffered if the channel's
   // internal buffers have been flushed. Newly created channels or
   // channels which have returned %G_IO_STATUS_EOF
   // not require such a flush. For write-only channels, a call to
   // g_io_channel_flush () is sufficient. For all other channels,
   // the buffers may be flushed by a call to g_io_channel_seek_position ().
   // This includes the possibility of seeking with seek type %G_SEEK_CUR
   // and an offset of zero. Note that this means that socket-based
   // channels cannot be set unbuffered once they have had data
   // read from them.
   // 
   // On unbuffered channels, it is safe to mix read and write
   // calls from the new and old APIs, if this is necessary for
   // maintaining old code.
   // 
   // The default state of the channel is buffered.
   // <buffered>: whether to set the channel buffered or unbuffered
   void set_buffered(int buffered) {
      g_io_channel_set_buffered(&this, buffered);
   }

   // Setting this flag to %TRUE for a channel you have already closed
   // can cause problems.
   // <do_close>: Whether to close the channel on the final unref of the GIOChannel data structure. The default value of this is %TRUE for channels created by g_io_channel_new_file (), and %FALSE for all other channels.
   void set_close_on_unref(int do_close) {
      g_io_channel_set_close_on_unref(&this, do_close);
   }

   // Sets the encoding for the input/output of the channel.
   // The internal encoding is always UTF-8. The default encoding
   // for the external file is UTF-8.
   // 
   // The encoding %NULL is safe to use with binary data.
   // 
   // The encoding can only be set if one of the following conditions
   // is true:
   // <itemizedlist>
   // <listitem><para>
   // The channel was just created, and has not been written to or read
   // from yet.
   // </para></listitem>
   // <listitem><para>
   // The channel is write-only.
   // </para></listitem>
   // <listitem><para>
   // The channel is a file, and the file pointer was just
   // repositioned by a call to g_io_channel_seek_position().
   // (This flushes all the internal buffers.)
   // </para></listitem>
   // <listitem><para>
   // The current encoding is %NULL or UTF-8.
   // </para></listitem>
   // <listitem><para>
   // One of the (new API) read functions has just returned %G_IO_STATUS_EOF
   // (or, in the case of g_io_channel_read_to_end(), %G_IO_STATUS_NORMAL).
   // </para></listitem>
   // <listitem><para>
   // One of the functions g_io_channel_read_chars() or
   // g_io_channel_read_unichar() has returned %G_IO_STATUS_AGAIN or
   // %G_IO_STATUS_ERROR. This may be useful in the case of
   // %G_CONVERT_ERROR_ILLEGAL_SEQUENCE.
   // Returning one of these statuses from g_io_channel_read_line(),
   // g_io_channel_read_line_string(), or g_io_channel_read_to_end()
   // does <emphasis>not</emphasis> guarantee that the encoding can
   // be changed.
   // </para></listitem>
   // </itemizedlist>
   // Channels which do not meet one of the above conditions cannot call
   // g_io_channel_seek_position() with an offset of %G_SEEK_CUR, and, if
   // they are "seekable", cannot call g_io_channel_write_chars() after
   // calling one of the API "read" functions.
   // RETURNS: %G_IO_STATUS_NORMAL if the encoding was successfully set.
   // <encoding>: the encoding type
   IOStatus set_encoding(char* encoding, GLib2.Error** error=null) {
      return g_io_channel_set_encoding(&this, encoding, error);
   }

   // Sets the (writeable) flags in @channel to (@flags & %G_IO_CHANNEL_SET_MASK).
   // RETURNS: the status of the operation.
   // <flags>: the flags to set on the IO channel
   IOStatus set_flags(IOFlags flags, GLib2.Error** error=null) {
      return g_io_channel_set_flags(&this, flags, error);
   }

   // This sets the string that #GIOChannel uses to determine
   // where in the file a line break occurs.
   // <line_term>: The line termination string. Use %NULL for autodetect. Autodetection breaks on "\n", "\r\n", "\r", "\0", and the Unicode paragraph separator. Autodetection should not be used for anything other than file-based channels.
   // <length>: The length of the termination string. If -1 is passed, the string is assumed to be nul-terminated. This option allows termination strings with embedded nuls.
   void set_line_term(char* line_term, int length) {
      g_io_channel_set_line_term(&this, line_term, length);
   }

   // Close an IO channel. Any pending data to be written will be
   // flushed if @flush is %TRUE. The channel will not be freed until the
   // last reference is dropped using g_io_channel_unref().
   // RETURNS: the status of the operation.
   // <flush>: if %TRUE, flush pending
   IOStatus shutdown(int flush, GLib2.Error** error=null) {
      return g_io_channel_shutdown(&this, flush, error);
   }

   // Returns the file descriptor of the #GIOChannel.
   // 
   // On Windows this function returns the file descriptor or socket of
   // the #GIOChannel.
   int unix_get_fd() {
      return g_io_channel_unix_get_fd(&this);
   }
   // Decrements the reference count of a #GIOChannel.
   void unref() {
      g_io_channel_unref(&this);
   }

   // Writes data to a #GIOChannel.
   // 
   // 
   // Deprecated:2.2: Use g_io_channel_write_chars() instead.
   // RETURNS: %G_IO_ERROR_NONE if the operation was successful.
   // <buf>: the buffer containing the data to write
   // <count>: the number of bytes to write
   // <bytes_written>: the number of bytes actually written
   IOError write(char* buf, size_t count, size_t* bytes_written) {
      return g_io_channel_write(&this, buf, count, bytes_written);
   }

   // Replacement for g_io_channel_write() with the new API.
   // 
   // On seekable channels with encodings other than %NULL or UTF-8, generic
   // mixing of reading and writing is not allowed. A call to g_io_channel_write_chars ()
   // may only be made on a channel from which data has been read in the
   // cases described in the documentation for g_io_channel_set_encoding ().
   // RETURNS: the status of the operation.
   // <buf>: a buffer to write data from
   // <count>: the size of the buffer. If -1, the buffer is taken to be a nul-terminated string.
   // <bytes_written>: The number of bytes written. This can be nonzero even if the return value is not %G_IO_STATUS_NORMAL. If the return value is %G_IO_STATUS_NORMAL and the channel is blocking, this will always be equal to @count if @count >= 0.
   IOStatus write_chars(char* buf, ssize_t count, size_t* bytes_written, GLib2.Error** error=null) {
      return g_io_channel_write_chars(&this, buf, count, bytes_written, error);
   }

   // Writes a Unicode character to @channel.
   // This function cannot be called on a channel with %NULL encoding.
   // RETURNS: a #GIOStatus
   // <thechar>: a character
   IOStatus write_unichar(dchar thechar, GLib2.Error** error=null) {
      return g_io_channel_write_unichar(&this, thechar, error);
   }

   // Converts an <literal>errno</literal> error number to a #GIOChannelError.
   // 
   // %G_IO_CHANNEL_ERROR_INVAL.
   // RETURNS: a #GIOChannelError error number, e.g.
   // <en>: an <literal>errno</literal> error number, e.g. %EINVAL
   static IOChannelError error_from_errno(int en) {
      return g_io_channel_error_from_errno(en);
   }
   // RETURNS: the quark used as %G_IO_CHANNEL_ERROR
   static Quark error_quark() {
      return g_io_channel_error_quark();
   }
}

// Error codes returned by #GIOChannel operations.
enum IOChannelError {
   FBIG = 0,
   INVAL = 1,
   IO = 2,
   ISDIR = 3,
   NOSPC = 4,
   NXIO = 5,
   OVERFLOW = 6,
   PIPE = 7,
   FAILED = 8
}

// A bitwise combination representing a condition to watch for on an
// event source.
enum IOCondition {
   IN = 1,
   OUT = 4,
   PRI = 2,
   ERR = 8,
   HUP = 16,
   NVAL = 32
}

// #GIOError is only used by the deprecated functions
// g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek().
enum IOError {
   NONE = 0,
   AGAIN = 1,
   INVAL = 2,
   UNKNOWN = 3
}

// Specifies properties of a #GIOChannel. Some of the flags can only be
// read with g_io_channel_get_flags(), but not changed with
// g_io_channel_set_flags().
enum IOFlags {
   APPEND = 1,
   NONBLOCK = 2,
   IS_READABLE = 4,
   IS_WRITEABLE = 8,
   IS_SEEKABLE = 16,
   MASK = 31,
   GET_MASK = 31,
   SET_MASK = 3
}

// 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.
// <source>: the #GIOChannel event source
// <condition>: the condition which has been satisfied
// <data>: user data set in g_io_add_watch() or g_io_add_watch_full()
extern (C) alias int function (IOChannel* source, IOCondition condition, void* data) IOFunc;


// A table of functions used to handle different types of #GIOChannel
// in a generic way.
struct IOFuncs {
   extern (C) IOStatus function (IOChannel* channel, char* buf, size_t count, size_t* bytes_read, GLib2.Error** error=null) io_read;
   extern (C) IOStatus function (IOChannel* channel, char* buf, size_t count, size_t* bytes_written, GLib2.Error** error=null) io_write;
   extern (C) IOStatus function (IOChannel* channel, long offset, SeekType type, GLib2.Error** error=null) io_seek;
   extern (C) IOStatus function (IOChannel* channel, GLib2.Error** error=null) io_close;
   extern (C) Source* /*new*/ function (IOChannel* channel, IOCondition condition) io_create_watch;
   extern (C) void function (IOChannel* channel) io_free;
   extern (C) IOStatus function (IOChannel* channel, IOFlags flags, GLib2.Error** error=null) io_set_flags;
   extern (C) IOFlags function (IOChannel* channel) io_get_flags;
}

// Stati returned by most of the #GIOFuncs functions.
enum IOStatus {
   ERROR = 0,
   NORMAL = 1,
   EOF = 2,
   AGAIN = 3
}
enum KEY_FILE_DESKTOP_GROUP = "Desktop Entry";
enum KEY_FILE_DESKTOP_KEY_CATEGORIES = "Categories";
enum KEY_FILE_DESKTOP_KEY_COMMENT = "Comment";
enum KEY_FILE_DESKTOP_KEY_EXEC = "Exec";
enum KEY_FILE_DESKTOP_KEY_GENERIC_NAME = "GenericName";
enum KEY_FILE_DESKTOP_KEY_HIDDEN = "Hidden";
enum KEY_FILE_DESKTOP_KEY_ICON = "Icon";
enum KEY_FILE_DESKTOP_KEY_MIME_TYPE = "MimeType";
enum KEY_FILE_DESKTOP_KEY_NAME = "Name";
enum KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN = "NotShowIn";
enum KEY_FILE_DESKTOP_KEY_NO_DISPLAY = "NoDisplay";
enum KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN = "OnlyShowIn";
enum KEY_FILE_DESKTOP_KEY_PATH = "Path";
enum KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY = "StartupNotify";
enum KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS = "StartupWMClass";
enum KEY_FILE_DESKTOP_KEY_TERMINAL = "Terminal";
enum KEY_FILE_DESKTOP_KEY_TRY_EXEC = "TryExec";
enum KEY_FILE_DESKTOP_KEY_TYPE = "Type";
enum KEY_FILE_DESKTOP_KEY_URL = "URL";
enum KEY_FILE_DESKTOP_KEY_VERSION = "Version";
enum KEY_FILE_DESKTOP_TYPE_APPLICATION = "Application";
enum KEY_FILE_DESKTOP_TYPE_DIRECTORY = "Directory";
enum KEY_FILE_DESKTOP_TYPE_LINK = "Link";
struct KeyFile {
   // Frees a #GKeyFile.
   void free() {
      g_key_file_free(&this);
   }

   // Returns the value associated with @key under @group_name as a
   // boolean.
   // 
   // If @key cannot be found then %FALSE is returned and @error is set
   // to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value
   // associated with @key cannot be interpreted as a boolean then %FALSE
   // is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.
   // 
   // or %FALSE if the key was not found or could not be parsed.
   // RETURNS: the value associated with the key as a boolean,
   // <group_name>: a group name
   // <key>: a key
   int get_boolean(char* group_name, char* key, GLib2.Error** error=null) {
      return g_key_file_get_boolean(&this, group_name, key, error);
   }

   // Returns the values associated with @key under @group_name as
   // booleans.
   // 
   // If @key cannot be found then %NULL is returned and @error is set to
   // #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
   // with @key cannot be interpreted as booleans then %NULL is returned
   // and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.
   // 
   // the values associated with the key as a list of booleans, or %NULL if the
   // key was not found or could not be parsed. The returned list of booleans
   // should be freed with g_free() when no longer needed.
   // <group_name>: a group name
   // <key>: a key
   // <length>: the number of booleans returned
   int* /*new container*/ get_boolean_list(char* group_name, char* key, /*out*/ size_t* length, GLib2.Error** error=null) {
      return g_key_file_get_boolean_list(&this, group_name, key, length, error);
   }

   // Retrieves a comment above @key from @group_name.
   // If @key is %NULL then @comment will be read from above
   // @group_name. If both @key and @group_name are %NULL, then
   // @comment will be read from above the first group in the file.
   // RETURNS: a comment that should be freed with g_free()
   // <group_name>: a group name, or %NULL
   // <key>: a key
   char* /*new*/ get_comment(char* group_name, char* key, GLib2.Error** error=null) {
      return g_key_file_get_comment(&this, group_name, key, error);
   }

   // Returns the value associated with @key under @group_name as a
   // double. If @group_name is %NULL, the start_group is used.
   // 
   // If @key cannot be found then 0.0 is returned and @error is set to
   // #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated
   // with @key cannot be interpreted as a double then 0.0 is returned
   // and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.
   // 
   // 0.0 if the key was not found or could not be parsed.
   // RETURNS: the value associated with the key as a double, or
   // <group_name>: a group name
   // <key>: a key
   double get_double(char* group_name, char* key, GLib2.Error** error=null) {
      return g_key_file_get_double(&this, group_name, key, error);
   }

   // Returns the values associated with @key under @group_name as
   // doubles.
   // 
   // If @key cannot be found then %NULL is returned and @error is set to
   // #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
   // with @key cannot be interpreted as doubles then %NULL is returned
   // and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.
   // 
   // the values associated with the key as a list of doubles, or %NULL if the
   // key was not found or could not be parsed. The returned list of doubles
   // should be freed with g_free() when no longer needed.
   // <group_name>: a group name
   // <key>: a key
   // <length>: the number of doubles returned
   double* /*new container*/ get_double_list(char* group_name, char* key, /*out*/ size_t* length, GLib2.Error** error=null) {
      return g_key_file_get_double_list(&this, group_name, key, length, error);
   }

   // Unintrospectable method: get_groups() / g_key_file_get_groups()
   // Returns all groups in the key file loaded with @key_file.
   // The array of returned groups will be %NULL-terminated, so
   // @length may optionally be %NULL.
   // 
   // Use g_strfreev() to free it.
   // RETURNS: a newly-allocated %NULL-terminated array of strings.
   // <length>: return location for the number of returned groups, or %NULL
   char** get_groups(size_t* length) {
      return g_key_file_get_groups(&this, length);
   }

   // Returns the value associated with @key under @group_name as a signed
   // 64-bit integer. This is similar to g_key_file_get_integer() but can return
   // 64-bit results without truncation.
   // 
   // 0 if the key was not found or could not be parsed.
   // RETURNS: the value associated with the key as a signed 64-bit integer, or
   // <group_name>: a non-%NULL group name
   // <key>: a non-%NULL key
   long get_int64(char* group_name, char* key, GLib2.Error** error=null) {
      return g_key_file_get_int64(&this, group_name, key, error);
   }

   // Returns the value associated with @key under @group_name as an
   // integer.
   // 
   // If @key cannot be found then 0 is returned and @error is set to
   // #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated
   // with @key cannot be interpreted as an integer then 0 is returned
   // and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.
   // 
   // 0 if the key was not found or could not be parsed.
   // RETURNS: the value associated with the key as an integer, or
   // <group_name>: a group name
   // <key>: a key
   int get_integer(char* group_name, char* key, GLib2.Error** error=null) {
      return g_key_file_get_integer(&this, group_name, key, error);
   }

   // Returns the values associated with @key under @group_name as
   // integers.
   // 
   // If @key cannot be found then %NULL is returned and @error is set to
   // #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
   // with @key cannot be interpreted as integers then %NULL is returned
   // and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.
   // 
   // the values associated with the key as a list of integers, or %NULL if
   // the key was not found or could not be parsed. The returned list of
   // integers should be freed with g_free() when no longer needed.
   // <group_name>: a group name
   // <key>: a key
   // <length>: the number of integers returned
   int* /*new container*/ get_integer_list(char* group_name, char* key, /*out*/ size_t* length, GLib2.Error** error=null) {
      return g_key_file_get_integer_list(&this, group_name, key, length, error);
   }

   // Unintrospectable method: get_keys() / g_key_file_get_keys()
   // Returns all keys for the group name @group_name.  The array of
   // returned keys will be %NULL-terminated, so @length may
   // optionally be %NULL. In the event that the @group_name cannot
   // be found, %NULL is returned and @error is set to
   // #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
   // 
   // Use g_strfreev() to free it.
   // RETURNS: a newly-allocated %NULL-terminated array of strings.
   // <group_name>: a group name
   // <length>: return location for the number of keys returned, or %NULL
   char** get_keys(char* group_name, size_t* length, GLib2.Error** error=null) {
      return g_key_file_get_keys(&this, group_name, length, error);
   }

   // Returns the value associated with @key under @group_name
   // translated in the given @locale if available.  If @locale is
   // %NULL then the current locale is assumed.
   // 
   // If @key cannot be found then %NULL is returned and @error is set
   // to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the value associated
   // with @key cannot be interpreted or no suitable translation can
   // be found then the untranslated value is returned.
   // 
   // key cannot be found.
   // RETURNS: a newly allocated string or %NULL if the specified
   // <group_name>: a group name
   // <key>: a key
   // <locale>: a locale identifier or %NULL
   char* /*new*/ get_locale_string(char* group_name, char* key, char* locale, GLib2.Error** error=null) {
      return g_key_file_get_locale_string(&this, group_name, key, locale, error);
   }

   // Returns the values associated with @key under @group_name
   // translated in the given @locale if available.  If @locale is
   // %NULL then the current locale is assumed.
   // If @key cannot be found then %NULL is returned and @error is set
   // to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the values associated
   // with @key cannot be interpreted or no suitable translations
   // can be found then the untranslated values are returned. The
   // returned array is %NULL-terminated, so @length may optionally
   // be %NULL.
   // 
   // or %NULL if the key isn't found. The string array should be freed
   // with g_strfreev().
   // RETURNS: a newly allocated %NULL-terminated string array
   // <group_name>: a group name
   // <key>: a key
   // <locale>: a locale identifier or %NULL
   // <length>: return location for the number of returned strings or %NULL
   char** /*new*/ get_locale_string_list(char* group_name, char* key, char* locale, /*out*/ size_t* length, GLib2.Error** error=null) {
      return g_key_file_get_locale_string_list(&this, group_name, key, locale, length, error);
   }

   // Returns the name of the start group of the file.
   // RETURNS: The start group of the key file.
   char* /*new*/ get_start_group() {
      return g_key_file_get_start_group(&this);
   }

   // Returns the string value associated with @key under @group_name.
   // Unlike g_key_file_get_value(), this function handles escape sequences
   // like \s.
   // 
   // In the event the key cannot be found, %NULL is returned and
   // @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the
   // event that the @group_name cannot be found, %NULL is returned
   // and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
   // 
   // key cannot be found.
   // RETURNS: a newly allocated string or %NULL if the specified
   // <group_name>: a group name
   // <key>: a key
   char* /*new*/ get_string(char* group_name, char* key, GLib2.Error** error=null) {
      return g_key_file_get_string(&this, group_name, key, error);
   }

   // Returns the values associated with @key under @group_name.
   // 
   // In the event the key cannot be found, %NULL is returned and
   // @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the
   // event that the @group_name cannot be found, %NULL is returned
   // and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
   // 
   // a %NULL-terminated string array or %NULL if the specified
   // key cannot be found. The array should be freed with g_strfreev().
   // <group_name>: a group name
   // <key>: a key
   // <length>: return location for the number of returned strings, or %NULL
   char** /*new*/ get_string_list(char* group_name, char* key, /*out*/ size_t* length, GLib2.Error** error=null) {
      return g_key_file_get_string_list(&this, group_name, key, length, error);
   }

   // Returns the value associated with @key under @group_name as an unsigned
   // 64-bit integer. This is similar to g_key_file_get_integer() but can return
   // large positive results without truncation.
   // 
   // or 0 if the key was not found or could not be parsed.
   // RETURNS: the value associated with the key as an unsigned 64-bit integer,
   // <group_name>: a non-%NULL group name
   // <key>: a non-%NULL key
   ulong get_uint64(char* group_name, char* key, GLib2.Error** error=null) {
      return g_key_file_get_uint64(&this, group_name, key, error);
   }

   // Returns the raw value associated with @key under @group_name.
   // Use g_key_file_get_string() to retrieve an unescaped UTF-8 string.
   // 
   // In the event the key cannot be found, %NULL is returned and
   // @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the
   // event that the @group_name cannot be found, %NULL is returned
   // and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
   // 
   // 
   // key cannot be found.
   // RETURNS: a newly allocated string or %NULL if the specified
   // <group_name>: a group name
   // <key>: a key
   char* /*new*/ get_value(char* group_name, char* key, GLib2.Error** error=null) {
      return g_key_file_get_value(&this, group_name, key, error);
   }

   // Looks whether the key file has the group @group_name.
   // 
   // otherwise.
   // RETURNS: %TRUE if @group_name is a part of @key_file, %FALSE
   // <group_name>: a group name
   int has_group(char* group_name) {
      return g_key_file_has_group(&this, group_name);
   }

   // Unintrospectable method: has_key() / g_key_file_has_key()
   // Looks whether the key file has the key @key in the group
   // @group_name.
   // 
   // <note>This function does not follow the rules for #GError strictly;
   // the return value both carries meaning and signals an error.  To use
   // this function, you must pass a #GError pointer in @error, and check
   // whether it is not %NULL to see if an error occurred.</note>
   // 
   // Language bindings should use g_key_file_get_value() to test whether
   // or not a key exists.
   // 
   // otherwise.
   // RETURNS: %TRUE if @key is a part of @group_name, %FALSE
   // <group_name>: a group name
   // <key>: a key name
   int has_key(char* group_name, char* key, GLib2.Error** error=null) {
      return g_key_file_has_key(&this, group_name, key, error);
   }

   // Loads a key file from memory into an empty #GKeyFile structure.
   // If the object cannot be created then %error is set to a #GKeyFileError.
   // RETURNS: %TRUE if a key file could be loaded, %FALSE otherwise
   // <data>: key file loaded in memory
   // <length>: the length of @data in bytes
   // <flags>: flags from #GKeyFileFlags
   int load_from_data(char* data, size_t length, KeyFileFlags flags, GLib2.Error** error=null) {
      return g_key_file_load_from_data(&this, data, length, flags, error);
   }

   // This function looks for a key file named @file in the paths
   // returned from g_get_user_data_dir() and g_get_system_data_dirs(),
   // loads the file into @key_file and returns the file's full path in
   // @full_path.  If the file could not be loaded then an %error is
   // set to either a #GFileError or #GKeyFileError.
   // RETURNS: %TRUE if a key file could be loaded, %FALSE othewise
   // <file>: a relative path to a filename to open and parse
   // <full_path>: return location for a string containing the full path of the file, or %NULL
   // <flags>: flags from #GKeyFileFlags
   int load_from_data_dirs(char* file, char** full_path, KeyFileFlags flags, GLib2.Error** error=null) {
      return g_key_file_load_from_data_dirs(&this, file, full_path, flags, error);
   }

   // This function looks for a key file named @file in the paths
   // specified in @search_dirs, loads the file into @key_file and
   // returns the file's full path in @full_path.  If the file could not
   // be loaded then an %error is set to either a #GFileError or
   // #GKeyFileError.
   // RETURNS: %TRUE if a key file could be loaded, %FALSE otherwise
   // <file>: a relative path to a filename to open and parse
   // <search_dirs>: %NULL-terminated array of directories to search
   // <full_path>: return location for a string containing the full path of the file, or %NULL
   // <flags>: flags from #GKeyFileFlags
   int load_from_dirs(char* file, char** search_dirs, char** full_path, KeyFileFlags flags, GLib2.Error** error=null) {
      return g_key_file_load_from_dirs(&this, file, search_dirs, full_path, flags, error);
   }

   // Loads a key file into an empty #GKeyFile structure.
   // If the file could not be loaded then %error is set to
   // either a #GFileError or #GKeyFileError.
   // RETURNS: %TRUE if a key file could be loaded, %FALSE otherwise
   // <file>: the path of a filename to load, in the GLib filename encoding
   // <flags>: flags from #GKeyFileFlags
   int load_from_file(char* file, KeyFileFlags flags, GLib2.Error** error=null) {
      return g_key_file_load_from_file(&this, file, flags, error);
   }

   // Removes a comment above @key from @group_name.
   // If @key is %NULL then @comment will be removed above @group_name.
   // If both @key and @group_name are %NULL, then @comment will
   // be removed above the first group in the file.
   // RETURNS: %TRUE if the comment was removed, %FALSE otherwise
   // <group_name>: a group name, or %NULL
   // <key>: a key
   int remove_comment(char* group_name, char* key, GLib2.Error** error=null) {
      return g_key_file_remove_comment(&this, group_name, key, error);
   }

   // Removes the specified group, @group_name,
   // from the key file.
   // RETURNS: %TRUE if the group was removed, %FALSE otherwise
   // <group_name>: a group name
   int remove_group(char* group_name, GLib2.Error** error=null) {
      return g_key_file_remove_group(&this, group_name, error);
   }

   // Removes @key in @group_name from the key file.
   // RETURNS: %TRUE if the key was removed, %FALSE otherwise
   // <group_name>: a group name
   // <key>: a key name to remove
   int remove_key(char* group_name, char* key, GLib2.Error** error=null) {
      return g_key_file_remove_key(&this, group_name, key, error);
   }

   // Associates a new boolean value with @key under @group_name.
   // If @key cannot be found then it is created.
   // <group_name>: a group name
   // <key>: a key
   // <value>: %TRUE or %FALSE
   void set_boolean(char* group_name, char* key, int value) {
      g_key_file_set_boolean(&this, group_name, key, value);
   }

   // Associates a list of boolean values with @key under @group_name.
   // If @key cannot be found then it is created.
   // If @group_name is %NULL, the start_group is used.
   // <group_name>: a group name
   // <key>: a key
   // <list>: an array of boolean values
   // <length>: length of @list
   void set_boolean_list(char* group_name, char* key, int list, size_t length) {
      g_key_file_set_boolean_list(&this, group_name, key, list, length);
   }

   // Places a comment above @key from @group_name.
   // If @key is %NULL then @comment will be written above @group_name.
   // If both @key and @group_name  are %NULL, then @comment will be
   // written above the first group in the file.
   // RETURNS: %TRUE if the comment was written, %FALSE otherwise
   // <group_name>: a group name, or %NULL
   // <key>: a key
   // <comment>: a comment
   int set_comment(char* group_name, char* key, char* comment, GLib2.Error** error=null) {
      return g_key_file_set_comment(&this, group_name, key, comment, error);
   }

   // Associates a new double value with @key under @group_name.
   // If @key cannot be found then it is created.
   // <group_name>: a group name
   // <key>: a key
   // <value>: an double value
   void set_double(char* group_name, char* key, double value) {
      g_key_file_set_double(&this, group_name, key, value);
   }

   // Associates a list of double values with @key under
   // @group_name.  If @key cannot be found then it is created.
   // <group_name>: a group name
   // <key>: a key
   // <list>: an array of double values
   // <length>: number of double values in @list
   void set_double_list(char* group_name, char* key, double list, size_t length) {
      g_key_file_set_double_list(&this, group_name, key, list, length);
   }

   // Associates a new integer value with @key under @group_name.
   // If @key cannot be found then it is created.
   // <group_name>: a group name
   // <key>: a key
   // <value>: an integer value
   void set_int64(char* group_name, char* key, long value) {
      g_key_file_set_int64(&this, group_name, key, value);
   }

   // Associates a new integer value with @key under @group_name.
   // If @key cannot be found then it is created.
   // <group_name>: a group name
   // <key>: a key
   // <value>: an integer value
   void set_integer(char* group_name, char* key, int value) {
      g_key_file_set_integer(&this, group_name, key, value);
   }

   // Associates a list of integer values with @key under @group_name.
   // If @key cannot be found then it is created.
   // <group_name>: a group name
   // <key>: a key
   // <list>: an array of integer values
   // <length>: number of integer values in @list
   void set_integer_list(char* group_name, char* key, int list, size_t length) {
      g_key_file_set_integer_list(&this, group_name, key, list, length);
   }

   // Sets the character which is used to separate
   // values in lists. Typically ';' or ',' are used
   // as separators. The default list separator is ';'.
   // <separator>: the separator
   void set_list_separator(char separator) {
      g_key_file_set_list_separator(&this, separator);
   }

   // Associates a string value for @key and @locale under @group_name.
   // If the translation for @key cannot be found then it is created.
   // <group_name>: a group name
   // <key>: a key
   // <locale>: a locale identifier
   // <string>: a string
   void set_locale_string(char* group_name, char* key, char* locale, char* string_) {
      g_key_file_set_locale_string(&this, group_name, key, locale, string_);
   }

   // Associates a list of string values for @key and @locale under
   // @group_name.  If the translation for @key cannot be found then
   // it is created.
   // <group_name>: a group name
   // <key>: a key
   // <locale>: a locale identifier
   // <list>: a %NULL-terminated array of locale string values
   // <length>: the length of @list
   void set_locale_string_list(char* group_name, char* key, char* locale, char* list, size_t length) {
      g_key_file_set_locale_string_list(&this, group_name, key, locale, list, length);
   }

   // Associates a new string value with @key under @group_name.
   // If @key cannot be found then it is created.
   // If @group_name cannot be found then it is created.
   // Unlike g_key_file_set_value(), this function handles characters
   // that need escaping, such as newlines.
   // <group_name>: a group name
   // <key>: a key
   // <string>: a string
   void set_string(char* group_name, char* key, char* string_) {
      g_key_file_set_string(&this, group_name, key, string_);
   }

   // Associates a list of string values for @key under @group_name.
   // If @key cannot be found then it is created.
   // If @group_name cannot be found then it is created.
   // <group_name>: a group name
   // <key>: a key
   // <list>: an array of string values
   // <length>: number of string values in @list
   void set_string_list(char* group_name, char* key, char* list, size_t length) {
      g_key_file_set_string_list(&this, group_name, key, list, length);
   }

   // Associates a new integer value with @key under @group_name.
   // If @key cannot be found then it is created.
   // <group_name>: a group name
   // <key>: a key
   // <value>: an integer value
   void set_uint64(char* group_name, char* key, ulong value) {
      g_key_file_set_uint64(&this, group_name, key, value);
   }

   // Associates a new value with @key under @group_name.
   // 
   // If @key cannot be found then it is created. If @group_name cannot
   // be found then it is created. To set an UTF-8 string which may contain
   // characters that need escaping (such as newlines or spaces), use
   // g_key_file_set_string().
   // <group_name>: a group name
   // <key>: a key
   // <value>: a string
   void set_value(char* group_name, char* key, char* value) {
      g_key_file_set_value(&this, group_name, key, value);
   }

   // This function outputs @key_file as a string.
   // 
   // Note that this function never reports an error,
   // so it is safe to pass %NULL as @error.
   // 
   // the contents of the #GKeyFile
   // RETURNS: a newly allocated string holding
   // <length>: return location for the length of the returned string, or %NULL
   char* /*new*/ to_data(size_t* length, GLib2.Error** error=null) {
      return g_key_file_to_data(&this, length, error);
   }
   static Quark error_quark() {
      return g_key_file_error_quark();
   }

   // Unintrospectable function: new() / g_key_file_new()
   // Creates a new empty #GKeyFile object. Use
   // g_key_file_load_from_file(), g_key_file_load_from_data(),
   // g_key_file_load_from_dirs() or g_key_file_load_from_data_dirs() to
   // read an existing key file.
   // RETURNS: an empty #GKeyFile.
   static KeyFile* new_() {
      return g_key_file_new();
   }
}

enum KeyFileError {
   UNKNOWN_ENCODING = 0,
   PARSE = 1,
   NOT_FOUND = 2,
   KEY_NOT_FOUND = 3,
   GROUP_NOT_FOUND = 4,
   INVALID_VALUE = 5
}
enum KeyFileFlags {
   NONE = 0,
   KEEP_COMMENTS = 1,
   KEEP_TRANSLATIONS = 2
}
enum int LITTLE_ENDIAN = 1234;
enum double LN10 = 2.302585;
enum double LN2 = 0.693147;
enum double LOG_2_BASE_10 = 0.301030;
enum int LOG_FATAL_MASK = 0;
enum int LOG_LEVEL_USER_SHIFT = 8;
// The #GList struct is used for each element in a doubly-linked list.
struct List {
   void* data;
   GLib2.List* next, prev;


   // Unintrospectable function: alloc() / g_list_alloc()
   // Allocates space for one #GList element. It is called by
   // g_list_append(), g_list_prepend(), g_list_insert() and
   // g_list_insert_sorted() and so is rarely used on its own.
   static GLib2.List* alloc() {
      return g_list_alloc();
   }

   // Unintrospectable function: append() / g_list_append()
   // Adds a new element on to the end of the list.
   // 
   // <note><para>
   // The return value is the new start of the list, which
   // may have changed, so make sure you store the new value.
   // </para></note>
   // 
   // <note><para>
   // Note that g_list_append() has to traverse the entire list
   // to find the end, which is inefficient when adding multiple
   // elements. A common idiom to avoid the inefficiency is to prepend
   // the elements and reverse the list when all elements have been added.
   // </para></note>
   // 
   // |[
   // /&ast; Notice that these are initialized to the empty list. &ast;/
   // GList *list = NULL, *number_list = NULL;
   // 
   // /&ast; This is a list of strings. &ast;/
   // list = g_list_append (list, "first");
   // list = g_list_append (list, "second");
   // 
   // /&ast; This is a list of integers. &ast;/
   // number_list = g_list_append (number_list, GINT_TO_POINTER (27));
   // number_list = g_list_append (number_list, GINT_TO_POINTER (14));
   // ]|
   // RETURNS: the new start of the #GList
   // <list>: a pointer to a #GList
   // <data>: the data for the new element
   static GLib2.List* append(GLib2.List* list, void* data) {
      return g_list_append(list, data);
   }

   // Unintrospectable function: concat() / g_list_concat()
   // Adds the second #GList onto the end of the first #GList.
   // Note that the elements of the second #GList are not copied.
   // They are used directly.
   // RETURNS: the start of the new #GList
   // <list1>: a #GList
   // <list2>: the #GList to add to the end of the first #GList
   static GLib2.List* concat(GLib2.List* list1, GLib2.List* list2) {
      return g_list_concat(list1, list2);
   }

   // Unintrospectable function: copy() / g_list_copy()
   // Copies a #GList.
   // 
   // <note><para>
   // Note that this is a "shallow" copy. If the list elements
   // consist of pointers to data, the pointers are copied but
   // the actual data is not.
   // </para></note>
   // RETURNS: a copy of @list
   // <list>: a #GList
   static GLib2.List* copy(GLib2.List* list) {
      return g_list_copy(list);
   }

   // Unintrospectable function: delete_link() / g_list_delete_link()
   // Removes the node link_ from the list and frees it.
   // Compare this to g_list_remove_link() which removes the node
   // without freeing it.
   // RETURNS: the new head of @list
   // <list>: a #GList
   // <link_>: node to delete from @list
   static GLib2.List* delete_link(GLib2.List* list, GLib2.List* link_) {
      return g_list_delete_link(list, link_);
   }

   // Unintrospectable function: find() / g_list_find()
   // Finds the element in a #GList which
   // contains the given data.
   // 
   // or %NULL if it is not found
   // RETURNS: the found #GList element,
   // <list>: a #GList
   // <data>: the element data to find
   static GLib2.List* find(GLib2.List* list, const(void)* data) {
      return g_list_find(list, data);
   }

   // Unintrospectable function: find_custom() / g_list_find_custom()
   // Finds an element in a #GList, using a supplied function to
   // find the desired element. It iterates over the list, calling
   // the given function which should return 0 when the desired
   // element is found. The function takes two #gconstpointer arguments,
   // the #GList element's data as the first argument and the
   // given user data.
   // RETURNS: the found #GList element, or %NULL if it is not found
   // <list>: a #GList
   // <data>: user data passed to the function
   // <func>: the function to call for each element. It should return 0 when the desired element is found
   static GLib2.List* find_custom(GLib2.List* list, const(void)* data, CompareFunc func) {
      return g_list_find_custom(list, data, func);
   }

   // Unintrospectable function: first() / g_list_first()
   // Gets the first element in a #GList.
   // 
   // or %NULL if the #GList has no elements
   // RETURNS: the first element in the #GList,
   // <list>: a #GList
   static GLib2.List* first(GLib2.List* list) {
      return g_list_first(list);
   }

   // Unintrospectable function: foreach() / g_list_foreach()
   // Calls a function for each element of a #GList.
   // <list>: a #GList
   // <func>: the function to call with each element's data
   // <user_data>: user data to pass to the function
   static void foreach_(GLib2.List* list, Func func, void* user_data) {
      g_list_foreach(list, func, user_data);
   }

   // Unintrospectable function: free() / g_list_free()
   // Frees all of the memory used by a #GList.
   // The freed elements are returned to the slice allocator.
   // 
   // <note><para>
   // If list elements contain dynamically-allocated memory,
   // you should either use g_list_free_full() or free them manually
   // first.
   // </para></note>
   // <list>: a #GList
   static void free(GLib2.List* list) {
      g_list_free(list);
   }

   // Unintrospectable function: free_1() / g_list_free_1()
   // Frees one #GList element.
   // It is usually used after g_list_remove_link().
   // <list>: a #GList element
   static void free_1(GLib2.List* list) {
      g_list_free_1(list);
   }

   // Unintrospectable function: free_full() / g_list_free_full()
   // Convenience method, which frees all the memory used by a #GList, and
   // calls the specified destroy function on every element's data.
   // <list>: a pointer to a #GList
   // <free_func>: the function to be called to free each element's data
   static void free_full(GLib2.List* list, DestroyNotify free_func) {
      g_list_free_full(list, free_func);
   }

   // Unintrospectable function: index() / g_list_index()
   // Gets the position of the element containing
   // the given data (starting from 0).
   // 
   // or -1 if the data is not found
   // RETURNS: the index of the element containing the data,
   // <list>: a #GList
   // <data>: the data to find
   static int index(GLib2.List* list, const(void)* data) {
      return g_list_index(list, data);
   }

   // Unintrospectable function: insert() / g_list_insert()
   // Inserts a new element into the list at the given position.
   // RETURNS: the new start of the #GList
   // <list>: a pointer to a #GList
   // <data>: the data for the new element
   // <position>: the position to insert the element. If this is negative, or is larger than the number of elements in the list, the new element is added on to the end of the list.
   static GLib2.List* insert(GLib2.List* list, void* data, int position) {
      return g_list_insert(list, data, position);
   }

   // Unintrospectable function: insert_before() / g_list_insert_before()
   // Inserts a new element into the list before the given position.
   // RETURNS: the new start of the #GList
   // <list>: a pointer to a #GList
   // <sibling>: the list element before which the new element is inserted or %NULL to insert at the end of the list
   // <data>: the data for the new element
   static GLib2.List* insert_before(GLib2.List* list, GLib2.List* sibling, void* data) {
      return g_list_insert_before(list, sibling, data);
   }

   // Unintrospectable function: insert_sorted() / g_list_insert_sorted()
   // Inserts a new element into the list, using the given comparison
   // function to determine its position.
   // RETURNS: the new start of the #GList
   // <list>: a pointer to a #GList
   // <data>: the data for the new element
   // <func>: the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order.
   static GLib2.List* insert_sorted(GLib2.List* list, void* data, CompareFunc func) {
      return g_list_insert_sorted(list, data, func);
   }

   // Unintrospectable function: insert_sorted_with_data() / g_list_insert_sorted_with_data()
   // Inserts a new element into the list, using the given comparison
   // function to determine its position.
   // RETURNS: the new start of the #GList
   // <list>: a pointer to a #GList
   // <data>: the data for the new element
   // <func>: the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order.
   // <user_data>: user data to pass to comparison function.
   static GLib2.List* insert_sorted_with_data(GLib2.List* list, void* data, CompareDataFunc func, void* user_data) {
      return g_list_insert_sorted_with_data(list, data, func, user_data);
   }

   // Unintrospectable function: last() / g_list_last()
   // Gets the last element in a #GList.
   // 
   // or %NULL if the #GList has no elements
   // RETURNS: the last element in the #GList,
   // <list>: a #GList
   static GLib2.List* last(GLib2.List* list) {
      return g_list_last(list);
   }

   // Unintrospectable function: length() / g_list_length()
   // Gets the number of elements in a #GList.
   // 
   // <note><para>
   // This function iterates over the whole list to
   // count its elements.
   // </para></note>
   // RETURNS: the number of elements in the #GList
   // <list>: a #GList
   static uint length(GLib2.List* list) {
      return g_list_length(list);
   }

   // Unintrospectable function: nth() / g_list_nth()
   // Gets the element at the given position in a #GList.
   // 
   // the end of the #GList
   // RETURNS: the element, or %NULL if the position is off
   // <list>: a #GList
   // <n>: the position of the element, counting from 0
   static GLib2.List* nth(GLib2.List* list, uint n) {
      return g_list_nth(list, n);
   }

   // Unintrospectable function: nth_data() / g_list_nth_data()
   // Gets the data of the element at the given position.
   // 
   // is off the end of the #GList
   // RETURNS: the element's data, or %NULL if the position
   // <list>: a #GList
   // <n>: the position of the element
   static void* nth_data(GLib2.List* list, uint n) {
      return g_list_nth_data(list, n);
   }

   // Unintrospectable function: nth_prev() / g_list_nth_prev()
   // Gets the element @n places before @list.
   // 
   // off the end of the #GList
   // RETURNS: the element, or %NULL if the position is
   // <list>: a #GList
   // <n>: the position of the element, counting from 0
   static GLib2.List* nth_prev(GLib2.List* list, uint n) {
      return g_list_nth_prev(list, n);
   }

   // Restores the previous #GAllocator, used when allocating #GList
   // elements.
   // 
   // Note that this function is not available if GLib has been compiled
   // with <option>--disable-mem-pools</option>
   // 
   // Deprecated:2.10: It does nothing, since #GList has been converted
   // to the <link linkend="glib-Memory-Slices">slice
   // allocator</link>
   static void pop_allocator() {
      g_list_pop_allocator();
   }

   // Unintrospectable function: position() / g_list_position()
   // Gets the position of the given element
   // in the #GList (starting from 0).
   // 
   // or -1 if the element is not found
   // RETURNS: the position of the element in the #GList,
   // <list>: a #GList
   // <llink>: an element in the #GList
   static int position(GLib2.List* list, GLib2.List* llink) {
      return g_list_position(list, llink);
   }

   // Unintrospectable function: prepend() / g_list_prepend()
   // Adds a new element on to the start of the list.
   // 
   // <note><para>
   // The return value is the new start of the list, which
   // may have changed, so make sure you store the new value.
   // </para></note>
   // 
   // |[
   // /&ast; Notice that it is initialized to the empty list. &ast;/
   // GList *list = NULL;
   // list = g_list_prepend (list, "last");
   // list = g_list_prepend (list, "first");
   // ]|
   // RETURNS: the new start of the #GList
   // <list>: a pointer to a #GList
   // <data>: the data for the new element
   static GLib2.List* prepend(GLib2.List* list, void* data) {
      return g_list_prepend(list, data);
   }

   // Sets the allocator to use to allocate #GList elements. Use
   // g_list_pop_allocator() to restore the previous allocator.
   // 
   // Note that this function is not available if GLib has been compiled
   // with <option>--disable-mem-pools</option>
   // 
   // Deprecated:2.10: It does nothing, since #GList has been converted
   // to the <link linkend="glib-Memory-Slices">slice
   // allocator</link>
   // <allocator>: the #GAllocator to use when allocating #GList elements.
   static void push_allocator(void* allocator) {
      g_list_push_allocator(allocator);
   }

   // Unintrospectable function: remove() / g_list_remove()
   // Removes an element from a #GList.
   // If two elements contain the same data, only the first is removed.
   // If none of the elements contain the data, the #GList is unchanged.
   // RETURNS: the new start of the #GList
   // <list>: a #GList
   // <data>: the data of the element to remove
   static GLib2.List* remove(GLib2.List* list, const(void)* data) {
      return g_list_remove(list, data);
   }

   // Unintrospectable function: remove_all() / g_list_remove_all()
   // Removes all list nodes with data equal to @data.
   // Returns the new head of the list. Contrast with
   // g_list_remove() which removes only the first node
   // matching the given data.
   // RETURNS: new head of @list
   // <list>: a #GList
   // <data>: data to remove
   static GLib2.List* remove_all(GLib2.List* list, const(void)* data) {
      return g_list_remove_all(list, data);
   }

   // Unintrospectable function: remove_link() / g_list_remove_link()
   // Removes an element from a #GList, without freeing the element.
   // The removed element's prev and next links are set to %NULL, so
   // that it becomes a self-contained list with one element.
   // RETURNS: the new start of the #GList, without the element
   // <list>: a #GList
   // <llink>: an element in the #GList
   static GLib2.List* remove_link(GLib2.List* list, GLib2.List* llink) {
      return g_list_remove_link(list, llink);
   }

   // Unintrospectable function: reverse() / g_list_reverse()
   // Reverses a #GList.
   // It simply switches the next and prev pointers of each element.
   // RETURNS: the start of the reversed #GList
   // <list>: a #GList
   static GLib2.List* reverse(GLib2.List* list) {
      return g_list_reverse(list);
   }

   // Unintrospectable function: sort() / g_list_sort()
   // Sorts a #GList using the given comparison function.
   // RETURNS: the start of the sorted #GList
   // <list>: a #GList
   // <compare_func>: the comparison function used to sort the #GList. This function is passed the data from 2 elements of the #GList and should return 0 if they are equal, a negative value if the first element comes before the second, or a positive value if the first element comes after the second.
   static GLib2.List* sort(GLib2.List* list, CompareFunc compare_func) {
      return g_list_sort(list, compare_func);
   }

   // Unintrospectable function: sort_with_data() / g_list_sort_with_data()
   // Like g_list_sort(), but the comparison function accepts
   // a user data argument.
   // RETURNS: the new head of @list
   // <list>: a #GList
   // <compare_func>: comparison function
   // <user_data>: user data to pass to comparison function
   static GLib2.List* sort_with_data(GLib2.List* list, CompareDataFunc compare_func, void* user_data) {
      return g_list_sort_with_data(list, compare_func, user_data);
   }
}

extern (C) alias void function (char* log_domain, LogLevelFlags log_level, char* message, void* user_data) LogFunc;

enum LogLevelFlags {
   FLAG_RECURSION = 1,
   FLAG_FATAL = 2,
   LEVEL_ERROR = 4,
   LEVEL_CRITICAL = 8,
   LEVEL_WARNING = 16,
   LEVEL_MESSAGE = 32,
   LEVEL_INFO = 64,
   LEVEL_DEBUG = 128,
   LEVEL_MASK = -4
}
enum int MAJOR_VERSION = 2;
enum int MICRO_VERSION = 2;
enum int MINOR_VERSION = 30;
enum MODULE_SUFFIX = "so";
enum int MUTEX_DEBUG_MAGIC = cast(int)4175530711;

// The <structname>GMainContext</structname> struct is an opaque data
// type representing a set of sources to be handled in a main loop.
struct MainContext {

   // Creates a new #GMainContext structure.
   // RETURNS: the new #GMainContext
   static MainContext* /*new*/ new_() {
      return g_main_context_new();
   }

   // Tries to become the owner of the specified context.
   // If some other thread is the owner of the context,
   // returns %FALSE immediately. Ownership is properly
   // recursive: the owner can require ownership again
   // and will release ownership when g_main_context_release()
   // is called as many times as g_main_context_acquire().
   // 
   // You must be the owner of a context before you
   // can call g_main_context_prepare(), g_main_context_query(),
   // g_main_context_check(), g_main_context_dispatch().
   // 
   // this thread is now the owner of @context.
   // RETURNS: %TRUE if the operation succeeded, and
   int acquire() {
      return g_main_context_acquire(&this);
   }

   // Adds a file descriptor to the set of file descriptors polled for
   // this context. This will very seldom be used directly. Instead
   // a typical event source will use g_source_add_poll() instead.
   // <fd>: a #GPollFD structure holding information about a file descriptor to watch.
   // <priority>: the priority for this file descriptor which should be the same as the priority used for g_source_attach() to ensure that the file descriptor is polled whenever the results may be needed.
   void add_poll(PollFD* fd, int priority) {
      g_main_context_add_poll(&this, fd, priority);
   }

   // Passes the results of polling back to the main loop.
   // RETURNS: %TRUE if some sources are ready to be dispatched.
   // <max_priority>: the maximum numerical priority of sources to check
   // <fds>: array of #GPollFD's that was passed to the last call to g_main_context_query()
   // <n_fds>: return value of g_main_context_query()
   int check(int max_priority, PollFD* fds, int n_fds) {
      return g_main_context_check(&this, max_priority, fds, n_fds);
   }
   // Dispatches all pending sources.
   void dispatch() {
      g_main_context_dispatch(&this);
   }

   // Finds a source with the given source functions and user data.  If
   // multiple sources exist with the same source function and user data,
   // the first one found will be returned.
   // RETURNS: the source, if one was found, otherwise %NULL
   // <funcs>: the @source_funcs passed to g_source_new().
   // <user_data>: the user data from the callback.
   Source* find_source_by_funcs_user_data(SourceFuncs* funcs, void* user_data) {
      return g_main_context_find_source_by_funcs_user_data(&this, funcs, user_data);
   }

   // Finds a #GSource given a pair of context and ID.
   // RETURNS: the #GSource if found, otherwise, %NULL
   // <source_id>: the source ID, as returned by g_source_get_id().
   Source* find_source_by_id(uint source_id) {
      return g_main_context_find_source_by_id(&this, source_id);
   }

   // Finds a source with the given user data for the callback.  If
   // multiple sources exist with the same user data, the first
   // one found will be returned.
   // RETURNS: the source, if one was found, otherwise %NULL
   // <user_data>: the user_data for the callback.
   Source* find_source_by_user_data(void* user_data) {
      return g_main_context_find_source_by_user_data(&this, user_data);
   }

   // Unintrospectable method: get_poll_func() / g_main_context_get_poll_func()
   // Gets the poll function set by g_main_context_set_poll_func().
   // RETURNS: the poll function
   PollFunc get_poll_func() {
      return g_main_context_get_poll_func(&this);
   }

   // Unintrospectable method: invoke() / g_main_context_invoke()
   // Invokes a function in such a way that @context is owned during the
   // invocation of @function.
   // 
   // If @context is %NULL then the global default main context — as
   // returned by g_main_context_default() — is used.
   // 
   // If @context is owned by the current thread, @function is called
   // directly.  Otherwise, if @context is the thread-default main context
   // of the current thread and g_main_context_acquire() succeeds, then
   // @function is called and g_main_context_release() is called
   // afterwards.
   // 
   // In any other case, an idle source is created to call @function and
   // that source is attached to @context (presumably to be run in another
   // thread).  The idle source is attached with #G_PRIORITY_DEFAULT
   // priority.  If you want a different priority, use
   // g_main_context_invoke_full().
   // 
   // Note that, as with normal idle functions, @function should probably
   // return %FALSE.  If it returns %TRUE, it will be continuously run in a
   // loop (and may prevent this call from returning).
   // <function>: function to call
   // <data>: data to pass to @function
   void invoke(SourceFunc function_, void* data) {
      g_main_context_invoke(&this, function_, data);
   }

   // Invokes a function in such a way that @context is owned during the
   // invocation of @function.
   // 
   // This function is the same as g_main_context_invoke() except that it
   // lets you specify the priority incase @function ends up being
   // scheduled as an idle and also lets you give a #GDestroyNotify for @data.
   // 
   // @notify should not assume that it is called from any particular
   // thread or with any particular context acquired.
   // <priority>: the priority at which to run @function
   // <function>: function to call
   // <data>: data to pass to @function
   // <notify>: a function to call when @data is no longer in use, or %NULL.
   void invoke_full(int priority, SourceFunc function_, void* data, DestroyNotify notify) {
      g_main_context_invoke_full(&this, priority, function_, data, notify);
   }

   // Determines whether this thread holds the (recursive)
   // ownership of this #GMaincontext. This is useful to
   // know before waiting on another thread that may be
   // blocking to get ownership of @context.
   // RETURNS: %TRUE if current thread is owner of @context.
   int is_owner() {
      return g_main_context_is_owner(&this);
   }

   // Runs a single iteration for the given main loop. This involves
   // checking to see if any event sources are ready to be processed,
   // then if no events sources are ready and @may_block is %TRUE, waiting
   // for a source to become ready, then dispatching the highest priority
   // events sources that are ready. Otherwise, if @may_block is %FALSE
   // sources are not waited to become ready, only those highest priority
   // events sources will be dispatched (if any), that are ready at this
   // given moment without further waiting.
   // 
   // Note that even when @may_block is %TRUE, it is still possible for
   // g_main_context_iteration() to return %FALSE, since the the wait may
   // be interrupted for other reasons than an event source becoming ready.
   // RETURNS: %TRUE if events were dispatched.
   // <may_block>: whether the call may block.
   int iteration(int may_block) {
      return g_main_context_iteration(&this, may_block);
   }

   // Checks if any sources have pending events for the given context.
   // RETURNS: %TRUE if events are pending.
   int pending() {
      return g_main_context_pending(&this);
   }

   // Pops @context off the thread-default context stack (verifying that
   // it was on the top of the stack).
   void pop_thread_default() {
      g_main_context_pop_thread_default(&this);
   }

   // Prepares to poll sources within a main loop. The resulting information
   // for polling is determined by calling g_main_context_query ().
   // 
   // prior to polling.
   // RETURNS: %TRUE if some source is ready to be dispatched
   // <priority>: location to store priority of highest priority source already ready.
   int prepare(int* priority) {
      return g_main_context_prepare(&this, priority);
   }

   // Acquires @context and sets it as the thread-default context for the
   // current thread. This will cause certain asynchronous operations
   // (such as most <link linkend="gio">gio</link>-based I/O) which are
   // started in this thread to run under @context and deliver their
   // results to its main loop, rather than running under the global
   // default context in the main thread. Note that calling this function
   // changes the context returned by
   // g_main_context_get_thread_default(), <emphasis>not</emphasis> the
   // one returned by g_main_context_default(), so it does not affect the
   // context used by functions like g_idle_add().
   // 
   // Normally you would call this function shortly after creating a new
   // thread, passing it a #GMainContext which will be run by a
   // #GMainLoop in that thread, to set a new default context for all
   // async operations in that thread. (In this case, you don't need to
   // ever call g_main_context_pop_thread_default().) In some cases
   // however, you may want to schedule a single operation in a
   // non-default context, or temporarily use a non-default context in
   // the main thread. In that case, you can wrap the call to the
   // asynchronous operation inside a
   // g_main_context_push_thread_default() /
   // g_main_context_pop_thread_default() pair, but it is up to you to
   // ensure that no other asynchronous operations accidentally get
   // started while the non-default context is active.
   // 
   // Beware that libraries that predate this function may not correctly
   // handle being used from a thread with a thread-default context. Eg,
   // see g_file_supports_thread_contexts().
   void push_thread_default() {
      g_main_context_push_thread_default(&this);
   }

   // Determines information necessary to poll this main loop.
   // 
   // or, if more than @n_fds records need to be stored, the number
   // of records that need to be stored.
   // RETURNS: the number of records actually stored in @fds,
   // <max_priority>: maximum priority source to check
   // <timeout_>: location to store timeout to be used in polling
   // <fds>: location to store #GPollFD records that need to be polled.
   // <n_fds>: length of @fds.
   int query(int max_priority, /*out*/ int* timeout_, /*out*/ PollFD* fds, /*out*/ int n_fds) {
      return g_main_context_query(&this, max_priority, timeout_, fds, n_fds);
   }

   // Increases the reference count on a #GMainContext object by one.
   // RETURNS: the @context that was passed in (since 2.6)
   MainContext* /*new*/ ref_() {
      return g_main_context_ref(&this);
   }

   // Releases ownership of a context previously acquired by this thread
   // with g_main_context_acquire(). If the context was acquired multiple
   // times, the ownership will be released only when g_main_context_release()
   // is called as many times as it was acquired.
   void release() {
      g_main_context_release(&this);
   }

   // Removes file descriptor from the set of file descriptors to be
   // polled for a particular context.
   // <fd>: a #GPollFD descriptor previously added with g_main_context_add_poll()
   void remove_poll(PollFD* fd) {
      g_main_context_remove_poll(&this, fd);
   }

   // Unintrospectable method: set_poll_func() / g_main_context_set_poll_func()
   // Sets the function to use to handle polling of file descriptors. It
   // will be used instead of the poll() system call
   // (or GLib's replacement function, which is used where
   // poll() isn't available).
   // 
   // This function could possibly be used to integrate the GLib event
   // loop with an external event loop.
   // <func>: the function to call to poll all file descriptors
   void set_poll_func(PollFunc func) {
      g_main_context_set_poll_func(&this, func);
   }

   // Decreases the reference count on a #GMainContext object by one. If
   // the result is zero, free the context and free all associated memory.
   void unref() {
      g_main_context_unref(&this);
   }

   // Tries to become the owner of the specified context,
   // as with g_main_context_acquire(). But if another thread
   // is the owner, atomically drop @mutex and wait on @cond until
   // that owner releases ownership or until @cond is signaled, then
   // try again (once) to become the owner.
   // 
   // this thread is now the owner of @context.
   // RETURNS: %TRUE if the operation succeeded, and
   // <cond>: a condition variable
   // <mutex>: a mutex, currently held
   int wait(Cond* cond, Mutex* mutex) {
      return g_main_context_wait(&this, cond, mutex);
   }

   // If @context is currently waiting in a poll(), interrupt
   // the poll(), and continue the iteration process.
   void wakeup() {
      g_main_context_wakeup(&this);
   }

   // Returns the global default main context. This is the main context
   // used for main loop functions when a main loop is not explicitly
   // specified, and corresponds to the "main" main loop. See also
   // g_main_context_get_thread_default().
   // RETURNS: the global default main context.
   static MainContext* default_() {
      return g_main_context_default();
   }

   // Gets the thread-default #GMainContext for this thread. Asynchronous
   // operations that want to be able to be run in contexts other than
   // the default one should call this method to get a #GMainContext to
   // add their #GSource<!-- -->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 %NULL if threads are not initialized.)
   // 
   // %NULL if the thread-default context is the global default context.
   // RETURNS: the thread-default #GMainContext, or
   static MainContext* get_thread_default() {
      return g_main_context_get_thread_default();
   }
}


// The <structname>GMainLoop</structname> struct is an opaque data type
// representing the main event loop of a GLib or GTK+ application.
struct MainLoop {

   // Creates a new #GMainLoop structure.
   // RETURNS: a new #GMainLoop.
   // <context>: a #GMainContext  (if %NULL, the default context will be used).
   // <is_running>: set to %TRUE to indicate that the loop is running. This is not very important since calling g_main_loop_run() will set this to %TRUE anyway.
   static MainLoop* /*new*/ new_(MainContext* context, int is_running) {
      return g_main_loop_new(context, is_running);
   }

   // Returns the #GMainContext of @loop.
   // RETURNS: the #GMainContext of @loop
   MainContext* get_context() {
      return g_main_loop_get_context(&this);
   }

   // Checks to see if the main loop is currently being run via g_main_loop_run().
   // RETURNS: %TRUE if the mainloop is currently being run.
   int is_running() {
      return g_main_loop_is_running(&this);
   }

   // Stops a #GMainLoop from running. Any calls to g_main_loop_run()
   // for the loop will return.
   // 
   // Note that sources that have already been dispatched when
   // g_main_loop_quit() is called will still be executed.
   void quit() {
      g_main_loop_quit(&this);
   }

   // Increases the reference count on a #GMainLoop object by one.
   // RETURNS: @loop
   MainLoop* /*new*/ ref_() {
      return g_main_loop_ref(&this);
   }

   // Runs a main loop until g_main_loop_quit() is called on the loop.
   // If this is called for the thread of the loop's #GMainContext,
   // it will process events from the loop, otherwise it will
   // simply wait.
   void run() {
      g_main_loop_run(&this);
   }

   // Decreases the reference count on a #GMainLoop object by one. If
   // the result is zero, free the loop and free all associated memory.
   void unref() {
      g_main_loop_unref(&this);
   }
}

struct MappedFile {

   // This call existed before #GMappedFile had refcounting and is currently
   // exactly the same as g_mapped_file_unref().
   // 
   // Deprecated:2.22: Use g_mapped_file_unref() instead.
   void free() {
      g_mapped_file_free(&this);
   }

   // Returns the contents of a #GMappedFile.
   // 
   // Note that the contents may not be zero-terminated,
   // even if the #GMappedFile is backed by a text file.
   // 
   // If the file is empty then %NULL is returned.
   // RETURNS: the contents of @file, or %NULL.
   char* /*new*/ get_contents() {
      return g_mapped_file_get_contents(&this);
   }

   // Returns the length of the contents of a #GMappedFile.
   // RETURNS: the length of the contents of @file.
   size_t get_length() {
      return g_mapped_file_get_length(&this);
   }

   // Unintrospectable method: ref() / g_mapped_file_ref()
   // Increments the reference count of @file by one.  It is safe to call
   // this function from any thread.
   // RETURNS: the passed in #GMappedFile.
   MappedFile* ref_() {
      return g_mapped_file_ref(&this);
   }

   // Decrements the reference count of @file by one.  If the reference count
   // drops to 0, unmaps the buffer of @file and frees it.
   // 
   // It is safe to call this function from any thread.
   // 
   // Since 2.22
   void unref() {
      g_mapped_file_unref(&this);
   }

   // Unintrospectable function: new() / g_mapped_file_new()
   // Maps a file into memory. On UNIX, this is using the mmap() function.
   // 
   // If @writable is %TRUE, the mapped buffer may be modified, otherwise
   // it is an error to modify the mapped buffer. Modifications to the buffer
   // are not visible to other processes mapping the same file, and are not
   // written back to the file.
   // 
   // Note that modifications of the underlying file might affect the contents
   // of the #GMappedFile. Therefore, mapping should only be used if the file
   // will not be modified, or if all modifications of the file are done
   // atomically (e.g. using g_file_set_contents()).
   // 
   // with g_mapped_file_unref(), or %NULL if the mapping failed.
   // RETURNS: a newly allocated #GMappedFile which must be unref'd
   // <filename>: The path of the file to load, in the GLib filename encoding
   // <writable>: whether the mapping should be writable
   static MappedFile* new_(char* filename, int writable, GLib2.Error** error=null) {
      return g_mapped_file_new(filename, writable, error);
   }
}


// A mixed enumerated type and flags field. You must specify one type
// (string, strdup, boolean, tristate).  Additionally, you may  optionally
// bitwise OR the type with the flag %G_MARKUP_COLLECT_OPTIONAL.
// 
// It is likely that this enum will be extended in the future to
// support other types.
enum MarkupCollectType {
   INVALID = 0,
   STRING = 1,
   STRDUP = 2,
   BOOLEAN = 3,
   TRISTATE = 4,
   OPTIONAL = 65536
}
// Error codes returned by markup parsing.
enum MarkupError {
   BAD_UTF8 = 0,
   EMPTY = 1,
   PARSE = 2,
   UNKNOWN_ELEMENT = 3,
   UNKNOWN_ATTRIBUTE = 4,
   INVALID_CONTENT = 5,
   MISSING_ATTRIBUTE = 6
}

// A parse context is used to parse a stream of bytes that
// you expect to contain marked-up text.
// 
// See g_markup_parse_context_new(), #GMarkupParser, and so
// on for more details.
struct MarkupParseContext {

   // Signals to the #GMarkupParseContext that all data has been
   // fed into the parse context with g_markup_parse_context_parse().
   // 
   // This function reports an error if the document isn't complete,
   // for example if elements are still open.
   // RETURNS: %TRUE on success, %FALSE if an error was set
   int end_parse(GLib2.Error** error=null) {
      return g_markup_parse_context_end_parse(&this, error);
   }

   // Frees a #GMarkupParseContext.
   // 
   // This function can't be called from inside one of the
   // #GMarkupParser functions or while a subparser is pushed.
   void free() {
      g_markup_parse_context_free(&this);
   }

   // Retrieves the name of the currently open element.
   // 
   // If called from the start_element or end_element handlers this will
   // give the element_name as passed to those functions. For the parent
   // elements, see g_markup_parse_context_get_element_stack().
   // RETURNS: the name of the currently open element, or %NULL
   char* get_element() {
      return g_markup_parse_context_get_element(&this);
   }

   // Unintrospectable method: get_element_stack() / g_markup_parse_context_get_element_stack()
   // Retrieves the element stack from the internal state of the parser.
   // 
   // The returned #GSList is a list of strings where the first item is
   // the currently open tag (as would be returned by
   // g_markup_parse_context_get_element()) and the next item is its
   // immediate parent.
   // 
   // This function is intended to be used in the start_element and
   // end_element handlers where g_markup_parse_context_get_element()
   // would merely return the name of the element that is being
   // processed.
   // RETURNS: the element stack, which must not be modified
   GLib2.SList* get_element_stack() {
      return g_markup_parse_context_get_element_stack(&this);
   }

   // Retrieves the current line number and the number of the character on
   // that line. Intended for use in error messages; there are no strict
   // semantics for what constitutes the "current" line number other than
   // "the best number we could come up with for error messages."
   // <line_number>: return location for a line number, or %NULL
   // <char_number>: return location for a char-on-line number, or %NULL
   void get_position(int* line_number=null, int* char_number=null) {
      g_markup_parse_context_get_position(&this, line_number, char_number);
   }

   // Unintrospectable method: get_user_data() / g_markup_parse_context_get_user_data()
   // Returns the user_data associated with @context.
   // 
   // This will either be the user_data that was provided to
   // g_markup_parse_context_new() or to the most recent call
   // of g_markup_parse_context_push().
   // 
   // the markup context and will be freed when
   // g_markup_parse_context_free() is called.
   // RETURNS: the provided user_data. The returned data belongs to
   void* get_user_data() {
      return g_markup_parse_context_get_user_data(&this);
   }

   // Feed some data to the #GMarkupParseContext.
   // 
   // The data need not be valid UTF-8; an error will be signaled if
   // it's invalid. The data need not be an entire document; you can
   // feed a document into the parser incrementally, via multiple calls
   // to this function. Typically, as you receive data from a network
   // connection or file, you feed each received chunk of data into this
   // function, aborting the process if an error occurs. Once an error
   // is reported, no further data may be fed to the #GMarkupParseContext;
   // all errors are fatal.
   // RETURNS: %FALSE if an error occurred, %TRUE on success
   // <text>: chunk of text to parse
   // <text_len>: length of @text in bytes
   int parse(char* text, ssize_t text_len, GLib2.Error** error=null) {
      return g_markup_parse_context_parse(&this, text, text_len, error);
   }

   // Unintrospectable method: pop() / g_markup_parse_context_pop()
   // Completes the process of a temporary sub-parser redirection.
   // 
   // This function exists to collect the user_data allocated by a
   // matching call to g_markup_parse_context_push(). It must be called
   // in the end_element handler corresponding to the start_element
   // handler during which g_markup_parse_context_push() was called.
   // You must not call this function from the error callback -- the
   // @user_data is provided directly to the callback in that case.
   // 
   // This function is not intended to be directly called by users
   // interested in invoking subparsers. Instead, it is intended to
   // be used by the subparsers themselves to implement a higher-level
   // interface.
   // RETURNS: the user data passed to g_markup_parse_context_push()
   void* pop() {
      return g_markup_parse_context_pop(&this);
   }

   // Temporarily redirects markup data to a sub-parser.
   // 
   // This function may only be called from the start_element handler of
   // a #GMarkupParser. It must be matched with a corresponding call to
   // g_markup_parse_context_pop() in the matching end_element handler
   // (except in the case that the parser aborts due to an error).
   // 
   // All tags, text and other data between the matching tags is
   // redirected to the subparser given by @parser. @user_data is used
   // as the user_data for that parser. @user_data is also passed to the
   // error callback in the event that an error occurs. This includes
   // errors that occur in subparsers of the subparser.
   // 
   // The end tag matching the start tag for which this call was made is
   // handled by the previous parser (which is given its own user_data)
   // which is why g_markup_parse_context_pop() is provided to allow "one
   // last access" to the @user_data provided to this function. In the
   // case of error, the @user_data provided here is passed directly to
   // the error callback of the subparser and g_markup_parse_context_pop()
   // should not be called. In either case, if @user_data was allocated
   // then it ought to be freed from both of these locations.
   // 
   // This function is not intended to be directly called by users
   // interested in invoking subparsers. Instead, it is intended to be
   // used by the subparsers themselves to implement a higher-level
   // interface.
   // 
   // As an example, see the following implementation of a simple
   // parser that counts the number of tags encountered.
   // 
   // |[
   // typedef struct
   // {
   // gint tag_count;
   // } CounterData;
   // 
   // static void
   // counter_start_element (GMarkupParseContext  *context,
   // const gchar          *element_name,
   // const gchar         **attribute_names,
   // const gchar         **attribute_values,
   // gpointer              user_data,
   // GError              **error)
   // {
   // CounterData *data = user_data;
   // 
   // data->tag_count++;
   // }
   // 
   // static void
   // counter_error (GMarkupParseContext *context,
   // GError              *error,
   // gpointer             user_data)
   // {
   // CounterData *data = user_data;
   // 
   // g_slice_free (CounterData, data);
   // }
   // 
   // static GMarkupParser counter_subparser =
   // {
   // counter_start_element,
   // NULL,
   // NULL,
   // NULL,
   // counter_error
   // };
   // ]|
   // 
   // In order to allow this parser to be easily used as a subparser, the
   // following interface is provided:
   // 
   // |[
   // void
   // start_counting (GMarkupParseContext *context)
   // {
   // CounterData *data = g_slice_new (CounterData);
   // 
   // data->tag_count = 0;
   // g_markup_parse_context_push (context, &counter_subparser, data);
   // }
   // 
   // gint
   // end_counting (GMarkupParseContext *context)
   // {
   // CounterData *data = g_markup_parse_context_pop (context);
   // int result;
   // 
   // result = data->tag_count;
   // g_slice_free (CounterData, data);
   // 
   // return result;
   // }
   // ]|
   // 
   // The subparser would then be used as follows:
   // 
   // |[
   // static void start_element (context, element_name, ...)
   // {
   // if (strcmp (element_name, "count-these") == 0)
   // start_counting (context);
   // 
   // /&ast; else, handle other tags... &ast;/
   // }
   // 
   // static void end_element (context, element_name, ...)
   // {
   // if (strcmp (element_name, "count-these") == 0)
   // g_print ("Counted %d tags\n", end_counting (context));
   // 
   // /&ast; else, handle other tags... &ast;/
   // }
   // ]|
   // <parser>: a #GMarkupParser
   // <user_data>: user data to pass to #GMarkupParser functions
   void push(MarkupParser* parser, void* user_data) {
      g_markup_parse_context_push(&this, parser, user_data);
   }

   // Unintrospectable function: new() / g_markup_parse_context_new()
   // Creates a new parse context. A parse context is used to parse
   // marked-up documents. You can feed any number of documents into
   // a context, as long as no errors occur; once an error occurs,
   // the parse context can't continue to parse text (you have to
   // free it and create a new parse context).
   // RETURNS: a new #GMarkupParseContext
   // <parser>: a #GMarkupParser
   // <flags>: one or more #GMarkupParseFlags
   // <user_data>: user data to pass to #GMarkupParser functions
   // <user_data_dnotify>: user data destroy notifier called when the parse context is freed
   static MarkupParseContext* new_(MarkupParser* parser, MarkupParseFlags flags, void* user_data, DestroyNotify user_data_dnotify) {
      return g_markup_parse_context_new(parser, flags, user_data, user_data_dnotify);
   }
}

// Flags that affect the behaviour of the parser.
enum MarkupParseFlags {
   DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1,
   TREAT_CDATA_AS_TEXT = 2,
   PREFIX_ERROR_POSITION = 4
}

// Any of the fields in #GMarkupParser can be %NULL, in which case they
// will be ignored. Except for the @error function, any of these callbacks
// can set an error; in particular the %G_MARKUP_ERROR_UNKNOWN_ELEMENT,
// %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, and %G_MARKUP_ERROR_INVALID_CONTENT
// errors are intended to be set from these callbacks. If you set an error
// from a callback, g_markup_parse_context_parse() will report that error
// back to its caller.
struct MarkupParser {
   extern (C) void function (MarkupParseContext* context, char* element_name, char** attribute_names, char** attribute_values, void* user_data, GLib2.Error** error=null) start_element;
   extern (C) void function (MarkupParseContext* context, char* element_name, void* user_data, GLib2.Error** error=null) end_element;
   extern (C) void function (MarkupParseContext* context, char* text, size_t text_len, void* user_data, GLib2.Error** error=null) text;
   extern (C) void function (MarkupParseContext* context, char* passthrough_text, size_t text_len, void* user_data, GLib2.Error** error=null) passthrough;
   extern (C) void function (MarkupParseContext* context, Error* error, void* user_data) error;
}

struct MatchInfo {

   // Returns a new string containing the text in @string_to_expand with
   // references and escape sequences expanded. References refer to the last
   // match done with @string against @regex and have the same syntax used by
   // g_regex_replace().
   // 
   // The @string_to_expand must be UTF-8 encoded even if #G_REGEX_RAW was
   // passed to g_regex_new().
   // 
   // The backreferences are extracted from the string passed to the match
   // function, so you cannot call this function after freeing the string.
   // 
   // @match_info may be %NULL in which case @string_to_expand must not
   // contain references. For instance "foo\n" does not refer to an actual
   // pattern and '\n' merely will be replaced with \n character,
   // while to expand "\0" (whole match) one needs the result of a match.
   // Use g_regex_check_replacement() to find out whether @string_to_expand
   // contains references.
   // RETURNS: the expanded string, or %NULL if an error occurred
   // <string_to_expand>: the string to expand
   char* /*new*/ expand_references(char* string_to_expand, GLib2.Error** error=null) {
      return g_match_info_expand_references(&this, string_to_expand, error);
   }

   // Retrieves the text matching the @match_num<!-- -->'th capturing
   // parentheses. 0 is the full text of the match, 1 is the first paren
   // set, 2 the second, and so on.
   // 
   // If @match_num is a valid sub pattern but it didn't match anything
   // (e.g. sub pattern 1, matching "b" against "(a)?b") then an empty
   // string is returned.
   // 
   // If the match was obtained using the DFA algorithm, that is using
   // g_regex_match_all() or g_regex_match_all_full(), the retrieved
   // string is not that of a set of parentheses but that of a matched
   // substring. Substrings are matched in reverse order of length, so
   // 0 is the longest match.
   // 
   // The string is fetched from the string passed to the match function,
   // so you cannot call this function after freeing the string.
   // 
   // occurred. You have to free the string yourself
   // RETURNS: The matched substring, or %NULL if an error
   // <match_num>: number of the sub expression
   char* /*new*/ fetch(int match_num) {
      return g_match_info_fetch(&this, match_num);
   }

   // Unintrospectable method: fetch_all() / g_match_info_fetch_all()
   // Bundles up pointers to each of the matching substrings from a match
   // and stores them in an array of gchar pointers. The first element in
   // the returned array is the match number 0, i.e. the entire matched
   // text.
   // 
   // If a sub pattern didn't match anything (e.g. sub pattern 1, matching
   // "b" against "(a)?b") then an empty string is inserted.
   // 
   // If the last match was obtained using the DFA algorithm, that is using
   // g_regex_match_all() or g_regex_match_all_full(), the retrieved
   // strings are not that matched by sets of parentheses but that of the
   // matched substring. Substrings are matched in reverse order of length,
   // so the first one is the longest match.
   // 
   // The strings are fetched from the string passed to the match function,
   // so you cannot call this function after freeing the string.
   // 
   // It must be freed using g_strfreev(). If the previous match failed
   // %NULL is returned
   // RETURNS: a %NULL-terminated array of gchar * pointers.
   char** fetch_all() {
      return g_match_info_fetch_all(&this);
   }

   // Retrieves the text matching the capturing parentheses named @name.
   // 
   // If @name is a valid sub pattern name but it didn't match anything
   // (e.g. sub pattern "X", matching "b" against "(?P&lt;X&gt;a)?b")
   // then an empty string is returned.
   // 
   // The string is fetched from the string passed to the match function,
   // so you cannot call this function after freeing the string.
   // 
   // occurred. You have to free the string yourself
   // RETURNS: The matched substring, or %NULL if an error
   // <name>: name of the subexpression
   char* /*new*/ fetch_named(char* name) {
      return g_match_info_fetch_named(&this, name);
   }

   // Retrieves the position in bytes of the capturing parentheses named @name.
   // 
   // If @name is a valid sub pattern name but it didn't match anything
   // (e.g. sub pattern "X", matching "b" against "(?P&lt;X&gt;a)?b")
   // then @start_pos and @end_pos are set to -1 and %TRUE is returned.
   // 
   // If the position cannot be fetched, @start_pos and @end_pos
   // are left unchanged.
   // RETURNS: %TRUE if the position was fetched, %FALSE otherwise.
   // <name>: name of the subexpression
   // <start_pos>: pointer to location where to store the start position, or %NULL
   // <end_pos>: pointer to location where to store the end position, or %NULL
   int fetch_named_pos(char* name, /*out*/ int* start_pos=null, /*out*/ int* end_pos=null) {
      return g_match_info_fetch_named_pos(&this, name, start_pos, end_pos);
   }

   // Retrieves the position in bytes of the @match_num<!-- -->'th capturing
   // parentheses. 0 is the full text of the match, 1 is the first
   // paren set, 2 the second, and so on.
   // 
   // If @match_num is a valid sub pattern but it didn't match anything
   // (e.g. sub pattern 1, matching "b" against "(a)?b") then @start_pos
   // and @end_pos are set to -1 and %TRUE is returned.
   // 
   // If the match was obtained using the DFA algorithm, that is using
   // g_regex_match_all() or g_regex_match_all_full(), the retrieved
   // position is not that of a set of parentheses but that of a matched
   // substring. Substrings are matched in reverse order of length, so
   // 0 is the longest match.
   // 
   // the position cannot be fetched, @start_pos and @end_pos are left
   // unchanged
   // RETURNS: %TRUE if the position was fetched, %FALSE otherwise. If
   // <match_num>: number of the sub expression
   // <start_pos>: pointer to location where to store the start position, or %NULL
   // <end_pos>: pointer to location where to store the end position, or %NULL
   int fetch_pos(int match_num, /*out*/ int* start_pos=null, /*out*/ int* end_pos=null) {
      return g_match_info_fetch_pos(&this, match_num, start_pos, end_pos);
   }

   // If @match_info is not %NULL, calls g_match_info_unref(); otherwise does
   // nothing.
   void free() {
      g_match_info_free(&this);
   }

   // Retrieves the number of matched substrings (including substring 0,
   // that is the whole matched text), so 1 is returned if the pattern
   // has no substrings in it and 0 is returned if the match failed.
   // 
   // If the last match was obtained using the DFA algorithm, that is
   // using g_regex_match_all() or g_regex_match_all_full(), the retrieved
   // count is not that of the number of capturing parentheses but that of
   // the number of matched substrings.
   // RETURNS: Number of matched substrings, or -1 if an error occurred
   int get_match_count() {
      return g_match_info_get_match_count(&this);
   }

   // Returns #GRegex object used in @match_info. It belongs to Glib
   // and must not be freed. Use g_regex_ref() if you need to keep it
   // after you free @match_info object.
   // RETURNS: #GRegex object used in @match_info
   Regex* /*new*/ get_regex() {
      return g_match_info_get_regex(&this);
   }

   // Returns the string searched with @match_info. This is the
   // string passed to g_regex_match() or g_regex_replace() so
   // you may not free it before calling this function.
   // RETURNS: the string searched with @match_info
   char* get_string() {
      return g_match_info_get_string(&this);
   }

   // Usually if the string passed to g_regex_match*() matches as far as
   // it goes, but is too short to match the entire pattern, %FALSE is
   // returned. There are circumstances where it might be helpful to
   // distinguish this case from other cases in which there is no match.
   // 
   // Consider, for example, an application where a human is required to
   // type in data for a field with specific formatting requirements. An
   // example might be a date in the form ddmmmyy, defined by the pattern
   // "^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$".
   // If the application sees the user’s keystrokes one by one, and can
   // check that what has been typed so far is potentially valid, it is
   // able to raise an error as soon as a mistake is made.
   // 
   // GRegex supports the concept of partial matching by means of the
   // #G_REGEX_MATCH_PARTIAL flag. When this is set the return code for
   // g_regex_match() or g_regex_match_full() is, as usual, %TRUE
   // for a complete match, %FALSE otherwise. But, when these functions
   // return %FALSE, you can check if the match was partial calling
   // g_match_info_is_partial_match().
   // 
   // When using partial matching you cannot use g_match_info_fetch*().
   // 
   // Because of the way certain internal optimizations are implemented
   // the partial matching algorithm cannot be used with all patterns.
   // So repeated single characters such as "a{2,4}" and repeated single
   // meta-sequences such as "\d+" are not permitted if the maximum number
   // of occurrences is greater than one. Optional items such as "\d?"
   // (where the maximum is one) are permitted. Quantifiers with any values
   // are permitted after parentheses, so the invalid examples above can be
   // coded thus "(a){2,4}" and "(\d)+". If #G_REGEX_MATCH_PARTIAL is set
   // for a pattern that does not conform to the restrictions, matching
   // functions return an error.
   // RETURNS: %TRUE if the match was partial, %FALSE otherwise
   int is_partial_match() {
      return g_match_info_is_partial_match(&this);
   }

   // Returns whether the previous match operation succeeded.
   // 
   // %FALSE otherwise
   // RETURNS: %TRUE if the previous match operation succeeded,
   int matches() {
      return g_match_info_matches(&this);
   }

   // Scans for the next match using the same parameters of the previous
   // call to g_regex_match_full() or g_regex_match() that returned
   // @match_info.
   // 
   // The match is done on the string passed to the match function, so you
   // cannot free it before calling this function.
   // RETURNS: %TRUE is the string matched, %FALSE otherwise
   int next(GLib2.Error** error=null) {
      return g_match_info_next(&this, error);
   }

   // Increases reference count of @match_info by 1.
   // RETURNS: @match_info
   MatchInfo* /*new*/ ref_() {
      return g_match_info_ref(&this);
   }

   // Decreases reference count of @match_info by 1. When reference count drops
   // to zero, it frees all the memory associated with the match_info structure.
   void unref() {
      g_match_info_unref(&this);
   }
}


// The #GMemChunk struct is an opaque data structure representing a
// memory chunk. It should be accessed only through the use of the
// following functions.
struct MemChunk {

   // Unintrospectable method: alloc() / g_mem_chunk_alloc()
   // Allocates an atom of memory from a #GMemChunk.
   // 
   // Deprecated:2.10: Use g_slice_alloc() instead
   void* alloc() {
      return g_mem_chunk_alloc(&this);
   }

   // Unintrospectable method: alloc0() / g_mem_chunk_alloc0()
   // Allocates an atom of memory from a #GMemChunk, setting the memory to
   // 0.
   // 
   // Deprecated:2.10: Use g_slice_alloc0() instead
   void* alloc0() {
      return g_mem_chunk_alloc0(&this);
   }

   // Frees any blocks in a #GMemChunk which are no longer being used.
   // 
   // Deprecated:2.10: Use the <link linkend="glib-Memory-Slices">slice
   // allocator</link> instead
   void clean() {
      g_mem_chunk_clean(&this);
   }

   // Frees all of the memory allocated for a #GMemChunk.
   // 
   // Deprecated:2.10: Use the <link linkend="glib-Memory-Slices">slice
   // allocator</link> instead
   void destroy() {
      g_mem_chunk_destroy(&this);
   }

   // Frees an atom in a #GMemChunk. This should only be called if the
   // #GMemChunk was created with #G_ALLOC_AND_FREE. Otherwise it will
   // simply return.
   // 
   // Deprecated:2.10: Use g_slice_free1() instead
   // <mem>: a pointer to the atom to free.
   void free(void* mem) {
      g_mem_chunk_free(&this, mem);
   }

   // Outputs debugging information for a #GMemChunk. It outputs the name
   // of the #GMemChunk (set with g_mem_chunk_new()), the number of bytes
   // used, and the number of blocks of memory allocated.
   // 
   // Deprecated:2.10: Use the <link linkend="glib-Memory-Slices">slice
   // allocator</link> instead
   void print() {
      g_mem_chunk_print(&this);
   }

   // Resets a GMemChunk to its initial state. It frees all of the
   // currently allocated blocks of memory.
   // 
   // Deprecated:2.10: Use the <link linkend="glib-Memory-Slices">slice
   // allocator</link> instead
   void reset() {
      g_mem_chunk_reset(&this);
   }

   // Outputs debugging information for all #GMemChunk objects currently
   // in use. It outputs the number of #GMemChunk objects currently
   // allocated, and calls g_mem_chunk_print() to output information on
   // each one.
   // 
   // Deprecated:2.10: Use the <link linkend="glib-Memory-Slices">slice
   // allocator</link> instead
   static void info() {
      g_mem_chunk_info();
   }

   // Unintrospectable function: new() / g_mem_chunk_new()
   // Creates a new #GMemChunk.
   // 
   // Deprecated:2.10: Use the <link linkend="glib-Memory-Slices">slice
   // allocator</link> instead
   // <name>: a string to identify the #GMemChunk. It is not copied so it should be valid for the lifetime of the #GMemChunk. It is only used in g_mem_chunk_print(), which is used for debugging.
   // <atom_size>: the size, in bytes, of each element in the #GMemChunk.
   // <area_size>: the size, in bytes, of each block of memory allocated to contain the atoms.
   // <type>: the type of the #GMemChunk.  #G_ALLOC_AND_FREE is used if the atoms will be freed individually.  #G_ALLOC_ONLY should be used if atoms will never be freed individually. #G_ALLOC_ONLY is quicker, since it does not need to track free atoms, but it obviously wastes memory if you no longer need many of the atoms.
   static MemChunk* new_(char* name, int atom_size, size_t area_size, int type) {
      return g_mem_chunk_new(name, atom_size, area_size, type);
   }
}


// A set of functions used to perform memory allocation. The same #GMemVTable must
// be used for all allocations in the same program; a call to g_mem_set_vtable(),
// if it exists, should be prior to any use of GLib.
struct MemVTable {
   // Unintrospectable functionp: malloc() / ()
   extern (C) void* function (size_t n_bytes) malloc;
   // Unintrospectable functionp: realloc() / ()
   extern (C) void* function (void* mem, size_t n_bytes) realloc;
   extern (C) void function (void* mem) free;
   // Unintrospectable functionp: calloc() / ()
   extern (C) void* function (size_t n_blocks, size_t n_block_bytes) calloc;
   // Unintrospectable functionp: try_malloc() / ()
   extern (C) void* function (size_t n_bytes) try_malloc;
   // Unintrospectable functionp: try_realloc() / ()
   extern (C) void* function (void* mem, size_t n_bytes) try_realloc;
}


// The #GMutex struct is an opaque data structure to represent a mutex
// (mutual exclusion). It can be used to protect data against shared
// access. Take for example the following function:
// 
// <example>
// <title>A function which will not work in a threaded environment</title>
// <programlisting>
// int
// give_me_next_number (void)
// {
// static int current_number = 0;
// 
// /<!-- -->* now do a very complicated calculation to calculate the new
// * number, this might for example be a random number generator
// *<!-- -->/
// current_number = calc_next_number (current_number);
// 
// return current_number;
// }
// </programlisting>
// </example>
// 
// It is easy to see that this won't work in a multi-threaded
// application. There current_number must be protected against shared
// access. A first naive implementation would be:
// 
// <example>
// <title>The wrong way to write a thread-safe function</title>
// <programlisting>
// int
// give_me_next_number (void)
// {
// static int current_number = 0;
// int ret_val;
// static GMutex * mutex = NULL;
// 
// if (!mutex) mutex = g_mutex_new (<!-- -->);
// 
// g_mutex_lock (mutex);
// ret_val = current_number = calc_next_number (current_number);
// g_mutex_unlock (mutex);
// 
// return ret_val;
// }
// </programlisting>
// </example>
// 
// This looks like it would work, but there is a race condition while
// constructing the mutex and this code cannot work reliable. Please do
// not use such constructs in your own programs! One working solution
// is:
// 
// <example>
// <title>A correct thread-safe function</title>
// <programlisting>
// static GMutex *give_me_next_number_mutex = NULL;
// 
// /<!-- -->* this function must be called before any call to
// * give_me_next_number(<!-- -->)
// *
// * it must be called exactly once.
// *<!-- -->/
// void
// init_give_me_next_number (void)
// {
// g_assert (give_me_next_number_mutex == NULL);
// give_me_next_number_mutex = g_mutex_new (<!-- -->);
// }
// 
// int
// give_me_next_number (void)
// {
// static int current_number = 0;
// int ret_val;
// 
// g_mutex_lock (give_me_next_number_mutex);
// ret_val = current_number = calc_next_number (current_number);
// g_mutex_unlock (give_me_next_number_mutex);
// 
// return ret_val;
// }
// </programlisting>
// </example>
// 
// #GStaticMutex provides a simpler and safer way of doing this.
// 
// If you want to use a mutex, and your code should also work without
// calling g_thread_init() first, then you cannot use a #GMutex, as
// g_mutex_new() requires that the thread system be initialized. Use a
// #GStaticMutex instead.
// 
// A #GMutex should only be accessed via the following functions.
// 
// <note><para>All of the <function>g_mutex_*</function> functions are
// actually macros. Apart from taking their addresses, you can however
// use them as if they were functions.</para></note>
struct Mutex {
}


// The #GNode struct represents one node in a
// <link linkend="glib-N-ary-Trees">N-ary Tree</link>. fields
struct Node {
   void* data;
   Node* next, prev, parent, children;


   // Gets the position of the first child of a #GNode
   // which contains the given data.
   // 
   // @data, or -1 if the data is not found
   // RETURNS: the index of the child of @node which contains
   // <data>: the data to find
   int child_index(void* data) {
      return g_node_child_index(&this, data);
   }

   // Gets the position of a #GNode with respect to its siblings.
   // @child must be a child of @node. The first child is numbered 0,
   // the second 1, and so on.
   // RETURNS: the position of @child with respect to its siblings
   // <child>: a child of @node
   int child_position(Node* child) {
      return g_node_child_position(&this, child);
   }

   // Unintrospectable method: children_foreach() / g_node_children_foreach()
   // Calls a function for each of the children of a #GNode.
   // Note that it doesn't descend beneath the child nodes.
   // <flags>: which types of children are to be visited, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
   // <func>: the function to call for each visited node
   // <data>: user data to pass to the function
   void children_foreach(TraverseFlags flags, NodeForeachFunc func, void* data) {
      g_node_children_foreach(&this, flags, func, data);
   }

   // Unintrospectable method: copy() / g_node_copy()
   // Recursively copies a #GNode (but does not deep-copy the data inside the
   // nodes, see g_node_copy_deep() if you need that).
   // RETURNS: a new #GNode containing the same data pointers
   Node* copy() {
      return g_node_copy(&this);
   }

   // Unintrospectable method: copy_deep() / g_node_copy_deep()
   // Recursively copies a #GNode and its data.
   // RETURNS: a new #GNode containing copies of the data in @node.
   // <copy_func>: the function which is called to copy the data inside each node, or %NULL to use the original data.
   // <data>: data to pass to @copy_func
   Node* copy_deep(CopyFunc copy_func, void* data) {
      return g_node_copy_deep(&this, copy_func, data);
   }

   // Gets the depth of a #GNode.
   // 
   // If @node is %NULL the depth is 0. The root node has a depth of 1.
   // For the children of the root node the depth is 2. And so on.
   // RETURNS: the depth of the #GNode
   uint depth() {
      return g_node_depth(&this);
   }

   // Removes @root and its children from the tree, freeing any memory
   // allocated.
   void destroy() {
      g_node_destroy(&this);
   }

   // Unintrospectable method: find() / g_node_find()
   // Finds a #GNode in a tree.
   // RETURNS: the found #GNode, or %NULL if the data is not found
   // <order>: the order in which nodes are visited - %G_IN_ORDER, %G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER
   // <flags>: which types of children are to be searched, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
   // <data>: the data to find
   Node* find(TraverseType order, TraverseFlags flags, void* data) {
      return g_node_find(&this, order, flags, data);
   }

   // Unintrospectable method: find_child() / g_node_find_child()
   // Finds the first child of a #GNode with the given data.
   // RETURNS: the found child #GNode, or %NULL if the data is not found
   // <flags>: which types of children are to be searched, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
   // <data>: the data to find
   Node* find_child(TraverseFlags flags, void* data) {
      return g_node_find_child(&this, flags, data);
   }

   // Unintrospectable method: first_sibling() / g_node_first_sibling()
   // Gets the first sibling of a #GNode.
   // This could possibly be the node itself.
   // RETURNS: the first sibling of @node
   Node* first_sibling() {
      return g_node_first_sibling(&this);
   }

   // Unintrospectable method: get_root() / g_node_get_root()
   // Gets the root of a tree.
   // RETURNS: the root of the tree
   Node* get_root() {
      return g_node_get_root(&this);
   }

   // Unintrospectable method: insert() / g_node_insert()
   // Inserts a #GNode beneath the parent at the given position.
   // RETURNS: the inserted #GNode
   // <position>: the position to place @node at, with respect to its siblings If position is -1, @node is inserted as the last child of @parent
   // <node>: the #GNode to insert
   Node* insert(int position, Node* node) {
      return g_node_insert(&this, position, node);
   }

   // Unintrospectable method: insert_after() / g_node_insert_after()
   // Inserts a #GNode beneath the parent after the given sibling.
   // RETURNS: the inserted #GNode
   // <sibling>: the sibling #GNode to place @node after. If sibling is %NULL, the node is inserted as the first child of @parent.
   // <node>: the #GNode to insert
   Node* insert_after(Node* sibling, Node* node) {
      return g_node_insert_after(&this, sibling, node);
   }

   // Unintrospectable method: insert_before() / g_node_insert_before()
   // Inserts a #GNode beneath the parent before the given sibling.
   // RETURNS: the inserted #GNode
   // <sibling>: the sibling #GNode to place @node before. If sibling is %NULL, the node is inserted as the last child of @parent.
   // <node>: the #GNode to insert
   Node* insert_before(Node* sibling, Node* node) {
      return g_node_insert_before(&this, sibling, node);
   }

   // Returns %TRUE if @node is an ancestor of @descendant.
   // This is true if node is the parent of @descendant,
   // or if node is the grandparent of @descendant etc.
   // RETURNS: %TRUE if @node is an ancestor of @descendant
   // <descendant>: a #GNode
   int is_ancestor(Node* descendant) {
      return g_node_is_ancestor(&this, descendant);
   }

   // Unintrospectable method: last_child() / g_node_last_child()
   // Gets the last child of a #GNode.
   // RETURNS: the last child of @node, or %NULL if @node has no children
   Node* last_child() {
      return g_node_last_child(&this);
   }

   // Unintrospectable method: last_sibling() / g_node_last_sibling()
   // Gets the last sibling of a #GNode.
   // This could possibly be the node itself.
   // RETURNS: the last sibling of @node
   Node* last_sibling() {
      return g_node_last_sibling(&this);
   }

   // Gets the maximum height of all branches beneath a #GNode.
   // This is the maximum distance from the #GNode to all leaf nodes.
   // 
   // If @root is %NULL, 0 is returned. If @root has no children,
   // 1 is returned. If @root has children, 2 is returned. And so on.
   // RETURNS: the maximum height of the tree beneath @root
   uint max_height() {
      return g_node_max_height(&this);
   }

   // Gets the number of children of a #GNode.
   // RETURNS: the number of children of @node
   uint n_children() {
      return g_node_n_children(&this);
   }

   // Gets the number of nodes in a tree.
   // RETURNS: the number of nodes in the tree
   // <flags>: which types of children are to be counted, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
   uint n_nodes(TraverseFlags flags) {
      return g_node_n_nodes(&this, flags);
   }

   // Unintrospectable method: nth_child() / g_node_nth_child()
   // Gets a child of a #GNode, using the given index.
   // The first child is at index 0. If the index is
   // too big, %NULL is returned.
   // RETURNS: the child of @node at index @n
   // <n>: the index of the desired child
   Node* nth_child(uint n) {
      return g_node_nth_child(&this, n);
   }

   // Unintrospectable method: prepend() / g_node_prepend()
   // Inserts a #GNode as the first child of the given parent.
   // RETURNS: the inserted #GNode
   // <node>: the #GNode to insert
   Node* prepend(Node* node) {
      return g_node_prepend(&this, node);
   }

   // Reverses the order of the children of a #GNode.
   // (It doesn't change the order of the grandchildren.)
   void reverse_children() {
      g_node_reverse_children(&this);
   }

   // Unintrospectable method: traverse() / g_node_traverse()
   // Traverses a tree starting at the given root #GNode.
   // It calls the given function for each node visited.
   // The traversal can be halted at any point by returning %TRUE from @func.
   // <order>: the order in which nodes are visited - %G_IN_ORDER, %G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER.
   // <flags>: which types of children are to be visited, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
   // <max_depth>: the maximum depth of the traversal. Nodes below this depth will not be visited. If max_depth is -1 all nodes in the tree are visited. If depth is 1, only the root is visited. If depth is 2, the root and its children are visited. And so on.
   // <func>: the function to call for each visited #GNode
   // <data>: user data to pass to the function
   void traverse(TraverseType order, TraverseFlags flags, int max_depth, NodeTraverseFunc func, void* data) {
      g_node_traverse(&this, order, flags, max_depth, func, data);
   }
   // Unlinks a #GNode from a tree, resulting in two separate trees.
   void unlink() {
      g_node_unlink(&this);
   }

   // Unintrospectable function: new() / g_node_new()
   // Creates a new #GNode containing the given data.
   // Used to create the first node in a tree.
   // RETURNS: a new #GNode
   // <data>: the data of the new node
   static Node* new_(void* data) {
      return g_node_new(data);
   }

   // Restores the previous #GAllocator, used when allocating #GNode
   // elements.
   // 
   // Note that this function is not available if GLib has been compiled
   // with <option>--disable-mem-pools</option>
   // 
   // Deprecated:2.10: It does nothing, since #GNode has been converted to
   // the <link linkend="glib-Memory-Slices">slice
   // allocator</link>
   static void pop_allocator() {
      g_node_pop_allocator();
   }

   // Sets the allocator to use to allocate #GNode elements. Use
   // g_node_pop_allocator() to restore the previous allocator.
   // 
   // Note that this function is not available if GLib has been compiled
   // with <option>--disable-mem-pools</option>
   // 
   // Deprecated:2.10: It does nothing, since #GNode has been converted to
   // the <link linkend="glib-Memory-Slices">slice
   // allocator</link>
   // <dummy>: the #GAllocator to use when allocating #GNode elements.
   static void push_allocator(void* dummy) {
      g_node_push_allocator(dummy);
   }
}


// 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().
// <node>: a #GNode.
// <data>: user data passed to g_node_children_foreach().
extern (C) alias void function (Node* node, void* data) NodeForeachFunc;


// 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.
// <node>: a #GNode.
// <data>: user data passed to g_node_traverse().
extern (C) alias int function (Node* node, void* data) NodeTraverseFunc;


// Defines how a Unicode string is transformed in a 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. Unicode strings
// should generally be normalized before comparing them.
enum NormalizeMode {
   DEFAULT = 0,
   NFD = 0,
   DEFAULT_COMPOSE = 1,
   NFC = 1,
   ALL = 2,
   NFKD = 2,
   ALL_COMPOSE = 3,
   NFKC = 3
}
enum OPTION_REMAINING = "";

// A #GOnce struct controls a one-time initialization function. Any
// one-time initialization function must have its own unique #GOnce
// struct.
struct Once /* Version 2.4 */ {
   OnceStatus status;
   void* retval;

   // Unintrospectable method: impl() / g_once_impl()
   void* impl(ThreadFunc func, void* arg) {
      return g_once_impl(&this, func, arg);
   }

   // Function to be called when starting a critical initialization
   // section. The argument @value_location must point to a static
   // 0-initialized variable that will be set to a value other than 0 at
   // the end of the initialization section. In combination with
   // g_once_init_leave() and the unique address @value_location, it can
   // be ensured that an initialization section will be executed only once
   // during a program's life time, and that concurrent threads are
   // blocked until initialization completed. To be used in constructs
   // like this:
   // 
   // <informalexample>
   // <programlisting>
   // static gsize initialization_value = 0;
   // 
   // if (g_once_init_enter (&amp;initialization_value))
   // {
   // gsize setup_value = 42; /<!-- -->* initialization code here *<!-- -->/
   // 
   // g_once_init_leave (&amp;initialization_value, setup_value);
   // }
   // 
   // /<!-- -->* use initialization_value here *<!-- -->/
   // </programlisting>
   // </informalexample>
   // <value_location>: location of a static initializable variable containing 0.
   static int init_enter(size_t* value_location) {
      return g_once_init_enter(value_location);
   }
   static int init_enter_impl(size_t* value_location) {
      return g_once_init_enter_impl(value_location);
   }

   // 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.
   // <value_location>: location of a static initializable variable containing 0.
   // <initialization_value>: new non-0 value for *@value_location.
   static void init_leave(size_t* value_location, size_t initialization_value) {
      g_once_init_leave(value_location, initialization_value);
   }
}


// The possible statuses of a one-time initialization function
// controlled by a #GOnce struct.
enum OnceStatus /* Version 2.4 */ {
   NOTCALLED = 0,
   PROGRESS = 1,
   READY = 2
}

// The #GOptionArg enum values determine which type of extra argument the
// options expect to find. If an option expects an extra argument, it
// can be specified in several ways; with a short option:
// <option>-x arg</option>, with a long option: <option>--name arg</option>
// or combined in a single argument: <option>--name=arg</option>.
enum OptionArg {
   NONE = 0,
   STRING = 1,
   INT = 2,
   CALLBACK = 3,
   FILENAME = 4,
   STRING_ARRAY = 5,
   FILENAME_ARRAY = 6,
   DOUBLE = 7,
   INT64 = 8
}

// The type of function to be passed as callback for %G_OPTION_ARG_CALLBACK
// options.
// 
// occurred, in which case @error should be set with g_set_error()
// RETURNS: %TRUE if the option was successfully parsed, %FALSE if an error
// <option_name>: The name of the option being parsed. This will be either a single dash followed by a single letter (for a short name) or two dashes followed by a long option name.
// <value>: The value to be parsed.
// <data>: User data added to the #GOptionGroup containing the option when it was created with g_option_group_new()
extern (C) alias int function (char* option_name, char* value, void* data, GLib2.Error** error=null) OptionArgFunc;


// A <structname>GOptionContext</structname> struct defines which options
// are accepted by the commandline option parser. The struct has only private 
// fields and should not be directly accessed.
struct OptionContext {

   // Adds a #GOptionGroup to the @context, so that parsing with @context
   // will recognize the options in the group. Note that the group will
   // be freed together with the context when g_option_context_free() is
   // called, so you must not free the group yourself after adding it
   // to a context.
   // <group>: the group to add
   void add_group(OptionGroup* group) {
      g_option_context_add_group(&this, group);
   }

   // A convenience function which creates a main group if it doesn't
   // exist, adds the @entries to it and sets the translation domain.
   // <entries>: a %NULL-terminated array of #GOptionEntry<!-- -->s
   // <translation_domain>: a translation domain to use for translating the <option>--help</option> output for the options in @entries with gettext(), or %NULL
   void add_main_entries(OptionEntry* entries, char* translation_domain) {
      g_option_context_add_main_entries(&this, entries, translation_domain);
   }

   // Frees context and all the groups which have been
   // added to it.
   // 
   // Please note that parsed arguments need to be freed separately (see
   // #GOptionEntry).
   void free() {
      g_option_context_free(&this);
   }

   // Returns the description. See g_option_context_set_description().
   // RETURNS: the description
   char* get_description() {
      return g_option_context_get_description(&this);
   }

   // Returns a formatted, translated help text for the given context.
   // To obtain the text produced by <option>--help</option>, call
   // <literal>g_option_context_get_help (context, TRUE, NULL)</literal>.
   // To obtain the text produced by <option>--help-all</option>, call
   // <literal>g_option_context_get_help (context, FALSE, NULL)</literal>.
   // To obtain the help text for an option group, call
   // <literal>g_option_context_get_help (context, FALSE, group)</literal>.
   // RETURNS: A newly allocated string containing the help text
   // <main_help>: if %TRUE, only include the main group
   // <group>: the #GOptionGroup to create help for, or %NULL
   char* /*new*/ get_help(int main_help, OptionGroup* group) {
      return g_option_context_get_help(&this, main_help, group);
   }

   // Returns whether automatic <option>--help</option> generation
   // is turned on for @context. See g_option_context_set_help_enabled().
   // RETURNS: %TRUE if automatic help generation is turned on.
   int get_help_enabled() {
      return g_option_context_get_help_enabled(&this);
   }

   // Returns whether unknown options are ignored or not. See
   // g_option_context_set_ignore_unknown_options().
   // RETURNS: %TRUE if unknown options are ignored.
   int get_ignore_unknown_options() {
      return g_option_context_get_ignore_unknown_options(&this);
   }

   // Unintrospectable method: get_main_group() / g_option_context_get_main_group()
   // Returns a pointer to the main group of @context.
   // 
   // have a main group. Note that group belongs to @context and should
   // not be modified or freed.
   // RETURNS: the main group of @context, or %NULL if @context doesn't
   OptionGroup* get_main_group() {
      return g_option_context_get_main_group(&this);
   }

   // Returns the summary. See g_option_context_set_summary().
   // RETURNS: the summary
   char* get_summary() {
      return g_option_context_get_summary(&this);
   }

   // Parses the command line arguments, recognizing options
   // which have been added to @context. A side-effect of
   // calling this function is that g_set_prgname() will be
   // called.
   // 
   // If the parsing is successful, any parsed arguments are
   // removed from the array and @argc and @argv are updated
   // accordingly. A '--' option is stripped from @argv
   // unless there are unparsed options before and after it,
   // or some of the options after it start with '-'. In case
   // of an error, @argc and @argv are left unmodified.
   // 
   // If automatic <option>--help</option> support is enabled
   // (see g_option_context_set_help_enabled()), and the
   // @argv array contains one of the recognized help options,
   // this function will produce help output to stdout and
   // call <literal>exit (0)</literal>.
   // 
   // Note that function depends on the
   // <link linkend="setlocale">current locale</link> for
   // automatic character set conversion of string and filename
   // arguments.
   // 
   // %FALSE if an error occurred
   // RETURNS: %TRUE if the parsing was successful,
   // <argc>: a pointer to the number of command line arguments
   // <argv>: a pointer to the array of command line arguments
   int parse(/*inout*/ int* argc, /*inout*/ char*** argv, GLib2.Error** error=null) {
      return g_option_context_parse(&this, argc, argv, error);
   }

   // Adds a string to be displayed in <option>--help</option> output
   // after the list of options. This text often includes a bug reporting
   // address.
   // 
   // Note that the summary is translated (see
   // g_option_context_set_translate_func()).
   // <description>: a string to be shown in <option>--help</option> output after the list of options, or %NULL
   void set_description(char* description) {
      g_option_context_set_description(&this, description);
   }

   // Enables or disables automatic generation of <option>--help</option>
   // output. By default, g_option_context_parse() recognizes
   // <option>--help</option>, <option>-h</option>,
   // <option>-?</option>, <option>--help-all</option>
   // and <option>--help-</option><replaceable>groupname</replaceable> and creates
   // suitable output to stdout.
   // <help_enabled>: %TRUE to enable <option>--help</option>, %FALSE to disable it
   void set_help_enabled(int help_enabled) {
      g_option_context_set_help_enabled(&this, help_enabled);
   }

   // Sets whether to ignore unknown options or not. If an argument is
   // ignored, it is left in the @argv array after parsing. By default,
   // g_option_context_parse() treats unknown options as error.
   // 
   // This setting does not affect non-option arguments (i.e. arguments
   // which don't start with a dash). But note that GOption cannot reliably
   // determine whether a non-option belongs to a preceding unknown option.
   // <ignore_unknown>: %TRUE to ignore unknown options, %FALSE to produce an error when unknown options are met
   void set_ignore_unknown_options(int ignore_unknown) {
      g_option_context_set_ignore_unknown_options(&this, ignore_unknown);
   }

   // Sets a #GOptionGroup as main group of the @context.
   // This has the same effect as calling g_option_context_add_group(),
   // the only difference is that the options in the main group are
   // treated differently when generating <option>--help</option> output.
   // <group>: the group to set as main group
   void set_main_group(OptionGroup* group) {
      g_option_context_set_main_group(&this, group);
   }

   // Adds a string to be displayed in <option>--help</option> output
   // before the list of options. This is typically a summary of the
   // program functionality.
   // 
   // Note that the summary is translated (see
   // g_option_context_set_translate_func() and
   // g_option_context_set_translation_domain()).
   // <summary>: a string to be shown in <option>--help</option> output before the list of options, or %NULL
   void set_summary(char* summary) {
      g_option_context_set_summary(&this, summary);
   }

   // Sets the function which is used to translate the contexts
   // user-visible strings, for <option>--help</option> output.
   // If @func is %NULL, strings are not translated.
   // 
   // Note that option groups have their own translation functions,
   // this function only affects the @parameter_string (see g_option_context_new()),
   // the summary (see g_option_context_set_summary()) and the description
   // (see g_option_context_set_description()).
   // 
   // If you are using gettext(), you only need to set the translation
   // domain, see g_option_context_set_translation_domain().
   // <func>: the #GTranslateFunc, or %NULL
   // <data>: user data to pass to @func, or %NULL
   // <destroy_notify>: a function which gets called to free @data, or %NULL
   void set_translate_func(TranslateFunc func, void* data, DestroyNotify destroy_notify) {
      g_option_context_set_translate_func(&this, func, data, destroy_notify);
   }

   // A convenience function to use gettext() for translating
   // user-visible strings.
   // <domain>: the domain to use
   void set_translation_domain(char* domain) {
      g_option_context_set_translation_domain(&this, domain);
   }

   // Unintrospectable function: new() / g_option_context_new()
   // Creates a new option context.
   // 
   // The @parameter_string can serve multiple purposes. It can be used
   // to add descriptions for "rest" arguments, which are not parsed by
   // the #GOptionContext, typically something like "FILES" or
   // "FILE1 FILE2...". If you are using #G_OPTION_REMAINING for
   // collecting "rest" arguments, GLib handles this automatically by
   // using the @arg_description of the corresponding #GOptionEntry in
   // the usage summary.
   // 
   // Another usage is to give a short summary of the program
   // functionality, like " - frob the strings", which will be displayed
   // in the same line as the usage. For a longer description of the
   // program functionality that should be displayed as a paragraph
   // below the usage line, use g_option_context_set_summary().
   // 
   // Note that the @parameter_string is translated using the
   // function set with g_option_context_set_translate_func(), so
   // it should normally be passed untranslated.
   // 
   // freed with g_option_context_free() after use.
   // RETURNS: a newly created #GOptionContext, which must be
   // <parameter_string>: a string which is displayed in the first line of <option>--help</option> output, after the usage summary <literal><replaceable>programname</replaceable> [OPTION...]</literal>
   static OptionContext* new_(char* parameter_string) {
      return g_option_context_new(parameter_string);
   }
}


// A <structname>GOptionEntry</structname> defines a single option.
// To have an effect, they must be added to a #GOptionGroup with
// g_option_context_add_main_entries() or g_option_group_add_entries().
struct OptionEntry {
   char* long_name;
   char short_name;
   int flags;
   OptionArg arg;
   void* arg_data;
   char* description, arg_description;
}

// Error codes returned by option parsing.
enum OptionError {
   UNKNOWN_OPTION = 0,
   BAD_VALUE = 1,
   FAILED = 2
}

// The type of function to be used as callback when a parse error occurs.
// <context>: The active #GOptionContext
// <group>: The group to which the function belongs
// <data>: User data added to the #GOptionGroup containing the option when it was created with g_option_group_new()
extern (C) alias void function (OptionContext* context, OptionGroup* group, void* data, GLib2.Error** error=null) OptionErrorFunc;

// Flags which modify individual options.
enum OptionFlags {
   HIDDEN = 1,
   IN_MAIN = 2,
   REVERSE = 4,
   NO_ARG = 8,
   FILENAME = 16,
   OPTIONAL_ARG = 32,
   NOALIAS = 64
}

// A <structname>GOptionGroup</structname> struct defines the options in a single
// group. The struct has only private fields and should not be directly accessed.
// 
// All options in a group share the same translation function. Libraries which
// need to parse commandline options are expected to provide a function for
// getting a <structname>GOptionGroup</structname> holding their options, which
// the application can then add to its #GOptionContext.
struct OptionGroup {

   // Adds the options specified in @entries to @group.
   // <entries>: a %NULL-terminated array of #GOptionEntry<!-- -->s
   void add_entries(OptionEntry* entries) {
      g_option_group_add_entries(&this, entries);
   }

   // Frees a #GOptionGroup. Note that you must <emphasis>not</emphasis>
   // free groups which have been added to a #GOptionContext.
   void free() {
      g_option_group_free(&this);
   }

   // Unintrospectable method: set_error_hook() / g_option_group_set_error_hook()
   // Associates a function with @group which will be called
   // from g_option_context_parse() when an error occurs.
   // 
   // Note that the user data to be passed to @error_func can be
   // specified when constructing the group with g_option_group_new().
   // <error_func>: a function to call when an error occurs
   void set_error_hook(OptionErrorFunc error_func) {
      g_option_group_set_error_hook(&this, error_func);
   }

   // Unintrospectable method: set_parse_hooks() / g_option_group_set_parse_hooks()
   // Associates two functions with @group which will be called
   // from g_option_context_parse() before the first option is parsed
   // and after the last option has been parsed, respectively.
   // 
   // Note that the user data to be passed to @pre_parse_func and
   // @post_parse_func can be specified when constructing the group
   // with g_option_group_new().
   // <pre_parse_func>: a function to call before parsing, or %NULL
   // <post_parse_func>: a function to call after parsing, or %NULL
   void set_parse_hooks(OptionParseFunc pre_parse_func, OptionParseFunc post_parse_func) {
      g_option_group_set_parse_hooks(&this, pre_parse_func, post_parse_func);
   }

   // Sets the function which is used to translate user-visible
   // strings, for <option>--help</option> output. Different
   // groups can use different #GTranslateFunc<!-- -->s. If @func
   // is %NULL, strings are not translated.
   // 
   // If you are using gettext(), you only need to set the translation
   // domain, see g_option_group_set_translation_domain().
   // <func>: the #GTranslateFunc, or %NULL
   // <data>: user data to pass to @func, or %NULL
   // <destroy_notify>: a function which gets called to free @data, or %NULL
   void set_translate_func(TranslateFunc func, void* data, DestroyNotify destroy_notify) {
      g_option_group_set_translate_func(&this, func, data, destroy_notify);
   }

   // A convenience function to use gettext() for translating
   // user-visible strings.
   // <domain>: the domain to use
   void set_translation_domain(char* domain) {
      g_option_group_set_translation_domain(&this, domain);
   }

   // Unintrospectable function: new() / g_option_group_new()
   // Creates a new #GOptionGroup.
   // 
   // to a #GOptionContext or freed with g_option_group_free().
   // RETURNS: a newly created option group. It should be added
   // <name>: the name for the option group, this is used to provide help for the options in this group with <option>--help-</option>@name
   // <description>: a description for this group to be shown in <option>--help</option>. This string is translated using the translation domain or translation function of the group
   // <help_description>: a description for the <option>--help-</option>@name option. This string is translated using the translation domain or translation function of the group
   // <user_data>: user data that will be passed to the pre- and post-parse hooks, the error hook and to callbacks of %G_OPTION_ARG_CALLBACK options, or %NULL
   // <destroy>: a function that will be called to free @user_data, or %NULL
   static OptionGroup* new_(char* name, char* description, char* help_description, void* user_data, DestroyNotify destroy) {
      return g_option_group_new(name, description, help_description, user_data, destroy);
   }
}


// The type of function that can be called before and after parsing. 
// 
// occurred, in which case @error should be set with g_set_error()
// RETURNS: %TRUE if the function completed successfully, %FALSE if an error
// <context>: The active #GOptionContext
// <group>: The group to which the function belongs
// <data>: User data added to the #GOptionGroup containing the option when it was created with g_option_group_new()
extern (C) alias int function (OptionContext* context, OptionGroup* group, void* data, GLib2.Error** error=null) OptionParseFunc;

enum int PDP_ENDIAN = 3412;
enum double PI = 3.141593;
enum double PI_2 = 1.570796;
enum double PI_4 = 0.785398;
enum POLLFD_FORMAT = "%#I64x";
enum int PRIORITY_DEFAULT = 0;
enum int PRIORITY_DEFAULT_IDLE = 200;
enum int PRIORITY_HIGH = -100;
enum int PRIORITY_HIGH_IDLE = 100;
enum int PRIORITY_LOW = 300;

// A <structname>GPatternSpec</structname> is the 'compiled' form of a
// pattern. This structure is opaque and its fields cannot be accessed
// directly.
struct PatternSpec {

   // Compares two compiled pattern specs and returns whether they will
   // match the same set of strings.
   // <pspec2>: another #GPatternSpec
   int equal(PatternSpec* pspec2) {
      return g_pattern_spec_equal(&this, pspec2);
   }
   // Frees the memory allocated for the #GPatternSpec.
   void free() {
      g_pattern_spec_free(&this);
   }

   // Unintrospectable function: new() / g_pattern_spec_new()
   // Compiles a pattern to a #GPatternSpec.
   // <pattern>: a zero-terminated UTF-8 encoded string
   static PatternSpec* new_(char* pattern) {
      return g_pattern_spec_new(pattern);
   }
}

struct PollFD {
   int fd;
   ushort events, revents;
}


// 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.
// 
// reported, or -1 if an error occurred.
// RETURNS: the number of #GPollFD elements which have events or errors
// <ufds>: an array of #GPollFD elements
// <nfsd>: the number of elements in @ufds
// <timeout_>: the maximum time to wait for an event of the file descriptors. A negative value indicates an infinite timeout.
extern (C) alias int function (PollFD* ufds, uint nfsd, int timeout_) PollFunc;


// Specifies the type of the print handler functions.
// These are called with the complete formatted string to output.
// <string>: the message to output
extern (C) alias void function (char* string_) PrintFunc;


// <note><para>
// #GStaticPrivate is a better choice for most uses.
// </para></note>
// 
// The #GPrivate struct is an opaque data structure to represent a
// thread private data key. Threads can thereby obtain and set a
// pointer which is private to the current thread. Take our
// <function>give_me_next_number(<!-- -->)</function> example from
// above.  Suppose we don't want <literal>current_number</literal> to be
// shared between the threads, but instead to be private to each thread.
// This can be done as follows:
// 
// <example>
// <title>Using GPrivate for per-thread data</title>
// <programlisting>
// GPrivate* current_number_key = NULL; /<!-- -->* Must be initialized somewhere
// with g_private_new (g_free); *<!-- -->/
// 
// int
// give_me_next_number (void)
// {
// int *current_number = g_private_get (current_number_key);
// 
// if (!current_number)
// {
// current_number = g_new (int, 1);
// *current_number = 0;
// g_private_set (current_number_key, current_number);
// }
// 
// *current_number = calc_next_number (*current_number);
// 
// return *current_number;
// }
// </programlisting>
// </example>
// 
// Here the pointer belonging to the key
// <literal>current_number_key</literal> is read. If it is %NULL, it has
// not been set yet. Then get memory for an integer value, assign this
// memory to the pointer and write the pointer back. Now we have an
// integer value that is private to the current thread.
// 
// The #GPrivate struct should only be accessed via the following
// functions.
// 
// <note><para>All of the <function>g_private_*</function> functions are
// actually macros. Apart from taking their addresses, you can however
// use them as if they were functions.</para></note>
struct Private {
}

// Contains the public fields of a pointer array.
struct PtrArray {
   void** pdata;
   uint len;


   // Adds a pointer to the end of the pointer array. The array will grow
   // in size automatically if necessary.
   // <array>: a #GPtrArray.
   // <data>: the pointer to add.
   static void add(PtrArray* array, void* data) {
      g_ptr_array_add(array, data);
   }

   // Unintrospectable function: foreach() / g_ptr_array_foreach()
   // Calls a function for each element of a #GPtrArray.
   // <array>: a #GPtrArray
   // <func>: the function to call for each array element
   // <user_data>: user data to pass to the function
   static void foreach_(PtrArray* array, Func func, void* user_data) {
      g_ptr_array_foreach(array, func, user_data);
   }

   // Unintrospectable function: free() / g_ptr_array_free()
   // Frees the memory allocated for the #GPtrArray. If @free_seg is %TRUE
   // it frees the memory block holding the elements as well. Pass %FALSE
   // if you want to free the #GPtrArray wrapper but preserve the
   // underlying array for use elsewhere. If the reference count of @array
   // is greater than one, the #GPtrArray wrapper is preserved but the
   // size of @array will be set to zero.
   // 
   // <note><para>If array contents point to dynamically-allocated
   // memory, they should be freed separately if @free_seg is %TRUE and no
   // #GDestroyNotify function has been set for @array.</para></note>
   // <array>: a #GPtrArray.
   // <free_seg>: if %TRUE the actual pointer array is freed as well.
   static void** free(PtrArray* array, int free_seg) {
      return g_ptr_array_free(array, free_seg);
   }

   // Unintrospectable function: new() / g_ptr_array_new()
   // Creates a new #GPtrArray with a reference count of 1.
   static PtrArray* new_() {
      return g_ptr_array_new();
   }

   // Unintrospectable function: new_full() / g_ptr_array_new_full()
   // Creates a new #GPtrArray with @reserved_size pointers preallocated
   // and a reference count of 1. This avoids frequent reallocation, if
   // you are going to add many pointers to the array. Note however that
   // the size of the array is still 0. It also set @element_free_func
   // for freeing each element when the array is destroyed either via
   // g_ptr_array_unref(), when g_ptr_array_free() is called with @free_segment
   // set to %TRUE or when removing elements.
   // RETURNS: A new #GPtrArray.
   // <reserved_size>: number of pointers preallocated.
   // <element_free_func>: A function to free elements with destroy @array or %NULL.
   static PtrArray* new_full(uint reserved_size, DestroyNotify element_free_func) {
      return g_ptr_array_new_full(reserved_size, element_free_func);
   }

   // Unintrospectable function: new_with_free_func() / g_ptr_array_new_with_free_func()
   // Creates a new #GPtrArray with a reference count of 1 and use @element_free_func
   // for freeing each element when the array is destroyed either via
   // g_ptr_array_unref(), when g_ptr_array_free() is called with @free_segment
   // set to %TRUE or when removing elements.
   // RETURNS: A new #GPtrArray.
   // <element_free_func>: A function to free elements with destroy @array or %NULL.
   static PtrArray* new_with_free_func(DestroyNotify element_free_func) {
      return g_ptr_array_new_with_free_func(element_free_func);
   }

   // Unintrospectable function: ref() / g_ptr_array_ref()
   // Atomically increments the reference count of @array by one. This
   // function is MT-safe and may be called from any thread.
   // RETURNS: The passed in #GPtrArray.
   // <array>: A #GArray.
   static PtrArray* ref_(PtrArray* array) {
      return g_ptr_array_ref(array);
   }

   // Removes the first occurrence of the given pointer from the pointer
   // array. The following elements are moved down one place. If @array
   // has a non-%NULL #GDestroyNotify function it is called for the
   // removed element.
   // 
   // It returns %TRUE if the pointer was removed, or %FALSE if the
   // pointer was not found.
   // <array>: a #GPtrArray.
   // <data>: the pointer to remove.
   static int remove(PtrArray* array, void* data) {
      return g_ptr_array_remove(array, data);
   }

   // Removes the first occurrence of the given pointer from the pointer
   // array. The last element in the array is used to fill in the space,
   // so this function does not preserve the order of the array. But it is
   // faster than g_ptr_array_remove(). If @array has a non-%NULL
   // #GDestroyNotify function it is called for the removed element.
   // 
   // It returns %TRUE if the pointer was removed, or %FALSE if the
   // pointer was not found.
   // <array>: a #GPtrArray.
   // <data>: the pointer to remove.
   static int remove_fast(PtrArray* array, void* data) {
      return g_ptr_array_remove_fast(array, data);
   }

   // Unintrospectable function: remove_index() / g_ptr_array_remove_index()
   // Removes the pointer at the given index from the pointer array. The
   // following elements are moved down one place. If @array has a
   // non-%NULL #GDestroyNotify function it is called for the removed
   // element.
   // <array>: a #GPtrArray.
   // <index_>: the index of the pointer to remove.
   static void* remove_index(PtrArray* array, uint index_) {
      return g_ptr_array_remove_index(array, index_);
   }

   // Unintrospectable function: remove_index_fast() / g_ptr_array_remove_index_fast()
   // Removes the pointer at the given index from the pointer array. The
   // last element in the array is used to fill in the space, so this
   // function does not preserve the order of the array. But it is faster
   // than g_ptr_array_remove_index(). If @array has a non-%NULL
   // #GDestroyNotify function it is called for the removed element.
   // <array>: a #GPtrArray.
   // <index_>: the index of the pointer to remove.
   static void* remove_index_fast(PtrArray* array, uint index_) {
      return g_ptr_array_remove_index_fast(array, index_);
   }

   // Removes the given number of pointers starting at the given index
   // from a #GPtrArray.  The following elements are moved to close the
   // gap. If @array has a non-%NULL #GDestroyNotify function it is called
   // for the removed elements.
   // <array>: a @GPtrArray.
   // <index_>: the index of the first pointer to remove.
   // <length>: the number of pointers to remove.
   static void remove_range(PtrArray* array, uint index_, uint length) {
      g_ptr_array_remove_range(array, index_, length);
   }

   // Sets a function for freeing each element when @array is destroyed
   // either via g_ptr_array_unref(), when g_ptr_array_free() is called
   // with @free_segment set to %TRUE or when removing elements.
   // <array>: A #GPtrArray.
   // <element_free_func>: A function to free elements with destroy @array or %NULL.
   static void set_free_func(PtrArray* array, DestroyNotify element_free_func) {
      g_ptr_array_set_free_func(array, element_free_func);
   }

   // Sets the size of the array. When making the array larger,
   // newly-added elements will be set to %NULL. When making it smaller,
   // if @array has a non-%NULL #GDestroyNotify function then it will be
   // called for the removed elements.
   // <array>: a #GPtrArray.
   // <length>: the new length of the pointer array.
   static void set_size(PtrArray* array, int length) {
      g_ptr_array_set_size(array, length);
   }

   // Unintrospectable function: sized_new() / g_ptr_array_sized_new()
   // Creates a new #GPtrArray with @reserved_size pointers preallocated
   // and a reference count of 1. This avoids frequent reallocation, if
   // you are going to add many pointers to the array. Note however that
   // the size of the array is still 0.
   // <reserved_size>: number of pointers preallocated.
   static PtrArray* sized_new(uint reserved_size) {
      return g_ptr_array_sized_new(reserved_size);
   }

   // Unintrospectable function: sort() / g_ptr_array_sort()
   // Sorts the 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 irst 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 &#8211; i.e.
   // you want a stable sort &#8211; you can write a comparison function that,
   // if two elements would otherwise compare equal, compares them by
   // their addresses.
   // 
   // <note><para>The comparison function for g_ptr_array_sort() doesn't
   // take the pointers from the array as arguments, it takes pointers to
   // the pointers in the array.</para></note>
   // <array>: a #GPtrArray.
   // <compare_func>: comparison function.
   static void sort(PtrArray* array, CompareFunc compare_func) {
      g_ptr_array_sort(array, compare_func);
   }

   // Unintrospectable function: sort_with_data() / g_ptr_array_sort_with_data()
   // Like g_ptr_array_sort(), but the comparison function has an extra
   // user data argument.
   // 
   // <note><para>The comparison function for g_ptr_array_sort_with_data()
   // doesn't take the pointers from the array as arguments, it takes
   // pointers to the pointers in the array.</para></note>
   // <array>: a #GPtrArray.
   // <compare_func>: comparison function.
   // <user_data>: data to pass to @compare_func.
   static void sort_with_data(PtrArray* array, CompareDataFunc compare_func, void* user_data) {
      g_ptr_array_sort_with_data(array, compare_func, user_data);
   }

   // Atomically decrements the reference count of @array by one. If the
   // reference count drops to 0, the effect is the same as calling
   // g_ptr_array_free() with @free_segment set to %TRUE. This function
   // is MT-safe and may be called from any thread.
   // <array>: A #GPtrArray.
   static void unref(PtrArray* array) {
      g_ptr_array_unref(array);
   }
}


// Contains the public fields of a
// <link linkend="glib-Double-ended-Queues">Queue</link>.
struct Queue {
   GLib2.List* head, tail;
   uint length;


   // Removes all the elements in @queue. If queue elements contain
   // dynamically-allocated memory, they should be freed first.
   void clear() {
      g_queue_clear(&this);
   }

   // Unintrospectable method: copy() / g_queue_copy()
   // Copies a @queue. Note that is a shallow copy. If the elements in the
   // queue consist of pointers to data, the pointers are copied, but the
   // actual data is not.
   // RETURNS: A copy of @queue
   Queue* copy() {
      return g_queue_copy(&this);
   }

   // Unintrospectable method: delete_link() / g_queue_delete_link()
   // Removes @link_ from @queue and frees it.
   // 
   // @link_ must be part of @queue.
   // <link_>: a #GList link that <emphasis>must</emphasis> be part of @queue
   void delete_link(GLib2.List* link_) {
      g_queue_delete_link(&this, link_);
   }

   // Unintrospectable method: find() / g_queue_find()
   // Finds the first link in @queue which contains @data.
   // RETURNS: The first link in @queue which contains @data.
   // <data>: data to find
   GLib2.List* find(const(void)* data) {
      return g_queue_find(&this, data);
   }

   // Unintrospectable method: find_custom() / g_queue_find_custom()
   // Finds an element in a #GQueue, using a supplied function to find the
   // desired element. It iterates over the queue, calling the given function
   // which should return 0 when the desired element is found. The function
   // takes two gconstpointer arguments, the #GQueue element's data as the
   // first argument and the given user data as the second argument.
   // RETURNS: The found link, or %NULL if it wasn't found
   // <data>: user data passed to @func
   // <func>: a #GCompareFunc to call for each element. It should return 0 when the desired element is found
   GLib2.List* find_custom(const(void)* data, CompareFunc func) {
      return g_queue_find_custom(&this, data, func);
   }

   // Unintrospectable method: foreach() / g_queue_foreach()
   // Calls @func for each element in the queue passing @user_data to the
   // function.
   // <func>: the function to call for each element's data
   // <user_data>: user data to pass to @func
   void foreach_(Func func, void* user_data) {
      g_queue_foreach(&this, func, user_data);
   }

   // Frees the memory allocated for the #GQueue. Only call this function if
   // @queue was created with g_queue_new(). If queue elements contain
   // dynamically-allocated memory, they should be freed first.
   void free() {
      g_queue_free(&this);
   }

   // Returns the number of items in @queue.
   // RETURNS: The number of items in @queue.
   uint get_length() {
      return g_queue_get_length(&this);
   }

   // Returns the position of the first element in @queue which contains @data.
   // RETURNS: The position of the first element in @queue which contains @data, or -1 if no element in @queue contains @data.
   // <data>: the data to find.
   int index(const(void)* data) {
      return g_queue_index(&this, data);
   }

   // A statically-allocated #GQueue must be initialized with this function
   // before it can be used. Alternatively you can initialize it with
   // #G_QUEUE_INIT. It is not necessary to initialize queues created with
   // g_queue_new().
   void init() {
      g_queue_init(&this);
   }

   // Unintrospectable method: insert_after() / g_queue_insert_after()
   // Inserts @data into @queue after @sibling
   // 
   // @sibling must be part of @queue
   // <sibling>: a #GList link that <emphasis>must</emphasis> be part of @queue
   // <data>: the data to insert
   void insert_after(GLib2.List* sibling, void* data) {
      g_queue_insert_after(&this, sibling, data);
   }

   // Unintrospectable method: insert_before() / g_queue_insert_before()
   // Inserts @data into @queue before @sibling.
   // 
   // @sibling must be part of @queue.
   // <sibling>: a #GList link that <emphasis>must</emphasis> be part of @queue
   // <data>: the data to insert
   void insert_before(GLib2.List* sibling, void* data) {
      g_queue_insert_before(&this, sibling, data);
   }

   // Unintrospectable method: insert_sorted() / g_queue_insert_sorted()
   // Inserts @data into @queue using @func to determine the new position.
   // <data>: the data to insert
   // <func>: the #GCompareDataFunc used to compare elements in the queue. It is called with two elements of the @queue and @user_data. It should return 0 if the elements are equal, a negative value if the first element comes before the second, and a positive value if the second element comes before the first.
   // <user_data>: user data passed to @func.
   void insert_sorted(void* data, CompareDataFunc func, void* user_data) {
      g_queue_insert_sorted(&this, data, func, user_data);
   }

   // Returns %TRUE if the queue is empty.
   // RETURNS: %TRUE if the queue is empty.
   int is_empty() {
      return g_queue_is_empty(&this);
   }

   // Unintrospectable method: link_index() / g_queue_link_index()
   // Returns the position of @link_ in @queue.
   // 
   // not part of @queue
   // RETURNS: The position of @link_, or -1 if the link is
   // <link_>: A #GList link
   int link_index(GLib2.List* link_) {
      return g_queue_link_index(&this, link_);
   }

   // Unintrospectable method: peek_head() / g_queue_peek_head()
   // Returns the first element of the queue.
   // 
   // is empty.
   // RETURNS: the data of the first element in the queue, or %NULL if the queue
   void* peek_head() {
      return g_queue_peek_head(&this);
   }

   // Unintrospectable method: peek_head_link() / g_queue_peek_head_link()
   // Returns the first link in @queue
   // RETURNS: the first link in @queue, or %NULL if @queue is empty
   GLib2.List* peek_head_link() {
      return g_queue_peek_head_link(&this);
   }

   // Unintrospectable method: peek_nth() / g_queue_peek_nth()
   // Returns the @n'th element of @queue.
   // 
   // off the end of @queue.
   // RETURNS: The data for the @n'th element of @queue, or %NULL if @n is
   // <n>: the position of the element.
   void* peek_nth(uint n) {
      return g_queue_peek_nth(&this, n);
   }

   // Unintrospectable method: peek_nth_link() / g_queue_peek_nth_link()
   // Returns the link at the given position
   // 
   // end of the list
   // RETURNS: The link at the @n'th position, or %NULL if @n is off the
   // <n>: the position of the link
   GLib2.List* peek_nth_link(uint n) {
      return g_queue_peek_nth_link(&this, n);
   }

   // Unintrospectable method: peek_tail() / g_queue_peek_tail()
   // Returns the last element of the queue.
   // 
   // is empty.
   // RETURNS: the data of the last element in the queue, or %NULL if the queue
   void* peek_tail() {
      return g_queue_peek_tail(&this);
   }

   // Unintrospectable method: peek_tail_link() / g_queue_peek_tail_link()
   // Returns the last link @queue.
   // RETURNS: the last link in @queue, or %NULL if @queue is empty
   GLib2.List* peek_tail_link() {
      return g_queue_peek_tail_link(&this);
   }

   // Unintrospectable method: pop_head() / g_queue_pop_head()
   // Removes the first element of the queue.
   // 
   // is empty.
   // RETURNS: the data of the first element in the queue, or %NULL if the queue
   void* pop_head() {
      return g_queue_pop_head(&this);
   }

   // Unintrospectable method: pop_head_link() / g_queue_pop_head_link()
   // Removes the first element of the queue.
   // 
   // is empty.
   // RETURNS: the #GList element at the head of the queue, or %NULL if the queue
   GLib2.List* pop_head_link() {
      return g_queue_pop_head_link(&this);
   }

   // Unintrospectable method: pop_nth() / g_queue_pop_nth()
   // Removes the @n'th element of @queue.
   // RETURNS: the element's data, or %NULL if @n is off the end of @queue.
   // <n>: the position of the element.
   void* pop_nth(uint n) {
      return g_queue_pop_nth(&this, n);
   }

   // Unintrospectable method: pop_nth_link() / g_queue_pop_nth_link()
   // Removes and returns the link at the given position.
   // RETURNS: The @n'th link, or %NULL if @n is off the end of @queue.
   // <n>: the link's position
   GLib2.List* pop_nth_link(uint n) {
      return g_queue_pop_nth_link(&this, n);
   }

   // Unintrospectable method: pop_tail() / g_queue_pop_tail()
   // Removes the last element of the queue.
   // 
   // is empty.
   // RETURNS: the data of the last element in the queue, or %NULL if the queue
   void* pop_tail() {
      return g_queue_pop_tail(&this);
   }

   // Unintrospectable method: pop_tail_link() / g_queue_pop_tail_link()
   // Removes the last element of the queue.
   // 
   // is empty.
   // RETURNS: the #GList element at the tail of the queue, or %NULL if the queue
   GLib2.List* pop_tail_link() {
      return g_queue_pop_tail_link(&this);
   }

   // Adds a new element at the head of the queue.
   // <data>: the data for the new element.
   void push_head(void* data) {
      g_queue_push_head(&this, data);
   }

   // Unintrospectable method: push_head_link() / g_queue_push_head_link()
   // Adds a new element at the head of the queue.
   // <link_>: a single #GList element, <emphasis>not</emphasis> a list with more than one element.
   void push_head_link(GLib2.List* link_) {
      g_queue_push_head_link(&this, link_);
   }

   // Inserts a new element into @queue at the given position
   // <data>: the data for the new element
   // <n>: the position to insert the new element. If @n is negative or larger than the number of elements in the @queue, the element is added to the end of the queue.
   void push_nth(void* data, int n) {
      g_queue_push_nth(&this, data, n);
   }

   // Unintrospectable method: push_nth_link() / g_queue_push_nth_link()
   // Inserts @link into @queue at the given position.
   // <n>: the position to insert the link. If this is negative or larger than the number of elements in @queue, the link is added to the end of @queue.
   // <link_>: the link to add to @queue
   void push_nth_link(int n, GLib2.List* link_) {
      g_queue_push_nth_link(&this, n, link_);
   }

   // Adds a new element at the tail of the queue.
   // <data>: the data for the new element.
   void push_tail(void* data) {
      g_queue_push_tail(&this, data);
   }

   // Unintrospectable method: push_tail_link() / g_queue_push_tail_link()
   // Adds a new element at the tail of the queue.
   // <link_>: a single #GList element, <emphasis>not</emphasis> a list with more than one element.
   void push_tail_link(GLib2.List* link_) {
      g_queue_push_tail_link(&this, link_);
   }

   // Removes the first element in @queue that contains @data.
   // RETURNS: %TRUE if @data was found and removed from @queue
   // <data>: data to remove.
   int remove(const(void)* data) {
      return g_queue_remove(&this, data);
   }

   // Remove all elements whose data equals @data from @queue.
   // RETURNS: the number of elements removed from @queue
   // <data>: data to remove
   uint remove_all(const(void)* data) {
      return g_queue_remove_all(&this, data);
   }
   // Reverses the order of the items in @queue.
   void reverse() {
      g_queue_reverse(&this);
   }

   // Unintrospectable method: sort() / g_queue_sort()
   // Sorts @queue using @compare_func.
   // <compare_func>: the #GCompareDataFunc used to sort @queue. This function is passed two elements of the queue and should return 0 if they are equal, a negative value if the first comes before the second, and a positive value if the second comes before the first.
   // <user_data>: user data passed to @compare_func
   void sort(CompareDataFunc compare_func, void* user_data) {
      g_queue_sort(&this, compare_func, user_data);
   }

   // Unintrospectable method: unlink() / g_queue_unlink()
   // Unlinks @link_ so that it will no longer be part of @queue. The link is
   // not freed.
   // 
   // @link_ must be part of @queue,
   // <link_>: a #GList link that <emphasis>must</emphasis> be part of @queue
   void unlink(GLib2.List* link_) {
      g_queue_unlink(&this, link_);
   }

   // Unintrospectable function: new() / g_queue_new()
   // Creates a new #GQueue.
   // RETURNS: a new #GQueue.
   static Queue* new_() {
      return g_queue_new();
   }
}


// The #GRand struct is an opaque data structure. It should only be
// accessed through the <function>g_rand_*</function> functions.
struct Rand {

   // Unintrospectable method: copy() / g_rand_copy()
   // Copies a #GRand into a new one with the same exact state as before.
   // This way you can take a snapshot of the random number generator for
   // replaying later.
   // RETURNS: the new #GRand.
   Rand* copy() {
      return g_rand_copy(&this);
   }

   // Returns the next random #gdouble from @rand_ equally distributed over
   // the range [0..1).
   // RETURNS: A random number.
   double double_() {
      return g_rand_double(&this);
   }

   // Returns the next random #gdouble from @rand_ equally distributed over
   // the range [@begin..@end).
   // RETURNS: A random number.
   // <begin>: lower closed bound of the interval.
   // <end>: upper open bound of the interval.
   double double_range(double begin, double end) {
      return g_rand_double_range(&this, begin, end);
   }
   // Frees the memory allocated for the #GRand.
   void free() {
      g_rand_free(&this);
   }

   // Returns the next random #guint32 from @rand_ equally distributed over
   // the range [0..2^32-1].
   // RETURNS: A random number.
   uint int_() {
      return g_rand_int(&this);
   }

   // Returns the next random #gint32 from @rand_ equally distributed over
   // the range [@begin..@end-1].
   // RETURNS: A random number.
   // <begin>: lower closed bound of the interval.
   // <end>: upper open bound of the interval.
   int int_range(int begin, int end) {
      return g_rand_int_range(&this, begin, end);
   }

   // Sets the seed for the random number generator #GRand to @seed.
   // <seed>: a value to reinitialize the random number generator.
   void set_seed(uint seed) {
      g_rand_set_seed(&this, seed);
   }

   // Initializes the random number generator by an array of
   // longs.  Array can be of arbitrary size, though only the
   // first 624 values are taken.  This function is useful
   // if you have many low entropy seeds, or if you require more then
   // 32bits of actual entropy for your application.
   // <seed>: array to initialize with
   // <seed_length>: length of array
   void set_seed_array(uint* seed, uint seed_length) {
      g_rand_set_seed_array(&this, seed, seed_length);
   }

   // Unintrospectable function: new() / g_rand_new()
   // Creates a new random number generator initialized with a seed taken
   // either from <filename>/dev/urandom</filename> (if existing) or from
   // the current time (as a fallback).
   // RETURNS: the new #GRand.
   static Rand* new_() {
      return g_rand_new();
   }

   // Unintrospectable function: new_with_seed() / g_rand_new_with_seed()
   // Creates a new random number generator initialized with @seed.
   // RETURNS: the new #GRand.
   // <seed>: a value to initialize the random number generator.
   static Rand* new_with_seed(uint seed) {
      return g_rand_new_with_seed(seed);
   }

   // Unintrospectable function: new_with_seed_array() / g_rand_new_with_seed_array()
   // Creates a new random number generator initialized with @seed.
   // RETURNS: the new #GRand.
   // <seed>: an array of seeds to initialize the random number generator.
   // <seed_length>: an array of seeds to initialize the random number generator.
   static Rand* new_with_seed_array(uint* seed, uint seed_length) {
      return g_rand_new_with_seed_array(seed, seed_length);
   }
}


// The <function>g_regex_*()</function> functions implement regular
// expression pattern matching using syntax and semantics similar to
// Perl regular expression.
// 
// Some functions accept a @start_position argument, setting it differs
// from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL
// in the case of a pattern that begins with any kind of lookbehind assertion.
// For example, consider the pattern "\Biss\B" which finds occurrences of "iss"
// in the middle of words. ("\B" matches only if the current position in the
// subject is not a word boundary.) When applied to the string "Mississipi"
// from the fourth byte, namely "issipi", it does not match, because "\B" is
// always false at the start of the subject, which is deemed to be a word
// boundary. However, if the entire string is passed , but with
// @start_position set to 4, it finds the second occurrence of "iss" because
// it is able to look behind the starting point to discover that it is
// preceded by a letter.
// 
// Note that, unless you set the #G_REGEX_RAW flag, all the strings passed
// to these functions must be encoded in UTF-8. The lengths and the positions
// inside the strings are in bytes and not in characters, so, for instance,
// "\xc3\xa0" (i.e. "&agrave;") is two bytes long but it is treated as a
// single character. If you set #G_REGEX_RAW the strings can be non-valid
// UTF-8 strings and a byte is treated as a character, so "\xc3\xa0" is two
// bytes and two characters long.
// 
// When matching a pattern, "\n" matches only against a "\n" character in
// the string, and "\r" matches only a "\r" character. To match any newline
// sequence use "\R". This particular group matches either the two-character
// sequence CR + LF ("\r\n"), or one of the single characters LF (linefeed,
// U+000A, "\n"), VT vertical tab, U+000B, "\v"), FF (formfeed, U+000C, "\f"),
// CR (carriage return, U+000D, "\r"), NEL (next line, U+0085), LS (line
// separator, U+2028), or PS (paragraph separator, U+2029).
// 
// The behaviour of the dot, circumflex, and dollar metacharacters are
// affected by newline characters, the default is to recognize any newline
// character (the same characters recognized by "\R"). This can be changed
// with #G_REGEX_NEWLINE_CR, #G_REGEX_NEWLINE_LF and #G_REGEX_NEWLINE_CRLF
// compile options, and with #G_REGEX_MATCH_NEWLINE_ANY,
// #G_REGEX_MATCH_NEWLINE_CR, #G_REGEX_MATCH_NEWLINE_LF and
// #G_REGEX_MATCH_NEWLINE_CRLF match options. These settings are also
// relevant when compiling a pattern if #G_REGEX_EXTENDED is set, and an
// unescaped "#" outside a character class is encountered. This indicates
// a comment that lasts until after the next newline.
// 
// Creating and manipulating the same #GRegex structure from different
// threads is not a problem as #GRegex does not modify its internal
// state between creation and destruction, on the other hand #GMatchInfo
// is not threadsafe.
// 
// The regular expressions low-level functionalities are obtained through
// the excellent <ulink url="http://www.pcre.org/">PCRE</ulink> library
// written by Philip Hazel.
struct Regex /* Version 2.14 */ {

   // Compiles the regular expression to an internal form, and does
   // the initial setup of the #GRegex structure.
   // 
   // are done with it
   // RETURNS: a #GRegex structure. Call g_regex_unref() when you
   // <pattern>: the regular expression
   // <compile_options>: compile options for the regular expression, or 0
   // <match_options>: match options for the regular expression, or 0
   static Regex* /*new*/ new_(char* pattern, RegexCompileFlags compile_options, RegexMatchFlags match_options, GLib2.Error** error=null) {
      return g_regex_new(pattern, compile_options, match_options, error);
   }

   // Returns the number of capturing subpatterns in the pattern.
   // RETURNS: the number of capturing subpatterns
   int get_capture_count() {
      return g_regex_get_capture_count(&this);
   }

   // Returns the compile options that @regex was created with.
   // RETURNS: flags from #GRegexCompileFlags
   RegexCompileFlags get_compile_flags() {
      return g_regex_get_compile_flags(&this);
   }

   // Returns the match options that @regex was created with.
   // RETURNS: flags from #GRegexMatchFlags
   RegexMatchFlags get_match_flags() {
      return g_regex_get_match_flags(&this);
   }

   // Returns the number of the highest back reference
   // in the pattern, or 0 if the pattern does not contain
   // back references.
   // RETURNS: the number of the highest back reference
   int get_max_backref() {
      return g_regex_get_max_backref(&this);
   }

   // Gets the pattern string associated with @regex, i.e. a copy of
   // the string passed to g_regex_new().
   // RETURNS: the pattern of @regex
   char* get_pattern() {
      return g_regex_get_pattern(&this);
   }

   // Retrieves the number of the subexpression named @name.
   // 
   // does not exists
   // RETURNS: The number of the subexpression or -1 if @name
   // <name>: name of the subexpression
   int get_string_number(char* name) {
      return g_regex_get_string_number(&this, name);
   }

   // Scans for a match in string for the pattern in @regex.
   // The @match_options are combined with the match options specified
   // when the @regex structure was created, letting you have more
   // flexibility in reusing #GRegex structures.
   // 
   // A #GMatchInfo structure, used to get information on the match,
   // is stored in @match_info if not %NULL. Note that if @match_info
   // is not %NULL then it is created even if the function returns %FALSE,
   // i.e. you must free it regardless if regular expression actually matched.
   // 
   // To retrieve all the non-overlapping matches of the pattern in
   // string you can use g_match_info_next().
   // 
   // |[
   // static void
   // print_uppercase_words (const gchar *string)
   // {
   // /&ast; Print all uppercase-only words. &ast;/
   // GRegex *regex;
   // GMatchInfo *match_info;
   // &nbsp;
   // regex = g_regex_new ("[A-Z]+", 0, 0, NULL);
   // g_regex_match (regex, string, 0, &amp;match_info);
   // while (g_match_info_matches (match_info))
   // {
   // gchar *word = g_match_info_fetch (match_info, 0);
   // g_print ("Found: %s\n", word);
   // g_free (word);
   // g_match_info_next (match_info, NULL);
   // }
   // g_match_info_free (match_info);
   // g_regex_unref (regex);
   // }
   // ]|
   // 
   // @string is not copied and is used in #GMatchInfo internally. If
   // you use any #GMatchInfo method (except g_match_info_free()) after
   // freeing or modifying @string then the behaviour is undefined.
   // RETURNS: %TRUE is the string matched, %FALSE otherwise
   // <string>: the string to scan for matches
   // <match_options>: match options
   // <match_info>: pointer to location where to store the #GMatchInfo, or %NULL if you do not need it
   int match(char* string_, RegexMatchFlags match_options, /*out*/ MatchInfo** match_info=null) {
      return g_regex_match(&this, string_, match_options, match_info);
   }

   // Using the standard algorithm for regular expression matching only
   // the longest match in the string is retrieved. This function uses
   // a different algorithm so it can retrieve all the possible matches.
   // For more documentation see g_regex_match_all_full().
   // 
   // A #GMatchInfo structure, used to get information on the match, is
   // stored in @match_info if not %NULL. Note that if @match_info is
   // not %NULL then it is created even if the function returns %FALSE,
   // i.e. you must free it regardless if regular expression actually
   // matched.
   // 
   // @string is not copied and is used in #GMatchInfo internally. If
   // you use any #GMatchInfo method (except g_match_info_free()) after
   // freeing or modifying @string then the behaviour is undefined.
   // RETURNS: %TRUE is the string matched, %FALSE otherwise
   // <string>: the string to scan for matches
   // <match_options>: match options
   // <match_info>: pointer to location where to store the #GMatchInfo, or %NULL if you do not need it
   int match_all(char* string_, RegexMatchFlags match_options, /*out*/ MatchInfo** match_info=null) {
      return g_regex_match_all(&this, string_, match_options, match_info);
   }

   // Using the standard algorithm for regular expression matching only
   // the longest match in the string is retrieved, it is not possible
   // to obtain all the available matches. For instance matching
   // "&lt;a&gt; &lt;b&gt; &lt;c&gt;" against the pattern "&lt;.*&gt;"
   // you get "&lt;a&gt; &lt;b&gt; &lt;c&gt;".
   // 
   // This function uses a different algorithm (called DFA, i.e. deterministic
   // finite automaton), so it can retrieve all the possible matches, all
   // starting at the same point in the string. For instance matching
   // "&lt;a&gt; &lt;b&gt; &lt;c&gt;" against the pattern "&lt;.*&gt;"
   // you would obtain three matches: "&lt;a&gt; &lt;b&gt; &lt;c&gt;",
   // "&lt;a&gt; &lt;b&gt;" and "&lt;a&gt;".
   // 
   // The number of matched strings is retrieved using
   // g_match_info_get_match_count(). To obtain the matched strings and
   // their position you can use, respectively, g_match_info_fetch() and
   // g_match_info_fetch_pos(). Note that the strings are returned in
   // reverse order of length; that is, the longest matching string is
   // given first.
   // 
   // Note that the DFA algorithm is slower than the standard one and it
   // is not able to capture substrings, so backreferences do not work.
   // 
   // Setting @start_position differs from just passing over a shortened
   // string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
   // that begins with any kind of lookbehind assertion, such as "\b".
   // 
   // A #GMatchInfo structure, used to get information on the match, is
   // stored in @match_info if not %NULL. Note that if @match_info is
   // not %NULL then it is created even if the function returns %FALSE,
   // i.e. you must free it regardless if regular expression actually
   // matched.
   // 
   // @string is not copied and is used in #GMatchInfo internally. If
   // you use any #GMatchInfo method (except g_match_info_free()) after
   // freeing or modifying @string then the behaviour is undefined.
   // RETURNS: %TRUE is the string matched, %FALSE otherwise
   // <string>: the string to scan for matches
   // <string_len>: the length of @string, or -1 if @string is nul-terminated
   // <start_position>: starting index of the string to match
   // <match_options>: match options
   // <match_info>: pointer to location where to store the #GMatchInfo, or %NULL if you do not need it
   int match_all_full(char* string_, ssize_t string_len, int start_position, RegexMatchFlags match_options, /*out*/ MatchInfo** match_info, GLib2.Error** error=null) {
      return g_regex_match_all_full(&this, string_, string_len, start_position, match_options, match_info, error);
   }

   // Scans for a match in string for the pattern in @regex.
   // The @match_options are combined with the match options specified
   // when the @regex structure was created, letting you have more
   // flexibility in reusing #GRegex structures.
   // 
   // Setting @start_position differs from just passing over a shortened
   // string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
   // that begins with any kind of lookbehind assertion, such as "\b".
   // 
   // A #GMatchInfo structure, used to get information on the match, is
   // stored in @match_info if not %NULL. Note that if @match_info is
   // not %NULL then it is created even if the function returns %FALSE,
   // i.e. you must free it regardless if regular expression actually
   // matched.
   // 
   // @string is not copied and is used in #GMatchInfo internally. If
   // you use any #GMatchInfo method (except g_match_info_free()) after
   // freeing or modifying @string then the behaviour is undefined.
   // 
   // To retrieve all the non-overlapping matches of the pattern in
   // string you can use g_match_info_next().
   // 
   // |[
   // static void
   // print_uppercase_words (const gchar *string)
   // {
   // /&ast; Print all uppercase-only words. &ast;/
   // GRegex *regex;
   // GMatchInfo *match_info;
   // GError *error = NULL;
   // &nbsp;
   // regex = g_regex_new ("[A-Z]+", 0, 0, NULL);
   // g_regex_match_full (regex, string, -1, 0, 0, &amp;match_info, &amp;error);
   // while (g_match_info_matches (match_info))
   // {
   // gchar *word = g_match_info_fetch (match_info, 0);
   // g_print ("Found: %s\n", word);
   // g_free (word);
   // g_match_info_next (match_info, &amp;error);
   // }
   // g_match_info_free (match_info);
   // g_regex_unref (regex);
   // if (error != NULL)
   // {
   // g_printerr ("Error while matching: %s\n", error->message);
   // g_error_free (error);
   // }
   // }
   // ]|
   // RETURNS: %TRUE is the string matched, %FALSE otherwise
   // <string>: the string to scan for matches
   // <string_len>: the length of @string, or -1 if @string is nul-terminated
   // <start_position>: starting index of the string to match
   // <match_options>: match options
   // <match_info>: pointer to location where to store the #GMatchInfo, or %NULL if you do not need it
   int match_full(char* string_, ssize_t string_len, int start_position, RegexMatchFlags match_options, /*out*/ MatchInfo** match_info, GLib2.Error** error=null) {
      return g_regex_match_full(&this, string_, string_len, start_position, match_options, match_info, error);
   }

   // Increases reference count of @regex by 1.
   // RETURNS: @regex
   Regex* /*new*/ ref_() {
      return g_regex_ref(&this);
   }

   // Replaces all occurrences of the pattern in @regex with the
   // replacement text. Backreferences of the form '\number' or
   // '\g&lt;number&gt;' in the replacement text are interpolated by the
   // number-th captured subexpression of the match, '\g&lt;name&gt;' refers
   // to the captured subexpression with the given name. '\0' refers to the
   // complete match, but '\0' followed by a number is the octal representation
   // of a character. To include a literal '\' in the replacement, write '\\'.
   // There are also escapes that changes the case of the following text:
   // 
   // <variablelist>
   // <varlistentry><term>\l</term>
   // <listitem>
   // <para>Convert to lower case the next character</para>
   // </listitem>
   // </varlistentry>
   // <varlistentry><term>\u</term>
   // <listitem>
   // <para>Convert to upper case the next character</para>
   // </listitem>
   // </varlistentry>
   // <varlistentry><term>\L</term>
   // <listitem>
   // <para>Convert to lower case till \E</para>
   // </listitem>
   // </varlistentry>
   // <varlistentry><term>\U</term>
   // <listitem>
   // <para>Convert to upper case till \E</para>
   // </listitem>
   // </varlistentry>
   // <varlistentry><term>\E</term>
   // <listitem>
   // <para>End case modification</para>
   // </listitem>
   // </varlistentry>
   // </variablelist>
   // 
   // If you do not need to use backreferences use g_regex_replace_literal().
   // 
   // The @replacement string must be UTF-8 encoded even if #G_REGEX_RAW was
   // passed to g_regex_new(). If you want to use not UTF-8 encoded stings
   // you can use g_regex_replace_literal().
   // 
   // Setting @start_position differs from just passing over a shortened
   // string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that
   // begins with any kind of lookbehind assertion, such as "\b".
   // RETURNS: a newly allocated string containing the replacements
   // <string>: the string to perform matches against
   // <string_len>: the length of @string, or -1 if @string is nul-terminated
   // <start_position>: starting index of the string to match
   // <replacement>: text to replace each match with
   // <match_options>: options for the match
   char* /*new*/ replace(char* string_, ssize_t string_len, int start_position, char* replacement, RegexMatchFlags match_options, GLib2.Error** error=null) {
      return g_regex_replace(&this, string_, string_len, start_position, replacement, match_options, error);
   }

   // Unintrospectable method: replace_eval() / g_regex_replace_eval()
   // Replaces occurrences of the pattern in regex with the output of
   // @eval for that occurrence.
   // 
   // Setting @start_position differs from just passing over a shortened
   // string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
   // that begins with any kind of lookbehind assertion, such as "\b".
   // 
   // The following example uses g_regex_replace_eval() to replace multiple
   // strings at once:
   // |[
   // static gboolean
   // eval_cb (const GMatchInfo *info,
   // GString          *res,
   // gpointer          data)
   // {
   // gchar *match;
   // gchar *r;
   // 
   // match = g_match_info_fetch (info, 0);
   // r = g_hash_table_lookup ((GHashTable *)data, match);
   // g_string_append (res, r);
   // g_free (match);
   // 
   // return FALSE;
   // }
   // 
   // /&ast; ... &ast;/
   // 
   // GRegex *reg;
   // GHashTable *h;
   // gchar *res;
   // 
   // h = g_hash_table_new (g_str_hash, g_str_equal);
   // 
   // g_hash_table_insert (h, "1", "ONE");
   // g_hash_table_insert (h, "2", "TWO");
   // g_hash_table_insert (h, "3", "THREE");
   // g_hash_table_insert (h, "4", "FOUR");
   // 
   // reg = g_regex_new ("1|2|3|4", 0, 0, NULL);
   // res = g_regex_replace_eval (reg, text, -1, 0, 0, eval_cb, h, NULL);
   // g_hash_table_destroy (h);
   // 
   // /&ast; ... &ast;/
   // ]|
   // RETURNS: a newly allocated string containing the replacements
   // <string>: string to perform matches against
   // <string_len>: the length of @string, or -1 if @string is nul-terminated
   // <start_position>: starting index of the string to match
   // <match_options>: options for the match
   // <eval>: a function to call for each match
   // <user_data>: user data to pass to the function
   char* /*new*/ replace_eval(char* string_, ssize_t string_len, int start_position, RegexMatchFlags match_options, RegexEvalCallback eval, void* user_data, GLib2.Error** error=null) {
      return g_regex_replace_eval(&this, string_, string_len, start_position, match_options, eval, user_data, error);
   }

   // Replaces all occurrences of the pattern in @regex with the
   // replacement text. @replacement is replaced literally, to
   // include backreferences use g_regex_replace().
   // 
   // Setting @start_position differs from just passing over a
   // shortened string and setting #G_REGEX_MATCH_NOTBOL in the
   // case of a pattern that begins with any kind of lookbehind
   // assertion, such as "\b".
   // RETURNS: a newly allocated string containing the replacements
   // <string>: the string to perform matches against
   // <string_len>: the length of @string, or -1 if @string is nul-terminated
   // <start_position>: starting index of the string to match
   // <replacement>: text to replace each match with
   // <match_options>: options for the match
   char* /*new*/ replace_literal(char* string_, ssize_t string_len, int start_position, char* replacement, RegexMatchFlags match_options, GLib2.Error** error=null) {
      return g_regex_replace_literal(&this, string_, string_len, start_position, replacement, match_options, error);
   }

   // Unintrospectable method: split() / g_regex_split()
   // 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.
   // 
   // 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 a 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".
   // RETURNS: a %NULL-terminated gchar ** array. Free it using g_strfreev()
   // <string>: the string to split with the pattern
   // <match_options>: match time option flags
   char** split(char* string_, RegexMatchFlags match_options) {
      return g_regex_split(&this, string_, match_options);
   }

   // Unintrospectable method: split_full() / g_regex_split_full()
   // 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.
   // 
   // 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 a 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".
   // 
   // Setting @start_position differs from just passing over a shortened
   // string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
   // that begins with any kind of lookbehind assertion, such as "\b".
   // RETURNS: a %NULL-terminated gchar ** array. Free it using g_strfreev()
   // <string>: the string to split with the pattern
   // <string_len>: the length of @string, or -1 if @string is nul-terminated
   // <start_position>: starting index of the string to match
   // <match_options>: match time option flags
   // <max_tokens>: the maximum number of tokens to split @string into. If this is less than 1, the string is split completely
   char** split_full(char* string_, ssize_t string_len, int start_position, RegexMatchFlags match_options, int max_tokens, GLib2.Error** error=null) {
      return g_regex_split_full(&this, string_, string_len, start_position, match_options, max_tokens, error);
   }

   // Decreases reference count of @regex by 1. When reference count drops
   // to zero, it frees all the memory associated with the regex structure.
   void unref() {
      g_regex_unref(&this);
   }

   // Checks whether @replacement is a valid replacement string
   // (see g_regex_replace()), i.e. that all escape sequences in
   // it are valid.
   // 
   // If @has_references is not %NULL then @replacement is checked
   // for pattern references. For instance, replacement text 'foo\n'
   // does not contain references and may be evaluated without information
   // about actual match, but '\0\1' (whole match followed by first
   // subpattern) requires valid #GMatchInfo object.
   // RETURNS: whether @replacement is a valid replacement string
   // <replacement>: the replacement string
   // <has_references>: location to store information about references in @replacement or %NULL
   static int check_replacement(char* replacement, /*out*/ int* has_references, GLib2.Error** error=null) {
      return g_regex_check_replacement(replacement, has_references, error);
   }
   static Quark error_quark() {
      return g_regex_error_quark();
   }

   // 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.
   // RETURNS: a newly-allocated escaped string
   // <string>: the string to escape
   // <length>: the length of @string
   static char* /*new*/ escape_nul(char* string_, int length) {
      return g_regex_escape_nul(string_, 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.
   // RETURNS: a newly-allocated escaped string
   // <string>: the string to escape
   // <length>: the length of @string, or -1 if @string is nul-terminated
   static char* /*new*/ escape_string(char* string_, int length) {
      return g_regex_escape_string(string_, length);
   }

   // 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().
   // RETURNS: %TRUE if the string matched, %FALSE otherwise
   // <pattern>: the regular expression
   // <string>: the string to scan for matches
   // <compile_options>: compile options for the regular expression, or 0
   // <match_options>: match options, or 0
   static int match_simple(char* pattern, char* string_, RegexCompileFlags compile_options, RegexMatchFlags match_options) {
      return g_regex_match_simple(pattern, string_, compile_options, match_options);
   }

   // Unintrospectable function: split_simple() / g_regex_split_simple()
   // 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
   // a 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".
   // RETURNS: a %NULL-terminated array of strings. Free it using g_strfreev()
   // <pattern>: the regular expression
   // <string>: the string to scan for matches
   // <compile_options>: compile options for the regular expression, or 0
   // <match_options>: match options, or 0
   static char** split_simple(char* pattern, char* string_, RegexCompileFlags compile_options, RegexMatchFlags match_options) {
      return g_regex_split_simple(pattern, string_, compile_options, match_options);
   }
}

// Flags specifying compile-time options.
enum RegexCompileFlags /* Version 2.14 */ {
   CASELESS = 1,
   MULTILINE = 2,
   DOTALL = 4,
   EXTENDED = 8,
   ANCHORED = 16,
   DOLLAR_ENDONLY = 32,
   UNGREEDY = 512,
   RAW = 2048,
   NO_AUTO_CAPTURE = 4096,
   OPTIMIZE = 8192,
   DUPNAMES = 524288,
   NEWLINE_CR = 1048576,
   NEWLINE_LF = 2097152,
   NEWLINE_CRLF = 3145728
}
// Error codes returned by regular expressions functions.
enum RegexError /* Version 2.14 */ {
   COMPILE = 0,
   OPTIMIZE = 1,
   REPLACE = 2,
   MATCH = 3,
   INTERNAL = 4,
   STRAY_BACKSLASH = 101,
   MISSING_CONTROL_CHAR = 102,
   UNRECOGNIZED_ESCAPE = 103,
   QUANTIFIERS_OUT_OF_ORDER = 104,
   QUANTIFIER_TOO_BIG = 105,
   UNTERMINATED_CHARACTER_CLASS = 106,
   INVALID_ESCAPE_IN_CHARACTER_CLASS = 107,
   RANGE_OUT_OF_ORDER = 108,
   NOTHING_TO_REPEAT = 109,
   UNRECOGNIZED_CHARACTER = 112,
   POSIX_NAMED_CLASS_OUTSIDE_CLASS = 113,
   UNMATCHED_PARENTHESIS = 114,
   INEXISTENT_SUBPATTERN_REFERENCE = 115,
   UNTERMINATED_COMMENT = 118,
   EXPRESSION_TOO_LARGE = 120,
   MEMORY_ERROR = 121,
   VARIABLE_LENGTH_LOOKBEHIND = 125,
   MALFORMED_CONDITION = 126,
   TOO_MANY_CONDITIONAL_BRANCHES = 127,
   ASSERTION_EXPECTED = 128,
   UNKNOWN_POSIX_CLASS_NAME = 130,
   POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED = 131,
   HEX_CODE_TOO_LARGE = 134,
   INVALID_CONDITION = 135,
   SINGLE_BYTE_MATCH_IN_LOOKBEHIND = 136,
   INFINITE_LOOP = 140,
   MISSING_SUBPATTERN_NAME_TERMINATOR = 142,
   DUPLICATE_SUBPATTERN_NAME = 143,
   MALFORMED_PROPERTY = 146,
   UNKNOWN_PROPERTY = 147,
   SUBPATTERN_NAME_TOO_LONG = 148,
   TOO_MANY_SUBPATTERNS = 149,
   INVALID_OCTAL_VALUE = 151,
   TOO_MANY_BRANCHES_IN_DEFINE = 154,
   DEFINE_REPETION = 155,
   INCONSISTENT_NEWLINE_OPTIONS = 156,
   MISSING_BACK_REFERENCE = 157
}

// 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.
// RETURNS: %FALSE to continue the replacement process, %TRUE to stop it
// <match_info>: the #GMatchInfo generated by the match. Use g_match_info_get_regex() and g_match_info_get_string() if you need the #GRegex or the matched string.
// <result>: a #GString containing the new string
// <user_data>: user data passed to g_regex_replace_eval()
extern (C) alias int function (MatchInfo* match_info, String* result, void* user_data) RegexEvalCallback;

// Flags specifying match-time options.
enum RegexMatchFlags /* Version 2.14 */ {
   ANCHORED = 16,
   NOTBOL = 128,
   NOTEOL = 256,
   NOTEMPTY = 1024,
   PARTIAL = 32768,
   NEWLINE_CR = 1048576,
   NEWLINE_LF = 2097152,
   NEWLINE_CRLF = 3145728,
   NEWLINE_ANY = 4194304
}

// The #GRelation struct is an opaque data structure to represent a
// <link linkend="glib-Relations-and-Tuples">Relation</link>. It should
// only be accessed via the following functions.
struct Relation {

   // Returns the number of tuples in a #GRelation that have the given
   // value in the given field.
   // <key>: the value to compare with.
   // <field>: the field of each record to match.
   int count(const(void)* key, int field) {
      return g_relation_count(&this, key, field);
   }

   // Deletes any records from a #GRelation that have the given key value
   // in the given field.
   // <key>: the value to compare with.
   // <field>: the field of each record to match.
   int delete_(const(void)* key, int field) {
      return g_relation_delete(&this, key, field);
   }

   // Destroys the #GRelation, freeing all memory allocated. However, it
   // does not free memory allocated for the tuple data, so you should
   // free that first if appropriate.
   void destroy() {
      g_relation_destroy(&this);
   }

   // Unintrospectable method: exists() / g_relation_exists()
   // Returns %TRUE if a record with the given values exists in a
   // #GRelation. Note that the values are compared directly, so that, for
   // example, two copies of the same string will not match.
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_relation_exists exists; // Variadic
   +/

   // Unintrospectable method: index() / g_relation_index()
   // Creates an index on the given field. Note that this must be called
   // before any records are added to the #GRelation.
   // <field>: the field to index, counting from 0.
   // <hash_func>: a function to produce a hash value from the field data.
   // <key_equal_func>: a function to compare two values of the given field.
   void index(int field, HashFunc hash_func, EqualFunc key_equal_func) {
      g_relation_index(&this, field, hash_func, key_equal_func);
   }

   // Unintrospectable method: insert() / g_relation_insert()
   // Inserts a record into a #GRelation.
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_relation_insert insert; // Variadic
   +/

   // Outputs information about all records in a #GRelation, as well as
   // the indexes. It is for debugging.
   void print() {
      g_relation_print(&this);
   }

   // Unintrospectable method: select() / g_relation_select()
   // Returns all of the tuples which have the given key in the given
   // field. Use g_tuples_index() to access the returned records. The
   // returned records should be freed with g_tuples_destroy().
   // <key>: the value to compare with.
   // <field>: the field of each record to match.
   Tuples* select(const(void)* key, int field) {
      return g_relation_select(&this, key, field);
   }

   // Unintrospectable function: new() / g_relation_new()
   // Creates a new #GRelation with the given number of fields. Note that
   // currently the number of fields must be 2.
   // <fields>: the number of fields.
   static Relation* new_(int fields) {
      return g_relation_new(fields);
   }
}

enum int SEARCHPATH_SEPARATOR = 59;
enum SEARCHPATH_SEPARATOR_S = ";";
enum int SIZEOF_LONG = 4;
enum int SIZEOF_SIZE_T = 4;
enum int SIZEOF_VOID_P = 4;

// The #GSList struct is used for each element in the singly-linked
// list.
struct SList {
   void* data;
   GLib2.SList* next;


   // Unintrospectable function: alloc() / g_slist_alloc()
   // Allocates space for one #GSList element. It is called by the
   // g_slist_append(), g_slist_prepend(), g_slist_insert() and
   // g_slist_insert_sorted() functions and so is rarely used on its own.
   static GLib2.SList* alloc() {
      return g_slist_alloc();
   }

   // Unintrospectable function: append() / g_slist_append()
   // Adds a new element on to the end of the list.
   // 
   // <note><para>
   // The return value is the new start of the list, which may
   // have changed, so make sure you store the new value.
   // </para></note>
   // 
   // <note><para>
   // Note that g_slist_append() has to traverse the entire list
   // to find the end, which is inefficient when adding multiple
   // elements. A common idiom to avoid the inefficiency is to prepend
   // the elements and reverse the list when all elements have been added.
   // </para></note>
   // 
   // |[
   // /&ast; Notice that these are initialized to the empty list. &ast;/
   // GSList *list = NULL, *number_list = NULL;
   // 
   // /&ast; This is a list of strings. &ast;/
   // list = g_slist_append (list, "first");
   // list = g_slist_append (list, "second");
   // 
   // /&ast; This is a list of integers. &ast;/
   // number_list = g_slist_append (number_list, GINT_TO_POINTER (27));
   // number_list = g_slist_append (number_list, GINT_TO_POINTER (14));
   // ]|
   // RETURNS: the new start of the #GSList
   // <list>: a #GSList
   // <data>: the data for the new element
   static GLib2.SList* append(GLib2.SList* list, void* data) {
      return g_slist_append(list, data);
   }

   // Unintrospectable function: concat() / g_slist_concat()
   // Adds the second #GSList onto the end of the first #GSList.
   // Note that the elements of the second #GSList are not copied.
   // They are used directly.
   // RETURNS: the start of the new #GSList
   // <list1>: a #GSList
   // <list2>: the #GSList to add to the end of the first #GSList
   static GLib2.SList* concat(GLib2.SList* list1, GLib2.SList* list2) {
      return g_slist_concat(list1, list2);
   }

   // Unintrospectable function: copy() / g_slist_copy()
   // Copies a #GSList.
   // 
   // <note><para>
   // Note that this is a "shallow" copy. If the list elements
   // consist of pointers to data, the pointers are copied but
   // the actual data isn't.
   // </para></note>
   // RETURNS: a copy of @list
   // <list>: a #GSList
   static GLib2.SList* copy(GLib2.SList* list) {
      return g_slist_copy(list);
   }

   // Unintrospectable function: delete_link() / g_slist_delete_link()
   // Removes the node link_ from the list and frees it.
   // Compare this to g_slist_remove_link() which removes the node
   // without freeing it.
   // RETURNS: the new head of @list
   // <list>: a #GSList
   // <link_>: node to delete
   static GLib2.SList* delete_link(GLib2.SList* list, GLib2.SList* link_) {
      return g_slist_delete_link(list, link_);
   }

   // Unintrospectable function: find() / g_slist_find()
   // Finds the element in a #GSList which
   // contains the given data.
   // 
   // or %NULL if it is not found
   // RETURNS: the found #GSList element,
   // <list>: a #GSList
   // <data>: the element data to find
   static GLib2.SList* find(GLib2.SList* list, const(void)* data) {
      return g_slist_find(list, data);
   }

   // Unintrospectable function: find_custom() / g_slist_find_custom()
   // Finds an element in a #GSList, using a supplied function to
   // find the desired element. It iterates over the list, calling
   // the given function which should return 0 when the desired
   // element is found. The function takes two #gconstpointer arguments,
   // the #GSList element's data as the first argument and the
   // given user data.
   // RETURNS: the found #GSList element, or %NULL if it is not found
   // <list>: a #GSList
   // <data>: user data passed to the function
   // <func>: the function to call for each element. It should return 0 when the desired element is found
   static GLib2.SList* find_custom(GLib2.SList* list, const(void)* data, CompareFunc func) {
      return g_slist_find_custom(list, data, func);
   }

   // Unintrospectable function: foreach() / g_slist_foreach()
   // Calls a function for each element of a #GSList.
   // <list>: a #GSList
   // <func>: the function to call with each element's data
   // <user_data>: user data to pass to the function
   static void foreach_(GLib2.SList* list, Func func, void* user_data) {
      g_slist_foreach(list, func, user_data);
   }

   // Unintrospectable function: free() / g_slist_free()
   // Frees all of the memory used by a #GSList.
   // The freed elements are returned to the slice allocator.
   // 
   // <note><para>
   // If list elements contain dynamically-allocated memory,
   // you should either use g_slist_free_full() or free them manually
   // first.
   // </para></note>
   // <list>: a #GSList
   static void free(GLib2.SList* list) {
      g_slist_free(list);
   }

   // Unintrospectable function: free_1() / g_slist_free_1()
   // Frees one #GSList element.
   // It is usually used after g_slist_remove_link().
   // <list>: a #GSList element
   static void free_1(GLib2.SList* list) {
      g_slist_free_1(list);
   }

   // Unintrospectable function: free_full() / g_slist_free_full()
   // Convenience method, which frees all the memory used by a #GSList, and
   // calls the specified destroy function on every element's data.
   // <list>: a pointer to a #GSList
   // <free_func>: the function to be called to free each element's data
   static void free_full(GLib2.SList* list, DestroyNotify free_func) {
      g_slist_free_full(list, free_func);
   }

   // Unintrospectable function: index() / g_slist_index()
   // Gets the position of the element containing
   // the given data (starting from 0).
   // 
   // or -1 if the data is not found
   // RETURNS: the index of the element containing the data,
   // <list>: a #GSList
   // <data>: the data to find
   static int index(GLib2.SList* list, const(void)* data) {
      return g_slist_index(list, data);
   }

   // Unintrospectable function: insert() / g_slist_insert()
   // Inserts a new element into the list at the given position.
   // RETURNS: the new start of the #GSList
   // <list>: a #GSList
   // <data>: the data for the new element
   // <position>: the position to insert the element. If this is negative, or is larger than the number of elements in the list, the new element is added on to the end of the list.
   static GLib2.SList* insert(GLib2.SList* list, void* data, int position) {
      return g_slist_insert(list, data, position);
   }

   // Unintrospectable function: insert_before() / g_slist_insert_before()
   // Inserts a node before @sibling containing @data.
   // RETURNS: the new head of the list.
   // <slist>: a #GSList
   // <sibling>: node to insert @data before
   // <data>: data to put in the newly-inserted node
   static GLib2.SList* insert_before(GLib2.SList* slist, GLib2.SList* sibling, void* data) {
      return g_slist_insert_before(slist, sibling, data);
   }

   // Unintrospectable function: insert_sorted() / g_slist_insert_sorted()
   // Inserts a new element into the list, using the given
   // comparison function to determine its position.
   // RETURNS: the new start of the #GSList
   // <list>: a #GSList
   // <data>: the data for the new element
   // <func>: the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order.
   static GLib2.SList* insert_sorted(GLib2.SList* list, void* data, CompareFunc func) {
      return g_slist_insert_sorted(list, data, func);
   }

   // Unintrospectable function: insert_sorted_with_data() / g_slist_insert_sorted_with_data()
   // Inserts a new element into the list, using the given
   // comparison function to determine its position.
   // RETURNS: the new start of the #GSList
   // <list>: a #GSList
   // <data>: the data for the new element
   // <func>: the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order.
   // <user_data>: data to pass to comparison function
   static GLib2.SList* insert_sorted_with_data(GLib2.SList* list, void* data, CompareDataFunc func, void* user_data) {
      return g_slist_insert_sorted_with_data(list, data, func, user_data);
   }

   // Unintrospectable function: last() / g_slist_last()
   // Gets the last element in a #GSList.
   // 
   // <note><para>
   // This function iterates over the whole list.
   // </para></note>
   // 
   // or %NULL if the #GSList has no elements
   // RETURNS: the last element in the #GSList,
   // <list>: a #GSList
   static GLib2.SList* last(GLib2.SList* list) {
      return g_slist_last(list);
   }

   // Unintrospectable function: length() / g_slist_length()
   // Gets the number of elements in a #GSList.
   // 
   // <note><para>
   // This function iterates over the whole list to
   // count its elements.
   // </para></note>
   // RETURNS: the number of elements in the #GSList
   // <list>: a #GSList
   static uint length(GLib2.SList* list) {
      return g_slist_length(list);
   }

   // Unintrospectable function: nth() / g_slist_nth()
   // Gets the element at the given position in a #GSList.
   // 
   // the end of the #GSList
   // RETURNS: the element, or %NULL if the position is off
   // <list>: a #GSList
   // <n>: the position of the element, counting from 0
   static GLib2.SList* nth(GLib2.SList* list, uint n) {
      return g_slist_nth(list, n);
   }

   // Unintrospectable function: nth_data() / g_slist_nth_data()
   // Gets the data of the element at the given position.
   // 
   // is off the end of the #GSList
   // RETURNS: the element's data, or %NULL if the position
   // <list>: a #GSList
   // <n>: the position of the element
   static void* nth_data(GLib2.SList* list, uint n) {
      return g_slist_nth_data(list, n);
   }

   // Restores the previous #GAllocator, used when allocating #GSList
   // elements.
   // 
   // Note that this function is not available if GLib has been compiled
   // with <option>--disable-mem-pools</option>
   // 
   // to the <link linkend="glib-Memory-Slices">slice
   // allocator</link>
   static void pop_allocator() {
      g_slist_pop_allocator();
   }

   // Unintrospectable function: position() / g_slist_position()
   // Gets the position of the given element
   // in the #GSList (starting from 0).
   // 
   // or -1 if the element is not found
   // RETURNS: the position of the element in the #GSList,
   // <list>: a #GSList
   // <llink>: an element in the #GSList
   static int position(GLib2.SList* list, GLib2.SList* llink) {
      return g_slist_position(list, llink);
   }

   // Unintrospectable function: prepend() / g_slist_prepend()
   // Adds a new element on to the start of the list.
   // 
   // <note><para>
   // The return value is the new start of the list, which
   // may have changed, so make sure you store the new value.
   // </para></note>
   // 
   // |[
   // /&ast; Notice that it is initialized to the empty list. &ast;/
   // GSList *list = NULL;
   // list = g_slist_prepend (list, "last");
   // list = g_slist_prepend (list, "first");
   // ]|
   // RETURNS: the new start of the #GSList
   // <list>: a #GSList
   // <data>: the data for the new element
   static GLib2.SList* prepend(GLib2.SList* list, void* data) {
      return g_slist_prepend(list, data);
   }

   // Sets the allocator to use to allocate #GSList elements. Use
   // g_slist_pop_allocator() to restore the previous allocator.
   // 
   // Note that this function is not available if GLib has been compiled
   // with <option>--disable-mem-pools</option>
   // 
   // to the <link linkend="glib-Memory-Slices">slice
   // allocator</link>
   // <dummy>: the #GAllocator to use when allocating #GSList elements.
   static void push_allocator(void* dummy) {
      g_slist_push_allocator(dummy);
   }

   // Unintrospectable function: remove() / g_slist_remove()
   // Removes an element from a #GSList.
   // If two elements contain the same data, only the first is removed.
   // If none of the elements contain the data, the #GSList is unchanged.
   // RETURNS: the new start of the #GSList
   // <list>: a #GSList
   // <data>: the data of the element to remove
   static GLib2.SList* remove(GLib2.SList* list, const(void)* data) {
      return g_slist_remove(list, data);
   }

   // Unintrospectable function: remove_all() / g_slist_remove_all()
   // Removes all list nodes with data equal to @data.
   // Returns the new head of the list. Contrast with
   // g_slist_remove() which removes only the first node
   // matching the given data.
   // RETURNS: new head of @list
   // <list>: a #GSList
   // <data>: data to remove
   static GLib2.SList* remove_all(GLib2.SList* list, const(void)* data) {
      return g_slist_remove_all(list, data);
   }

   // Unintrospectable function: remove_link() / g_slist_remove_link()
   // Removes an element from a #GSList, without
   // freeing the element. The removed element's next
   // link is set to %NULL, so that it becomes a
   // self-contained list with one element.
   // RETURNS: the new start of the #GSList, without the element
   // <list>: a #GSList
   // <link_>: an element in the #GSList
   static GLib2.SList* remove_link(GLib2.SList* list, GLib2.SList* link_) {
      return g_slist_remove_link(list, link_);
   }

   // Unintrospectable function: reverse() / g_slist_reverse()
   // Reverses a #GSList.
   // RETURNS: the start of the reversed #GSList
   // <list>: a #GSList
   static GLib2.SList* reverse(GLib2.SList* list) {
      return g_slist_reverse(list);
   }

   // Unintrospectable function: sort() / g_slist_sort()
   // Sorts a #GSList using the given comparison function.
   // RETURNS: the start of the sorted #GSList
   // <list>: a #GSList
   // <compare_func>: the comparison function used to sort the #GSList. This function is passed the data from 2 elements of the #GSList and should return 0 if they are equal, a negative value if the first element comes before the second, or a positive value if the first element comes after the second.
   static GLib2.SList* sort(GLib2.SList* list, CompareFunc compare_func) {
      return g_slist_sort(list, compare_func);
   }

   // Unintrospectable function: sort_with_data() / g_slist_sort_with_data()
   // Like g_slist_sort(), but the sort function accepts a user data argument.
   // RETURNS: new head of the list
   // <list>: a #GSList
   // <compare_func>: comparison function
   // <user_data>: data to pass to comparison function
   static GLib2.SList* sort_with_data(GLib2.SList* list, CompareDataFunc compare_func, void* user_data) {
      return g_slist_sort_with_data(list, compare_func, user_data);
   }
}

enum double SQRT2 = 1.414214;
enum STR_DELIMITERS = "_-|> <.";
enum int SYSDEF_AF_INET = 2;
enum int SYSDEF_AF_INET6 = 10;
enum int SYSDEF_AF_UNIX = 1;
enum int SYSDEF_MSG_DONTROUTE = 4;
enum int SYSDEF_MSG_OOB = 1;
enum int SYSDEF_MSG_PEEK = 2;
struct Scanner {
   void* user_data;
   uint max_parse_errors, parse_errors;
   char* input_name;
   Data* qdata;
   ScannerConfig* config;
   TokenType token;
   TokenValue value;
   uint line, position;
   TokenType next_token;
   TokenValue next_value;
   uint next_line, next_position;
   GLib2.HashTable* symbol_table;
   int input_fd;
   char* text, text_end, buffer;
   uint scope_id;
   ScannerMsgFunc msg_handler;

   uint cur_line() {
      return g_scanner_cur_line(&this);
   }
   uint cur_position() {
      return g_scanner_cur_position(&this);
   }
   TokenType cur_token() {
      return g_scanner_cur_token(&this);
   }
   // Unintrospectable method: cur_value() / g_scanner_cur_value()
   TokenValue cur_value() {
      return g_scanner_cur_value(&this);
   }
   void destroy() {
      g_scanner_destroy(&this);
   }
   int eof() {
      return g_scanner_eof(&this);
   }
   // Unintrospectable method: error() / g_scanner_error()
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_scanner_error error; // Variadic
   +/
   TokenType get_next_token() {
      return g_scanner_get_next_token(&this);
   }
   void input_file(int input_fd) {
      g_scanner_input_file(&this, input_fd);
   }
   void input_text(char* text, uint text_len) {
      g_scanner_input_text(&this, text, text_len);
   }
   // Unintrospectable method: lookup_symbol() / g_scanner_lookup_symbol()
   void* lookup_symbol(char* symbol) {
      return g_scanner_lookup_symbol(&this, symbol);
   }
   TokenType peek_next_token() {
      return g_scanner_peek_next_token(&this);
   }
   void scope_add_symbol(uint scope_id, char* symbol, void* value) {
      g_scanner_scope_add_symbol(&this, scope_id, symbol, value);
   }
   // Unintrospectable method: scope_foreach_symbol() / g_scanner_scope_foreach_symbol()
   void scope_foreach_symbol(uint scope_id, HFunc func, void* user_data) {
      g_scanner_scope_foreach_symbol(&this, scope_id, func, user_data);
   }
   // Unintrospectable method: scope_lookup_symbol() / g_scanner_scope_lookup_symbol()
   void* scope_lookup_symbol(uint scope_id, char* symbol) {
      return g_scanner_scope_lookup_symbol(&this, scope_id, symbol);
   }
   void scope_remove_symbol(uint scope_id, char* symbol) {
      g_scanner_scope_remove_symbol(&this, scope_id, symbol);
   }
   uint set_scope(uint scope_id) {
      return g_scanner_set_scope(&this, scope_id);
   }
   void sync_file_offset() {
      g_scanner_sync_file_offset(&this);
   }
   void unexp_token(TokenType expected_token, char* identifier_spec, char* symbol_spec, char* symbol_name, char* message, int is_error) {
      g_scanner_unexp_token(&this, expected_token, identifier_spec, symbol_spec, symbol_name, message, is_error);
   }
   // Unintrospectable method: warn() / g_scanner_warn()
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_scanner_warn warn; // Variadic
   +/
   // Unintrospectable function: new() / g_scanner_new()
   static Scanner* new_(ScannerConfig* config_templ) {
      return g_scanner_new(config_templ);
   }
}

struct ScannerConfig {
   char* cset_skip_characters, cset_identifier_first, cset_identifier_nth, cpair_comment_single;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "case_sensitive", 1,
   uint, "skip_comment_multi", 1,
   uint, "skip_comment_single", 1,
   uint, "scan_comment_multi", 1,
   uint, "scan_identifier", 1,
   uint, "scan_identifier_1char", 1,
   uint, "scan_identifier_NULL", 1,
   uint, "scan_symbols", 1,
   uint, "scan_binary", 1,
   uint, "scan_octal", 1,
   uint, "scan_float", 1,
   uint, "scan_hex", 1,
   uint, "scan_hex_dollar", 1,
   uint, "scan_string_sq", 1,
   uint, "scan_string_dq", 1,
   uint, "numbers_2_int", 1,
   uint, "int_2_float", 1,
   uint, "identifier_2_string", 1,
   uint, "char_2_token", 1,
   uint, "symbol_2_token", 1,
   uint, "scope_0_fallback", 1,
   uint, "store_int64", 1,
    uint, "__dummy32A", 10));
   uint padding_dummy;
}

extern (C) alias void function (Scanner* scanner, char* message, int error) ScannerMsgFunc;


// An enumeration specifying the base position for a
// g_io_channel_seek_position() operation.
enum SeekType {
   CUR = 0,
   SET = 1,
   END = 2
}

// The #GSequence struct is an opaque data type representing a
// <link linkend="glib-Sequences">Sequence</link> data type.
struct Sequence {

   // Unintrospectable method: append() / g_sequence_append()
   // Adds a new item to the end of @seq.
   // RETURNS: an iterator pointing to the new item
   // <data>: the data for the new item
   SequenceIter* append(void* data) {
      return g_sequence_append(&this, data);
   }

   // Unintrospectable method: foreach() / g_sequence_foreach()
   // Calls @func for each item in the sequence passing @user_data
   // to the function.
   // <func>: the function to call for each item in @seq
   // <user_data>: user data passed to @func
   void foreach_(Func func, void* user_data) {
      g_sequence_foreach(&this, func, user_data);
   }

   // Frees the memory allocated for @seq. If @seq has a data destroy
   // function associated with it, that function is called on all items in
   // @seq.
   void free() {
      g_sequence_free(&this);
   }

   // Unintrospectable method: get_begin_iter() / g_sequence_get_begin_iter()
   // Returns the begin iterator for @seq.
   // RETURNS: the begin iterator for @seq.
   SequenceIter* get_begin_iter() {
      return g_sequence_get_begin_iter(&this);
   }

   // Unintrospectable method: get_end_iter() / g_sequence_get_end_iter()
   // Returns the end iterator for @seg
   // RETURNS: the end iterator for @seq
   SequenceIter* get_end_iter() {
      return g_sequence_get_end_iter(&this);
   }

   // Unintrospectable method: get_iter_at_pos() / g_sequence_get_iter_at_pos()
   // Returns the iterator at position @pos. If @pos is negative or larger
   // than the number of items in @seq, the end iterator is returned.
   // RETURNS: The #GSequenceIter at position @pos
   // <pos>: a position in @seq, or -1 for the end.
   SequenceIter* get_iter_at_pos(int pos) {
      return g_sequence_get_iter_at_pos(&this, pos);
   }

   // Returns the length of @seq
   // RETURNS: the length of @seq
   int get_length() {
      return g_sequence_get_length(&this);
   }

   // Unintrospectable method: insert_sorted() / g_sequence_insert_sorted()
   // Inserts @data into @sequence using @func to determine the new
   // position. The sequence must already be sorted according to @cmp_func;
   // otherwise the new position of @data is undefined.
   // 
   // @cmp_func is called with two items of the @seq and @user_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.
   // RETURNS: a #GSequenceIter pointing to the new item.
   // <data>: the data to insert
   // <cmp_func>: the function used to compare items in the sequence
   // <cmp_data>: user data passed to @cmp_func.
   SequenceIter* insert_sorted(void* data, CompareDataFunc cmp_func, void* cmp_data) {
      return g_sequence_insert_sorted(&this, data, cmp_func, cmp_data);
   }

   // Unintrospectable method: insert_sorted_iter() / g_sequence_insert_sorted_iter()
   // Like g_sequence_insert_sorted(), but uses
   // a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as
   // the compare function.
   // 
   // @iter_cmp is called with two iterators pointing into @seq.
   // 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.
   // 
   // It is called with two iterators pointing into @seq. 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.
   // RETURNS: a #GSequenceIter pointing to the new item
   // <data>: data for the new item
   // <iter_cmp>: the function used to compare iterators in the sequence
   // <cmp_data>: user data passed to @cmp_func
   SequenceIter* insert_sorted_iter(void* data, SequenceIterCompareFunc iter_cmp, void* cmp_data) {
      return g_sequence_insert_sorted_iter(&this, data, iter_cmp, cmp_data);
   }

   // Unintrospectable method: lookup() / g_sequence_lookup()
   // Returns an iterator pointing to the position of the first item found
   // equal to @data according to @cmp_func and @cmp_data. If more than one
   // item is equal, it is not guaranteed that it is the first which is
   // returned. In that case, you can use g_sequence_iter_next() and
   // g_sequence_iter_prev() to get others.
   // 
   // @cmp_func is called with two items of the @seq and @user_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.
   // 
   // first item found equal to @data according to @cmp_func and @cmp_data.
   // RETURNS: an #GSequenceIter pointing to the position of the
   // <data>: data to lookup
   // <cmp_func>: the function used to compare items in the sequence
   // <cmp_data>: user data passed to @cmp_func.
   SequenceIter* lookup(void* data, CompareDataFunc cmp_func, void* cmp_data) {
      return g_sequence_lookup(&this, data, cmp_func, cmp_data);
   }

   // Unintrospectable method: lookup_iter() / g_sequence_lookup_iter()
   // Like g_sequence_lookup(), but uses a #GSequenceIterCompareFunc
   // instead of a #GCompareDataFunc as the compare function.
   // 
   // @iter_cmp is called with two iterators pointing into @seq.
   // 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.
   // 
   // the first item found equal to @data according to @cmp_func
   // and @cmp_data.
   // RETURNS: an #GSequenceIter pointing to the position of
   // <data>: data to lookup
   // <iter_cmp>: the function used to compare iterators in the sequence
   // <cmp_data>: user data passed to @iter_cmp
   SequenceIter* lookup_iter(void* data, SequenceIterCompareFunc iter_cmp, void* cmp_data) {
      return g_sequence_lookup_iter(&this, data, iter_cmp, cmp_data);
   }

   // Unintrospectable method: prepend() / g_sequence_prepend()
   // Adds a new item to the front of @seq
   // RETURNS: an iterator pointing to the new item
   // <data>: the data for the new item
   SequenceIter* prepend(void* data) {
      return g_sequence_prepend(&this, data);
   }

   // Unintrospectable method: search() / g_sequence_search()
   // Returns an iterator pointing to the position where @data would
   // be inserted according to @cmp_func and @cmp_data.
   // 
   // @cmp_func is called with two items of the @seq and @user_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.
   // 
   // If you are simply searching for an existing element of the sequence,
   // consider using g_sequence_lookup().
   // 
   // would have been inserted according to @cmp_func and @cmp_data.
   // RETURNS: an #GSequenceIter pointing to the position where @data
   // <data>: data for the new item
   // <cmp_func>: the function used to compare items in the sequence
   // <cmp_data>: user data passed to @cmp_func.
   SequenceIter* search(void* data, CompareDataFunc cmp_func, void* cmp_data) {
      return g_sequence_search(&this, data, cmp_func, cmp_data);
   }

   // Unintrospectable method: search_iter() / g_sequence_search_iter()
   // Like g_sequence_search(), but uses a #GSequenceIterCompareFunc
   // instead of a #GCompareDataFunc as the compare function.
   // 
   // @iter_cmp is called with two iterators pointing into @seq.
   // 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.
   // 
   // If you are simply searching for an existing element of the sequence,
   // consider using g_sequence_lookup_iter().
   // 
   // where @data would have been inserted according to @iter_cmp
   // and @cmp_data.
   // RETURNS: a #GSequenceIter pointing to the position in @seq
   // <data>: data for the new item
   // <iter_cmp>: the function used to compare iterators in the sequence
   // <cmp_data>: user data passed to @iter_cmp
   SequenceIter* search_iter(void* data, SequenceIterCompareFunc iter_cmp, void* cmp_data) {
      return g_sequence_search_iter(&this, data, iter_cmp, cmp_data);
   }

   // Unintrospectable method: sort() / g_sequence_sort()
   // Sorts @seq using @cmp_func.
   // 
   // @cmp_func is passed two items of @seq and should
   // return 0 if they are equal, a negative value if the
   // first comes before the second, and a positive value
   // if the second comes before the first.
   // <cmp_func>: the function used to sort the sequence
   // <cmp_data>: user data passed to @cmp_func
   void sort(CompareDataFunc cmp_func, void* cmp_data) {
      g_sequence_sort(&this, cmp_func, cmp_data);
   }

   // Unintrospectable method: sort_iter() / g_sequence_sort_iter()
   // Like g_sequence_sort(), but uses a #GSequenceIterCompareFunc instead
   // of a GCompareDataFunc as the compare function
   // 
   // @cmp_func is called with two iterators pointing into @seq. 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.
   // <cmp_func>: the function used to compare iterators in the sequence
   // <cmp_data>: user data passed to @cmp_func
   void sort_iter(SequenceIterCompareFunc cmp_func, void* cmp_data) {
      g_sequence_sort_iter(&this, cmp_func, cmp_data);
   }

   // Unintrospectable function: foreach_range() / g_sequence_foreach_range()
   // Calls @func for each item in the range (@begin, @end) passing
   // @user_data to the function.
   // <begin>: a #GSequenceIter
   // <end>: a #GSequenceIter
   // <func>: a #GFunc
   // <user_data>: user data passed to @func
   static void foreach_range(SequenceIter* begin, SequenceIter* end, Func func, void* user_data) {
      g_sequence_foreach_range(begin, end, func, user_data);
   }

   // Unintrospectable function: get() / g_sequence_get()
   // Returns the data that @iter points to.
   // RETURNS: the data that @iter points to
   // <iter>: a #GSequenceIter
   static void* get(SequenceIter* iter) {
      return g_sequence_get(iter);
   }

   // Unintrospectable function: insert_before() / g_sequence_insert_before()
   // Inserts a new item just before the item pointed to by @iter.
   // RETURNS: an iterator pointing to the new item
   // <iter>: a #GSequenceIter
   // <data>: the data for the new item
   static SequenceIter* insert_before(SequenceIter* iter, void* data) {
      return g_sequence_insert_before(iter, data);
   }

   // 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>: a #GSequenceIter pointing to the item to move
   // <dest>: a #GSequenceIter pointing to the position to which the item is moved.
   static void move(SequenceIter* src, SequenceIter* dest) {
      g_sequence_move(src, dest);
   }

   // Inserts the (@begin, @end) range at the destination pointed to by ptr.
   // 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 iter points to a place within
   // the (@begin, @end) range, the range does not move.
   // <dest>: a #GSequenceIter
   // <begin>: a #GSequenceIter
   // <end>: a #GSequenceIter
   static void move_range(SequenceIter* dest, SequenceIter* begin, SequenceIter* end) {
      g_sequence_move_range(dest, begin, end);
   }

   // Unintrospectable function: new() / g_sequence_new()
   // Creates a new GSequence. The @data_destroy function, if non-%NULL will
   // be called on all items when the sequence is destroyed and on items that
   // are removed from the sequence.
   // RETURNS: a new #GSequence
   // <data_destroy>: a #GDestroyNotify function, or %NULL
   static Sequence* new_(DestroyNotify data_destroy) {
      return g_sequence_new(data_destroy);
   }

   // Unintrospectable function: range_get_midpoint() / g_sequence_range_get_midpoint()
   // 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 <emphasis>exactly</emphasis> 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, @end) range.
   // RETURNS: A #GSequenceIter pointing somewhere in the
   // <begin>: a #GSequenceIter
   // <end>: a #GSequenceIter
   static SequenceIter* range_get_midpoint(SequenceIter* begin, SequenceIter* end) {
      return g_sequence_range_get_midpoint(begin, end);
   }

   // Removes the item pointed to by @iter. It is an error to pass the
   // end iterator to this function.
   // 
   // If the sequnce has a data destroy function associated with it, this
   // function is called on the data for the removed item.
   // <iter>: a #GSequenceIter
   static void remove(SequenceIter* iter) {
      g_sequence_remove(iter);
   }

   // 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>: a #GSequenceIter
   // <end>: a #GSequenceIter
   static void remove_range(SequenceIter* begin, SequenceIter* end) {
      g_sequence_remove_range(begin, end);
   }

   // 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>: a #GSequenceIter
   // <data>: new data for the item
   static void set(SequenceIter* iter, void* data) {
      g_sequence_set(iter, data);
   }

   // Unintrospectable function: sort_changed() / g_sequence_sort_changed()
   // Moves the data pointed to a new position as indicated by @cmp_func. 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 @user_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>: A #GSequenceIter
   // <cmp_func>: the function used to compare items in the sequence
   // <cmp_data>: user data passed to @cmp_func.
   static void sort_changed(SequenceIter* iter, CompareDataFunc cmp_func, void* cmp_data) {
      g_sequence_sort_changed(iter, cmp_func, cmp_data);
   }

   // Unintrospectable function: sort_changed_iter() / g_sequence_sort_changed_iter()
   // 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 @seq. 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>: a #GSequenceIter
   // <iter_cmp>: the function used to compare iterators in the sequence
   // <cmp_data>: user data passed to @cmp_func
   static void sort_changed_iter(SequenceIter* iter, SequenceIterCompareFunc iter_cmp, void* cmp_data) {
      g_sequence_sort_changed_iter(iter, iter_cmp, cmp_data);
   }

   // Swaps the items pointed to by @a and @b. It is allowed for @a and @b
   // to point into difference sequences.
   // <a>: a #GSequenceIter
   // <b>: a #GSequenceIter
   static void swap(SequenceIter* a, SequenceIter* b) {
      g_sequence_swap(a, b);
   }
}


// The #GSequenceIter struct is an opaque data type representing an
// iterator pointing into a #GSequence.
struct SequenceIter {

   // Returns a negative number if @a comes before @b, 0 if they are equal,
   // and a positive number if @a comes after @b.
   // 
   // The @a and @b iterators must point into the same sequence.
   // 
   // equal, and a positive number if @a comes after @b.
   // RETURNS: A negative number if @a comes before @b, 0 if they are
   // <b>: a #GSequenceIter
   int compare(SequenceIter* b) {
      return g_sequence_iter_compare(&this, b);
   }

   // Returns the position of @iter
   // RETURNS: the position of @iter
   int get_position() {
      return g_sequence_iter_get_position(&this);
   }

   // Unintrospectable method: get_sequence() / g_sequence_iter_get_sequence()
   // Returns the #GSequence that @iter points into.
   // RETURNS: the #GSequence that @iter points into.
   Sequence* get_sequence() {
      return g_sequence_iter_get_sequence(&this);
   }

   // Returns whether @iter is the begin iterator
   // RETURNS: whether @iter is the begin iterator
   int is_begin() {
      return g_sequence_iter_is_begin(&this);
   }

   // Returns whether @iter is the end iterator
   // RETURNS: Whether @iter is the end iterator.
   int is_end() {
      return g_sequence_iter_is_end(&this);
   }

   // Unintrospectable method: move() / g_sequence_iter_move()
   // Returns the #GSequenceIter which is @delta positions away from @iter.
   // If @iter is closer than -@delta positions to the beginning of the sequence,
   // the begin iterator is returned. If @iter is closer than @delta positions
   // to the end of the sequence, the end iterator is returned.
   // RETURNS: a #GSequenceIter which is @delta positions away from @iter.
   // <delta>: A positive or negative number indicating how many positions away from @iter the returned #GSequenceIter will be.
   SequenceIter* move(int delta) {
      return g_sequence_iter_move(&this, delta);
   }

   // Unintrospectable method: next() / g_sequence_iter_next()
   // Returns an iterator pointing to the next position after @iter. If
   // @iter is the end iterator, the end iterator is returned.
   // RETURNS: a #GSequenceIter pointing to the next position after @iter.
   SequenceIter* next() {
      return g_sequence_iter_next(&this);
   }

   // Unintrospectable method: prev() / g_sequence_iter_prev()
   // Returns an iterator pointing to the previous position before @iter. If
   // @iter is the begin iterator, the begin iterator is returned.
   // 
   // @iter.
   // RETURNS: a #GSequenceIter pointing to the previous position before
   SequenceIter* prev() {
      return g_sequence_iter_prev(&this);
   }
}


// 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.
// <a>: a #GSequenceIter
// <b>: a #GSequenceIter
// <data>: user data
extern (C) alias int function (SequenceIter* a, SequenceIter* b, void* data) SequenceIterCompareFunc;

// Error codes returned by shell functions.
enum ShellError {
   BAD_QUOTING = 0,
   EMPTY_STRING = 1,
   FAILED = 2
}
enum SliceConfig {
   ALWAYS_MALLOC = 1,
   BYPASS_MAGAZINES = 2,
   WORKING_SET_MSECS = 3,
   COLOR_INCREMENT = 4,
   CHUNK_SIZES = 5,
   CONTENTION_COUNTER = 6
}

// The <structname>GSource</structname> struct is an opaque data type
// representing an event source.
struct Source {
   private void* callback_data;
   private SourceCallbackFuncs* callback_funcs;
   private SourceFuncs* source_funcs;
   private uint ref_count;
   private MainContext* context;
   private int priority;
   private uint flags, source_id;
   private GLib2.SList* poll_fds;
   private Source* prev, next;
   private char* name;
   private SourcePrivate* priv;


   // Creates a new #GSource structure. The size is specified to
   // allow creating structures derived from #GSource that contain
   // additional data. The size passed in must be at least
   // <literal>sizeof (GSource)</literal>.
   // 
   // The source will not initially be associated with any #GMainContext
   // and must be added to one with g_source_attach() before it will be
   // executed.
   // RETURNS: the newly-created #GSource.
   // <source_funcs>: structure containing functions that implement the sources behavior.
   // <struct_size>: size of the #GSource structure to create.
   static Source* /*new*/ new_(SourceFuncs* source_funcs, uint struct_size) {
      return g_source_new(source_funcs, struct_size);
   }

   // Adds @child_source to @source as a "polled" source; when @source is
   // added to a #GMainContext, @child_source will be automatically added
   // with the same priority, when @child_source is triggered, it will
   // cause @source to dispatch (in addition to calling its own
   // callback), and when @source is destroyed, it will destroy
   // @child_source as well. (@source will also still be dispatched if
   // its own prepare/check functions indicate that it is ready.)
   // 
   // If you don't need @child_source to do anything on its own when it
   // triggers, you can call g_source_set_dummy_callback() on it to set a
   // callback that does nothing (except return %TRUE if appropriate).
   // 
   // @source will hold a reference on @child_source while @child_source
   // is attached to it.
   // <child_source>: a second #GSource that @source should "poll"
   void add_child_source(Source* child_source) {
      g_source_add_child_source(&this, child_source);
   }

   // Adds a file descriptor to the set of file descriptors polled for
   // this source. This is usually combined with g_source_new() to add an
   // event source. The event source's check function will typically test
   // the @revents field in the #GPollFD struct and return %TRUE if events need
   // to be processed.
   // <fd>: a #GPollFD structure holding information about a file descriptor to watch.
   void add_poll(PollFD* fd) {
      g_source_add_poll(&this, fd);
   }

   // Adds a #GSource to a @context so that it will be executed within
   // that context. Remove it by calling g_source_destroy().
   // 
   // #GMainContext.
   // RETURNS: the ID (greater than 0) for the source within the
   // <context>: a #GMainContext (if %NULL, the default context will be used)
   uint attach(MainContext* context) {
      return g_source_attach(&this, context);
   }

   // Removes a source from its #GMainContext, if any, and mark it as
   // destroyed.  The source cannot be subsequently added to another
   // context.
   void destroy() {
      g_source_destroy(&this);
   }

   // Checks whether a source is allowed to be called recursively.
   // see g_source_set_can_recurse().
   // RETURNS: whether recursion is allowed.
   int get_can_recurse() {
      return g_source_get_can_recurse(&this);
   }

   // Gets the #GMainContext with which the source is associated.
   // Calling this function on a destroyed source is an error.
   // 
   // source is associated, or %NULL if the context has not
   // yet been added to a source.
   // RETURNS: the #GMainContext with which the
   MainContext* get_context() {
      return g_source_get_context(&this);
   }

   // Gets the "current time" to be used when checking
   // this source. The advantage of calling this function over
   // calling g_get_current_time() directly is that when
   // checking multiple sources, GLib can cache a single value
   // instead of having to repeatedly get the system time.
   // <timeval>: #GTimeVal structure in which to store current time.
   void get_current_time(TimeVal* timeval) {
      g_source_get_current_time(&this, timeval);
   }

   // Returns the numeric ID for a particular source. The ID of a source
   // is a positive integer which is unique within a particular main loop
   // context. The reverse
   // mapping from ID to source is done by g_main_context_find_source_by_id().
   // RETURNS: the ID (greater than 0) for the source
   uint get_id() {
      return g_source_get_id(&this);
   }

   // Gets a name for the source, used in debugging and profiling.
   // The name may be #NULL if it has never been set with
   // g_source_set_name().
   // RETURNS: the name of the source
   char* get_name() {
      return g_source_get_name(&this);
   }

   // Gets the priority of a source.
   // RETURNS: the priority of the source
   int get_priority() {
      return g_source_get_priority(&this);
   }

   // Gets the time to be used when checking this source. The advantage of
   // calling this function over calling g_get_monotonic_time() directly is
   // that when checking multiple sources, GLib can cache a single value
   // instead of having to repeatedly get the system monotonic time.
   // 
   // The time here is the system monotonic time, if available, or some
   // other reasonable alternative otherwise.  See g_get_monotonic_time().
   // RETURNS: the monotonic time in microseconds
   long get_time() {
      return g_source_get_time(&this);
   }

   // Returns whether @source has been destroyed.
   // 
   // This is important when you operate upon your objects
   // from within idle handlers, but may have freed the object
   // before the dispatch of your idle handler.
   // 
   // |[
   // static gboolean
   // idle_callback (gpointer data)
   // {
   // SomeWidget *self = data;
   // 
   // GDK_THREADS_ENTER (<!-- -->);
   // /<!-- -->* do stuff with self *<!-- -->/
   // self->idle_id = 0;
   // GDK_THREADS_LEAVE (<!-- -->);
   // 
   // return FALSE;
   // }
   // 
   // static void
   // some_widget_do_stuff_later (SomeWidget *self)
   // {
   // self->idle_id = g_idle_add (idle_callback, self);
   // }
   // 
   // static void
   // some_widget_finalize (GObject *object)
   // {
   // SomeWidget *self = SOME_WIDGET (object);
   // 
   // if (self->idle_id)
   // g_source_remove (self->idle_id);
   // 
   // G_OBJECT_CLASS (parent_class)->finalize (object);
   // }
   // ]|
   // 
   // This will fail in a multi-threaded application if the
   // widget is destroyed before the idle handler fires due
   // to the use after free in the callback. A solution, to
   // this particular problem, is to check to if the source
   // has already been destroy within the callback.
   // 
   // |[
   // static gboolean
   // idle_callback (gpointer data)
   // {
   // SomeWidget *self = data;
   // 
   // GDK_THREADS_ENTER ();
   // if (!g_source_is_destroyed (g_main_current_source ()))
   // {
   // /<!-- -->* do stuff with self *<!-- -->/
   // }
   // GDK_THREADS_LEAVE ();
   // 
   // return FALSE;
   // }
   // ]|
   // RETURNS: %TRUE if the source has been destroyed
   int is_destroyed() {
      return g_source_is_destroyed(&this);
   }

   // Increases the reference count on a source by one.
   // RETURNS: @source
   Source* /*new*/ ref_() {
      return g_source_ref(&this);
   }

   // Detaches @child_source from @source and destroys it.
   // <child_source>: a #GSource previously passed to g_source_add_child_source().
   void remove_child_source(Source* child_source) {
      g_source_remove_child_source(&this, child_source);
   }

   // Removes a file descriptor from the set of file descriptors polled for
   // this source.
   // <fd>: a #GPollFD structure previously passed to g_source_add_poll().
   void remove_poll(PollFD* fd) {
      g_source_remove_poll(&this, fd);
   }

   // Sets the callback function for a source. The callback for a source is
   // called from the source's dispatch function.
   // 
   // The exact type of @func depends on the type of source; ie. you
   // should not count on @func being called with @data as its first
   // parameter.
   // 
   // Typically, you won't use this function. Instead use functions specific
   // to the type of source you are using.
   // <func>: a callback function
   // <data>: the data to pass to callback function
   // <notify>: a function to call when @data is no longer in use, or %NULL.
   void set_callback(SourceFunc func, void* data, DestroyNotify notify) {
      g_source_set_callback(&this, func, data, notify);
   }

   // Sets the callback function storing the data as a refcounted callback
   // "object". This is used internally. Note that calling
   // g_source_set_callback_indirect() assumes
   // an initial reference count on @callback_data, and thus
   // @callback_funcs->unref will eventually be called once more
   // than @callback_funcs->ref.
   // <callback_data>: pointer to callback data "object"
   // <callback_funcs>: functions for reference counting @callback_data and getting the callback and data
   void set_callback_indirect(void* callback_data, SourceCallbackFuncs* callback_funcs) {
      g_source_set_callback_indirect(&this, callback_data, callback_funcs);
   }

   // Sets whether a source can be called recursively. If @can_recurse is
   // %TRUE, then while the source is being dispatched then this source
   // will be processed normally. Otherwise, all processing of this
   // source is blocked until the dispatch function returns.
   // <can_recurse>: whether recursion is allowed for this source
   void set_can_recurse(int can_recurse) {
      g_source_set_can_recurse(&this, can_recurse);
   }

   // Sets the source functions (can be used to override
   // default implementations) of an unattached source.
   // <funcs>: the new #GSourceFuncs
   void set_funcs(SourceFuncs* funcs) {
      g_source_set_funcs(&this, funcs);
   }

   // Sets a name for the source, used in debugging and profiling.
   // The name defaults to #NULL.
   // 
   // The source name should describe in a human-readable way
   // what the source does. For example, "X11 event queue"
   // or "GTK+ repaint idle handler" or whatever it is.
   // 
   // It is permitted to call this function multiple times, but is not
   // recommended due to the potential performance impact.  For example,
   // one could change the name in the "check" function of a #GSourceFuncs
   // to include details like the event type in the source name.
   // <name>: debug name for the source
   void set_name(char* name) {
      g_source_set_name(&this, name);
   }

   // Sets the priority of a source. While the main loop is being run, a
   // source will be dispatched if it is ready to be dispatched and no
   // sources at a higher (numerically smaller) priority are ready to be
   // dispatched.
   // <priority>: the new priority.
   void set_priority(int priority) {
      g_source_set_priority(&this, priority);
   }

   // Decreases the reference count of a source by one. If the
   // resulting reference count is zero the source and associated
   // memory will be destroyed.
   void unref() {
      g_source_unref(&this);
   }

   // Removes the source with the given id from the default main context.
   // The id of
   // a #GSource is given by g_source_get_id(), or will be returned by the
   // functions g_source_attach(), g_idle_add(), g_idle_add_full(),
   // g_timeout_add(), g_timeout_add_full(), g_child_watch_add(),
   // g_child_watch_add_full(), g_io_add_watch(), and g_io_add_watch_full().
   // 
   // See also g_source_destroy(). You must use g_source_destroy() for sources
   // added to a non-default main context.
   // RETURNS: %TRUE if the source was found and removed.
   // <tag>: the ID of the source to remove.
   static int remove(uint tag) {
      return g_source_remove(tag);
   }

   // 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.
   // RETURNS: %TRUE if a source was found and removed.
   // <funcs>: The @source_funcs passed to g_source_new()
   // <user_data>: the user data for the callback
   static int remove_by_funcs_user_data(SourceFuncs* funcs, void* user_data) {
      return g_source_remove_by_funcs_user_data(funcs, 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.
   // RETURNS: %TRUE if a source was found and removed.
   // <user_data>: the user_data for the callback.
   static int remove_by_user_data(void* user_data) {
      return g_source_remove_by_user_data(user_data);
   }

   // Sets the name of a source using its ID.
   // 
   // This is a convenience utility to set source names from the return
   // value of g_idle_add(), g_timeout_add(), etc.
   // <tag>: a #GSource ID
   // <name>: debug name for the source
   static void set_name_by_id(uint tag, char* name) {
      g_source_set_name_by_id(tag, name);
   }
}

struct SourceCallbackFuncs {
   extern (C) void function (void* cb_data) ref_;
   extern (C) void function (void* cb_data) unref;
   // Unintrospectable functionp: get() / ()
   extern (C) void function (void* cb_data, Source* source, SourceFunc* func, void** data) get;
}


// This is just a placeholder for #GClosureMarshal,
// which cannot be used here for dependency reasons.
extern (C) alias void function () SourceDummyMarshal;


// Specifies the type of function passed to g_timeout_add(),
// g_timeout_add_full(), g_idle_add(), and g_idle_add_full().
// RETURNS: %FALSE if the source should be removed
// <user_data>: data passed to the function, set when the source was created with one of the above functions
extern (C) alias int function (void* user_data) SourceFunc;


// The <structname>GSourceFuncs</structname> struct contains a table of
// functions used to handle event sources in a generic manner.
// 
// For idle sources, the prepare and check functions always return %TRUE
// to indicate that the source is always ready to be processed. The prepare
// function also returns a timeout value of 0 to ensure that the poll() call
// doesn't block (since that would be time wasted which could have been spent
// running the idle function).
// 
// For timeout sources, the prepare and check functions both return %TRUE
// if the timeout interval has expired. The prepare function also returns
// a timeout value to ensure that the poll() call doesn't block too long
// and miss the next timeout.
// 
// For file descriptor sources, the prepare function typically returns %FALSE,
// since it must wait until poll() has been called before it knows whether
// any events need to be processed. It sets the returned timeout to -1 to
// indicate that it doesn't mind how long the poll() call blocks. In the
// check function, it tests the results of the poll() call to see if the
// required condition has been met, and returns %TRUE if so.
struct SourceFuncs {
   extern (C) int function (Source* source, int* timeout_) prepare;
   extern (C) int function (Source* source) check;
   // Unintrospectable functionp: dispatch() / ()
   extern (C) int function (Source* source, SourceFunc callback, void* user_data) dispatch;
   extern (C) void function (Source* source) finalize;
   SourceFunc closure_callback;
   SourceDummyMarshal closure_marshal;
}

struct SourcePrivate {
}


// Specifies the type of the setup function passed to g_spawn_async(),
// g_spawn_sync() and g_spawn_async_with_pipes(). On POSIX platforms it
// is called in the child after GLib has performed all the setup it plans
// to perform but before calling exec(). On POSIX actions taken in this
// function will thus only affect the child, not the parent.
// 
// Note that 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.
// 
// Also note that modifying the environment from the child setup function
// may not have the intended effect, since it will get overridden by
// a non-%NULL @env argument to the <literal>g_spawn...</literal> functions.
// 
// 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.
// <user_data>: user data to pass to the function.
extern (C) alias void function (void* user_data) SpawnChildSetupFunc;

// Error codes returned by spawning processes.
enum SpawnError {
   FORK = 0,
   READ = 1,
   CHDIR = 2,
   ACCES = 3,
   PERM = 4,
   _2BIG = 5,
   NOEXEC = 6,
   NAMETOOLONG = 7,
   NOENT = 8,
   NOMEM = 9,
   NOTDIR = 10,
   LOOP = 11,
   TXTBUSY = 12,
   IO = 13,
   NFILE = 14,
   MFILE = 15,
   INVAL = 16,
   ISDIR = 17,
   LIBBAD = 18,
   FAILED = 19
}
// Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes().
enum SpawnFlags {
   LEAVE_DESCRIPTORS_OPEN = 1,
   DO_NOT_REAP_CHILD = 2,
   SEARCH_PATH = 4,
   STDOUT_TO_DEV_NULL = 8,
   STDERR_TO_DEV_NULL = 16,
   CHILD_INHERITS_STDIN = 32,
   FILE_AND_ARGV_ZERO = 64
}

// A type corresponding to the appropriate struct type for the stat
// system call, depending on the platform and/or compiler being used.
// 
// See g_stat() for more information.
struct StatBuf {
}


// A #GStaticMutex works like a #GMutex, but it has one significant
// advantage. It doesn't need to be created at run-time like a #GMutex,
// but can be defined at compile-time. Here is a shorter, easier and
// safer version of our <function>give_me_next_number()</function>
// example:
// 
// <example>
// <title>
// Using <structname>GStaticMutex</structname>
// to simplify thread-safe programming
// </title>
// <programlisting>
// int
// give_me_next_number (void)
// {
// static int current_number = 0;
// int ret_val;
// static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
// 
// g_static_mutex_lock (&amp;mutex);
// ret_val = current_number = calc_next_number (current_number);
// g_static_mutex_unlock (&amp;mutex);
// 
// return ret_val;
// }
// </programlisting>
// </example>
// 
// Sometimes you would like to dynamically create a mutex. If you don't
// want to require prior calling to g_thread_init(), because your code
// should also be usable in non-threaded programs, you are not able to
// use g_mutex_new() and thus #GMutex, as that requires a prior call to
// g_thread_init(). In theses cases you can also use a #GStaticMutex.
// It must be initialized with g_static_mutex_init() before using it
// and freed with with g_static_mutex_free() when not needed anymore to
// free up any allocated resources.
// 
// Even though #GStaticMutex is not opaque, it should only be used with
// the following functions, as it is defined differently on different
// platforms.
// 
// All of the <function>g_static_mutex_*</function> functions apart
// from <function>g_static_mutex_get_mutex</function> can also be used
// even if g_thread_init() has not yet been called. Then they do
// nothing, apart from <function>g_static_mutex_trylock</function>,
// which does nothing but returning %TRUE.
// 
// <note><para>All of the <function>g_static_mutex_*</function>
// functions are actually macros. Apart from taking their addresses, you
// can however use them as if they were functions.</para></note>
struct StaticMutex {
   void** runtime_mutex;

   union static_mutex {
      char[24] pad;
      double dummy_double;
      void* dummy_pointer;
      c_long dummy_long;
   }


   // Releases all resources allocated to @mutex.
   // 
   // You don't have to call this functions for a #GStaticMutex with an
   // unbounded lifetime, i.e. objects declared 'static', but if you have
   // a #GStaticMutex as a member of a structure and the structure is
   // freed, you should also free the #GStaticMutex.
   // 
   // <note><para>Calling g_static_mutex_free() on a locked mutex may
   // result in undefined behaviour.</para></note>
   void free() {
      g_static_mutex_free(&this);
   }

   // Initializes @mutex. Alternatively you can initialize it with
   // #G_STATIC_MUTEX_INIT.
   void init() {
      g_static_mutex_init(&this);
   }
   // Unintrospectable function: get_mutex_impl() / g_static_mutex_get_mutex_impl()
   static Mutex* get_mutex_impl(Mutex** mutex) {
      return g_static_mutex_get_mutex_impl(mutex);
   }
}


// A #GStaticPrivate works almost like a #GPrivate, but it has one
// significant advantage. It doesn't need to be created at run-time
// like a #GPrivate, but can be defined at compile-time. This is
// similar to the difference between #GMutex and #GStaticMutex. Now
// look at our <function>give_me_next_number()</function> example with
// #GStaticPrivate:
// 
// <example>
// <title>Using GStaticPrivate for per-thread data</title>
// <programlisting>
// int
// give_me_next_number (<!-- -->)
// {
// static GStaticPrivate current_number_key = G_STATIC_PRIVATE_INIT;
// int *current_number = g_static_private_get (&amp;current_number_key);
// 
// if (!current_number)
// {
// current_number = g_new (int,1);
// *current_number = 0;
// g_static_private_set (&amp;current_number_key, current_number, g_free);
// }
// 
// *current_number = calc_next_number (*current_number);
// 
// return *current_number;
// }
// </programlisting>
// </example>
struct StaticPrivate {
   private uint index;


   // Releases all resources allocated to @private_key.
   // 
   // You don't have to call this functions for a #GStaticPrivate with an
   // unbounded lifetime, i.e. objects declared 'static', but if you have
   // a #GStaticPrivate as a member of a structure and the structure is
   // freed, you should also free the #GStaticPrivate.
   void free() {
      g_static_private_free(&this);
   }

   // Unintrospectable method: get() / g_static_private_get()
   // Works like g_private_get() only for a #GStaticPrivate.
   // 
   // This function works even if g_thread_init() has not yet been called.
   void* get() {
      return g_static_private_get(&this);
   }

   // Initializes @private_key. Alternatively you can initialize it with
   // #G_STATIC_PRIVATE_INIT.
   void init() {
      g_static_private_init(&this);
   }

   // Sets the pointer keyed to @private_key for the current thread and
   // the function @notify to be called with that pointer (%NULL or
   // non-%NULL), whenever the pointer is set again or whenever the
   // current thread ends.
   // 
   // This function works even if g_thread_init() has not yet been called.
   // If g_thread_init() is called later, the @data keyed to @private_key
   // will be inherited only by the main thread, i.e. the one that called
   // g_thread_init().
   // 
   // <note><para>@notify is used quite differently from @destructor in
   // g_private_new().</para></note>
   // <data>: the new pointer.
   // <notify>: a function to be called with the pointer whenever the current thread ends or sets this pointer again.
   void set(void* data, DestroyNotify notify) {
      g_static_private_set(&this, data, notify);
   }
}


// The #GStaticRWLock struct represents a read-write lock. A read-write
// lock can be used for protecting data that some portions of code only
// read from, while others also write. In such situations it is
// desirable that several readers can read at once, whereas of course
// only one writer may write at a time. Take a look at the following
// example:
// 
// <example>
// <title>An array with access functions</title>
// <programlisting>
// GStaticRWLock rwlock = G_STATIC_RW_LOCK_INIT;
// GPtrArray *array;
// 
// gpointer
// my_array_get (guint index)
// {
// gpointer retval = NULL;
// 
// if (!array)
// return NULL;
// 
// g_static_rw_lock_reader_lock (&amp;rwlock);
// if (index &lt; array->len)
// retval = g_ptr_array_index (array, index);
// g_static_rw_lock_reader_unlock (&amp;rwlock);
// 
// return retval;
// }
// 
// void
// my_array_set (guint index, gpointer data)
// {
// g_static_rw_lock_writer_lock (&amp;rwlock);
// 
// if (!array)
// array = g_ptr_array_new (<!-- -->);
// 
// if (index >= array->len)
// g_ptr_array_set_size (array, index+1);
// g_ptr_array_index (array, index) = data;
// 
// g_static_rw_lock_writer_unlock (&amp;rwlock);
// }
// </programlisting>
// </example>
// 
// This example shows an array which can be accessed by many readers
// (the <function>my_array_get()</function> function) simultaneously,
// whereas the writers (the <function>my_array_set()</function>
// function) will only be allowed once at a time and only if no readers
// currently access the array. This is because of the potentially
// dangerous resizing of the array. Using these functions is fully
// multi-thread safe now.
// 
// Most of the time, writers should have precedence over readers. That
// means, for this implementation, that as soon as a writer wants to
// lock the data, no other reader is allowed to lock the data, whereas,
// of course, the readers that already have locked the data are allowed
// to finish their operation. As soon as the last reader unlocks the
// data, the writer will lock it.
// 
// Even though #GStaticRWLock is not opaque, it should only be used
// with the following functions.
// 
// All of the <function>g_static_rw_lock_*</function> functions can be
// used even if g_thread_init() has not been called. Then they do
// nothing, apart from <function>g_static_rw_lock_*_trylock</function>,
// which does nothing but returning %TRUE.
// 
// <note><para>A read-write lock has a higher overhead than a mutex. For
// example, both g_static_rw_lock_reader_lock() and
// g_static_rw_lock_reader_unlock() have to lock and unlock a
// #GStaticMutex, so it takes at least twice the time to lock and unlock
// a #GStaticRWLock that it does to lock and unlock a #GStaticMutex. So
// only data structures that are accessed by multiple readers, and which
// keep the lock for a considerable time justify a #GStaticRWLock. The
// above example most probably would fare better with a
// #GStaticMutex.</para></note>
struct StaticRWLock {
   private StaticMutex mutex;
   private Cond* read_cond, write_cond;
   private uint read_counter;
   private int have_writer;
   private uint want_to_read, want_to_write;


   // Releases all resources allocated to @lock.
   // 
   // You don't have to call this functions for a #GStaticRWLock with an
   // unbounded lifetime, i.e. objects declared 'static', but if you have
   // a #GStaticRWLock as a member of a structure, and the structure is
   // freed, you should also free the #GStaticRWLock.
   void free() {
      g_static_rw_lock_free(&this);
   }

   // A #GStaticRWLock must be initialized with this function before it
   // can be used. Alternatively you can initialize it with
   // #G_STATIC_RW_LOCK_INIT.
   void init() {
      g_static_rw_lock_init(&this);
   }

   // Locks @lock for reading. There may be unlimited concurrent locks for
   // reading of a #GStaticRWLock at the same time.  If @lock is already
   // locked for writing by another thread or if another thread is already
   // waiting to lock @lock for writing, this function will block until
   // @lock is unlocked by the other writing thread and no other writing
   // threads want to lock @lock. This lock has to be unlocked by
   // g_static_rw_lock_reader_unlock().
   // 
   // #GStaticRWLock is not recursive. It might seem to be possible to
   // recursively lock for reading, but that can result in a deadlock, due
   // to writer preference.
   void reader_lock() {
      g_static_rw_lock_reader_lock(&this);
   }

   // Tries to lock @lock for reading. If @lock is already locked for
   // writing by another thread or if another thread is already waiting to
   // lock @lock for writing, immediately returns %FALSE. Otherwise locks
   // @lock for reading and returns %TRUE. This lock has to be unlocked by
   // g_static_rw_lock_reader_unlock().
   int reader_trylock() {
      return g_static_rw_lock_reader_trylock(&this);
   }

   // Unlocks @lock. If a thread waits to lock @lock for writing and all
   // locks for reading have been unlocked, the waiting thread is woken up
   // and can lock @lock for writing.
   void reader_unlock() {
      g_static_rw_lock_reader_unlock(&this);
   }

   // Locks @lock for writing. If @lock is already locked for writing or
   // reading by other threads, this function will block until @lock is
   // completely unlocked and then lock @lock for writing. While this
   // functions waits to lock @lock, no other thread can lock @lock for
   // reading. When @lock is locked for writing, no other thread can lock
   // @lock (neither for reading nor writing). This lock has to be
   // unlocked by g_static_rw_lock_writer_unlock().
   void writer_lock() {
      g_static_rw_lock_writer_lock(&this);
   }

   // Tries to lock @lock for writing. If @lock is already locked (for
   // either reading or writing) by another thread, it immediately returns
   // %FALSE. Otherwise it locks @lock for writing and returns %TRUE. This
   // lock has to be unlocked by g_static_rw_lock_writer_unlock().
   int writer_trylock() {
      return g_static_rw_lock_writer_trylock(&this);
   }

   // Unlocks @lock. If a thread is waiting to lock @lock for writing and
   // all locks for reading have been unlocked, the waiting thread is
   // woken up and can lock @lock for writing. If no thread is waiting to
   // lock @lock for writing, and some thread or threads are waiting to
   // lock @lock for reading, the waiting threads are woken up and can
   // lock @lock for reading.
   void writer_unlock() {
      g_static_rw_lock_writer_unlock(&this);
   }
}


// A #GStaticRecMutex works like a #GStaticMutex, but it can be locked
// multiple times by one thread. If you enter it n times, you have to
// unlock it n times again to let other threads lock it. An exception
// is the function g_static_rec_mutex_unlock_full(): that allows you to
// unlock a #GStaticRecMutex completely returning the depth, (i.e. the
// number of times this mutex was locked). The depth can later be used
// to restore the state of the #GStaticRecMutex by calling
// g_static_rec_mutex_lock_full().
// 
// Even though #GStaticRecMutex is not opaque, it should only be used
// with the following functions.
// 
// All of the <function>g_static_rec_mutex_*</function> functions can
// be used even if g_thread_init() has not been called. Then they do
// nothing, apart from <function>g_static_rec_mutex_trylock</function>,
// which does nothing but returning %TRUE.
struct StaticRecMutex {
   private StaticMutex mutex;
   private uint depth;
   private SystemThread owner;


   // Releases all resources allocated to a #GStaticRecMutex.
   // 
   // You don't have to call this functions for a #GStaticRecMutex with an
   // unbounded lifetime, i.e. objects declared 'static', but if you have
   // a #GStaticRecMutex as a member of a structure and the structure is
   // freed, you should also free the #GStaticRecMutex.
   void free() {
      g_static_rec_mutex_free(&this);
   }

   // A #GStaticRecMutex must be initialized with this function before it
   // can be used. Alternatively you can initialize it with
   // #G_STATIC_REC_MUTEX_INIT.
   void init() {
      g_static_rec_mutex_init(&this);
   }

   // Locks @mutex. If @mutex is already locked by another thread, the
   // current thread will block until @mutex is unlocked by the other
   // thread. If @mutex is already locked by the calling thread, this
   // functions increases the depth of @mutex and returns immediately.
   void lock() {
      g_static_rec_mutex_lock(&this);
   }

   // Works like calling g_static_rec_mutex_lock() for @mutex @depth times.
   // <depth>: number of times this mutex has to be unlocked to be completely unlocked.
   void lock_full(uint depth) {
      g_static_rec_mutex_lock_full(&this, depth);
   }

   // Tries to lock @mutex. If @mutex is already locked by another thread,
   // it immediately returns %FALSE. Otherwise it locks @mutex and returns
   // %TRUE. If @mutex is already locked by the calling thread, this
   // functions increases the depth of @mutex and immediately returns
   // %TRUE.
   int trylock() {
      return g_static_rec_mutex_trylock(&this);
   }

   // Unlocks @mutex. Another thread will be allowed to lock @mutex only
   // when it has been unlocked as many times as it had been locked
   // before. If @mutex is completely unlocked and another thread is
   // blocked in a g_static_rec_mutex_lock() call for @mutex, it will be
   // woken and can lock @mutex itself.
   void unlock() {
      g_static_rec_mutex_unlock(&this);
   }

   // Completely unlocks @mutex. If another thread is blocked in a
   // g_static_rec_mutex_lock() call for @mutex, it will be woken and can
   // lock @mutex itself. This function returns the number of times that
   // @mutex has been locked by the current thread. To restore the state
   // before the call to g_static_rec_mutex_unlock_full() you can call
   // g_static_rec_mutex_lock_full() with the depth returned by this
   // function.
   uint unlock_full() {
      return g_static_rec_mutex_unlock_full(&this);
   }
}

// The #GString struct contains the public fields of a #GString.
struct String {
   char* str;
   size_t len, allocated_len;


   // Adds a string onto the end of a #GString, expanding
   // it if necessary.
   // RETURNS: @string
   // <val>: the string to append onto the end of @string
   String* /*new*/ append(char* val) {
      return g_string_append(&this, val);
   }

   // Adds a byte onto the end of a #GString, expanding
   // it if necessary.
   // RETURNS: @string
   // <c>: the byte to append onto the end of @string
   String* /*new*/ append_c(char c) {
      return g_string_append_c(&this, c);
   }

   // Appends @len bytes of @val to @string. Because @len is
   // provided, @val may contain embedded nuls and need not
   // be nul-terminated.
   // 
   // Since this function does not stop at nul bytes, it is
   // the caller's responsibility to ensure that @val has at
   // least @len addressable bytes.
   // RETURNS: @string
   // <val>: bytes to append
   // <len>: number of bytes of @val to use
   String* /*new*/ append_len(char* val, ssize_t len) {
      return g_string_append_len(&this, val, len);
   }

   // Unintrospectable method: append_printf() / g_string_append_printf()
   // Appends a formatted string onto the end of a #GString.
   // This function is similar to g_string_printf() except
   // that the text is appended to the #GString.
   // <format>: the string format. See the printf() documentation
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_string_append_printf append_printf; // Variadic
   +/

   // Converts a Unicode character into UTF-8, and appends it
   // to the string.
   // RETURNS: @string
   // <wc>: a Unicode character
   String* /*new*/ append_unichar(dchar wc) {
      return g_string_append_unichar(&this, wc);
   }

   // Appends @unescaped to @string, escaped any characters that
   // are reserved in URIs using URI-style escape sequences.
   // RETURNS: @string
   // <unescaped>: a string
   // <reserved_chars_allowed>: a string of reserved characters allowed to be used, or %NULL
   // <allow_utf8>: set %TRUE if the escaped string may include UTF8 characters
   String* /*new*/ append_uri_escaped(char* unescaped, char* reserved_chars_allowed, int allow_utf8) {
      return g_string_append_uri_escaped(&this, unescaped, reserved_chars_allowed, allow_utf8);
   }

   // Unintrospectable method: append_vprintf() / g_string_append_vprintf()
   // Appends a formatted string onto the end of a #GString.
   // This function is similar to g_string_append_printf()
   // except that the arguments to the format string are passed
   // as a va_list.
   // <format>: the string format. See the printf() documentation
   // <args>: the list of arguments to insert in the output
   void append_vprintf(char* format, va_list args) {
      g_string_append_vprintf(&this, format, args);
   }

   // Converts all upper case ASCII letters to lower case ASCII letters.
   // 
   // characters converted to lower case in place, with
   // semantics that exactly match g_ascii_tolower().
   // RETURNS: passed-in @string pointer, with all the upper case
   String* /*new*/ ascii_down() {
      return g_string_ascii_down(&this);
   }

   // Converts all lower case ASCII letters to upper case ASCII letters.
   // 
   // characters converted to upper case in place, with
   // semantics that exactly match g_ascii_toupper().
   // RETURNS: passed-in @string pointer, with all the lower case
   String* /*new*/ ascii_up() {
      return g_string_ascii_up(&this);
   }

   // Copies the bytes from a string into a #GString,
   // destroying any previous contents. It is rather like
   // the standard strcpy() function, except that you do not
   // have to worry about having enough space to copy the string.
   // RETURNS: @string
   // <rval>: the string to copy into @string
   String* /*new*/ assign(char* rval) {
      return g_string_assign(&this, rval);
   }

   // Converts a #GString to lowercase.
   // 
   // 
   // Deprecated:2.2: This function uses the locale-specific
   // tolower() function, which is almost never the right thing.
   // Use g_string_ascii_down() or g_utf8_strdown() instead.
   // RETURNS: the #GString.
   String* /*new*/ down() {
      return g_string_down(&this);
   }

   // Compares two strings for equality, returning %TRUE if they are equal.
   // For use with #GHashTable.
   // 
   // same bytes
   // RETURNS: %TRUE if they strings are the same length and contain the
   // <v2>: another #GString
   int equal(String* v2) {
      return g_string_equal(&this, v2);
   }

   // Removes @len bytes from a #GString, starting at position @pos.
   // The rest of the #GString is shifted down to fill the gap.
   // RETURNS: @string
   // <pos>: the position of the content to remove
   // <len>: the number of bytes to remove, or -1 to remove all following bytes
   String* /*new*/ erase(ssize_t pos, ssize_t len) {
      return g_string_erase(&this, pos, len);
   }

   // Frees the memory allocated for the #GString.
   // If @free_segment is %TRUE it also frees the character data.  If
   // it's %FALSE, the caller gains ownership of the buffer and must
   // free it after use with g_free().
   // 
   // (i.e. %NULL if @free_segment is %TRUE)
   // RETURNS: the character data of @string
   // <free_segment>: if %TRUE the actual character data is freed as well
   char* /*new*/ free(int free_segment) {
      return g_string_free(&this, free_segment);
   }

   // Creates a hash code for @str; for use with #GHashTable.
   // RETURNS: hash code for @str
   uint hash() {
      return g_string_hash(&this);
   }

   // Inserts a copy of a string into a #GString,
   // expanding it if necessary.
   // RETURNS: @string
   // <pos>: the position to insert the copy of the string
   // <val>: the string to insert
   String* /*new*/ insert(ssize_t pos, char* val) {
      return g_string_insert(&this, pos, val);
   }

   // Inserts a byte into a #GString, expanding it if necessary.
   // RETURNS: @string
   // <pos>: the position to insert the byte
   // <c>: the byte to insert
   String* /*new*/ insert_c(ssize_t pos, char c) {
      return g_string_insert_c(&this, pos, c);
   }

   // Inserts @len bytes of @val into @string at @pos.
   // Because @len is provided, @val may contain embedded
   // nuls and need not be nul-terminated. If @pos is -1,
   // bytes are inserted at the end of the string.
   // 
   // Since this function does not stop at nul bytes, it is
   // the caller's responsibility to ensure that @val has at
   // least @len addressable bytes.
   // RETURNS: @string
   // <pos>: position in @string where insertion should happen, or -1 for at the end
   // <val>: bytes to insert
   // <len>: number of bytes of @val to insert
   String* /*new*/ insert_len(ssize_t pos, char* val, ssize_t len) {
      return g_string_insert_len(&this, pos, val, len);
   }

   // Converts a Unicode character into UTF-8, and insert it
   // into the string at the given position.
   // RETURNS: @string
   // <pos>: the position at which to insert character, or -1 to append at the end of the string
   // <wc>: a Unicode character
   String* /*new*/ insert_unichar(ssize_t pos, dchar wc) {
      return g_string_insert_unichar(&this, pos, wc);
   }

   // Overwrites part of a string, lengthening it if necessary.
   // RETURNS: @string
   // <pos>: the position at which to start overwriting
   // <val>: the string that will overwrite the @string starting at @pos
   String* /*new*/ overwrite(size_t pos, char* val) {
      return g_string_overwrite(&this, pos, val);
   }

   // Overwrites part of a string, lengthening it if necessary.
   // This function will work with embedded nuls.
   // RETURNS: @string
   // <pos>: the position at which to start overwriting
   // <val>: the string that will overwrite the @string starting at @pos
   // <len>: the number of bytes to write from @val
   String* /*new*/ overwrite_len(size_t pos, char* val, ssize_t len) {
      return g_string_overwrite_len(&this, pos, val, len);
   }

   // Adds a string on to the start of a #GString,
   // expanding it if necessary.
   // RETURNS: @string
   // <val>: the string to prepend on the start of @string
   String* /*new*/ prepend(char* val) {
      return g_string_prepend(&this, val);
   }

   // Adds a byte onto the start of a #GString,
   // expanding it if necessary.
   // RETURNS: @string
   // <c>: the byte to prepend on the start of the #GString
   String* /*new*/ prepend_c(char c) {
      return g_string_prepend_c(&this, c);
   }

   // Prepends @len bytes of @val to @string.
   // Because @len is provided, @val may contain
   // embedded nuls and need not be nul-terminated.
   // 
   // Since this function does not stop at nul bytes,
   // it is the caller's responsibility to ensure that
   // @val has at least @len addressable bytes.
   // RETURNS: @string
   // <val>: bytes to prepend
   // <len>: number of bytes in @val to prepend
   String* /*new*/ prepend_len(char* val, ssize_t len) {
      return g_string_prepend_len(&this, val, len);
   }

   // Converts a Unicode character into UTF-8, and prepends it
   // to the string.
   // RETURNS: @string
   // <wc>: a Unicode character
   String* /*new*/ prepend_unichar(dchar wc) {
      return g_string_prepend_unichar(&this, wc);
   }

   // Unintrospectable method: printf() / g_string_printf()
   // Writes a formatted string into a #GString.
   // This is similar to the standard sprintf() function,
   // except that the #GString buffer automatically expands
   // to contain the results. The previous contents of the
   // #GString are destroyed.
   // <format>: the string format. See the printf() documentation
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_string_printf printf; // Variadic
   +/

   // Sets the length of a #GString. If the length is less than
   // the current length, the string will be truncated. If the
   // length is greater than the current length, the contents
   // of the newly added area are undefined. (However, as
   // always, string->str[string->len] will be a nul byte.)
   // RETURNS: @string
   // <len>: the new length
   String* /*new*/ set_size(size_t len) {
      return g_string_set_size(&this, len);
   }

   // Cuts off the end of the GString, leaving the first @len bytes.
   // RETURNS: @string
   // <len>: the new size of @string
   String* /*new*/ truncate(size_t len) {
      return g_string_truncate(&this, len);
   }

   // Converts a #GString to uppercase.
   // 
   // 
   // Deprecated:2.2: This function uses the locale-specific
   // toupper() function, which is almost never the right thing.
   // Use g_string_ascii_up() or g_utf8_strup() instead.
   // RETURNS: @string
   String* /*new*/ up() {
      return g_string_up(&this);
   }

   // Unintrospectable method: vprintf() / g_string_vprintf()
   // Writes a formatted string into a #GString.
   // This function is similar to g_string_printf() except that
   // the arguments to the format string are passed as a va_list.
   // <format>: the string format. See the printf() documentation
   // <args>: the parameters to insert into the format string
   void vprintf(char* format, va_list args) {
      g_string_vprintf(&this, format, args);
   }
}


// An opaque data structure representing String Chunks. It should only
// be accessed by using the following functions.
struct StringChunk {

   // Frees all strings contained within the #GStringChunk.
   // After calling g_string_chunk_clear() it is not safe to
   // access any of the strings which were contained within it.
   void clear() {
      g_string_chunk_clear(&this);
   }

   // Frees all memory allocated by the #GStringChunk.
   // After calling g_string_chunk_free() it is not safe to
   // access any of the strings which were contained within it.
   void free() {
      g_string_chunk_free(&this);
   }

   // Adds a copy of @string to the #GStringChunk.
   // It returns a pointer to the new copy of the string
   // in the #GStringChunk. The characters in the string
   // can be changed, if necessary, though you should not
   // change anything after the end of the string.
   // 
   // Unlike g_string_chunk_insert_const(), this function
   // does not check for duplicates. Also strings added
   // with g_string_chunk_insert() will not be searched
   // by g_string_chunk_insert_const() when looking for
   // duplicates.
   // 
   // the #GStringChunk
   // RETURNS: a pointer to the copy of @string within
   // <string>: the string to add
   char* /*new*/ insert(char* string_) {
      return g_string_chunk_insert(&this, string_);
   }

   // Adds a copy of @string to the #GStringChunk, unless the same
   // string has already been added to the #GStringChunk with
   // g_string_chunk_insert_const().
   // 
   // This function is useful if you need to copy a large number
   // of strings but do not want to waste space storing duplicates.
   // But you must remember that there may be several pointers to
   // the same string, and so any changes made to the strings
   // should be done very carefully.
   // 
   // Note that g_string_chunk_insert_const() will not return a
   // pointer to a string added with g_string_chunk_insert(), even
   // if they do match.
   // 
   // within the #GStringChunk
   // RETURNS: a pointer to the new or existing copy of @string
   // <string>: the string to add
   char* /*new*/ insert_const(char* string_) {
      return g_string_chunk_insert_const(&this, string_);
   }

   // Adds a copy of the first @len bytes of @string to the #GStringChunk.
   // The copy is nul-terminated.
   // 
   // Since this function does not stop at nul bytes, it is the caller's
   // responsibility to ensure that @string has at least @len addressable
   // bytes.
   // 
   // The characters in the returned string can be changed, if necessary,
   // though you should not change anything after the end of the string.
   // RETURNS: a pointer to the copy of @string within the #GStringChunk
   // <string>: bytes to insert
   // <len>: number of bytes of @string to insert, or -1 to insert a nul-terminated string
   char* /*new*/ insert_len(char* string_, ssize_t len) {
      return g_string_chunk_insert_len(&this, string_, len);
   }

   // Unintrospectable function: new() / g_string_chunk_new()
   // Creates a new #GStringChunk.
   // RETURNS: a new #GStringChunk
   // <size>: the default size of the blocks of memory which are allocated to store the strings. If a particular string is larger than this default size, a larger block of memory will be allocated for it.
   static StringChunk* new_(size_t size) {
      return g_string_chunk_new(size);
   }
}

union SystemThread {
   char[4] data;
   double dummy_double;
   void* dummy_pointer;
   c_long dummy_long;
}

struct TestCase {
}

struct TestConfig {
   int test_initialized, test_quick, test_perf, test_verbose, test_quiet;
}


// The type used for test case functions that take an extra pointer
// argument.
// <user_data>: the data provided when registering the test
extern (C) alias void function (const(void)* user_data) TestDataFunc;


// 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.
// <fixture>: the test fixture
// <user_data>: the data provided when registering the test
extern (C) alias void function (void* fixture, const(void)* user_data) TestFixtureFunc;

// The type used for test case functions.
extern (C) alias void function () TestFunc;

struct TestLogBuffer {
   private String* data;
   private GLib2.SList* msgs;

   // Internal function for gtester to free test log messages, no ABI guarantees provided.
   void free() {
      g_test_log_buffer_free(&this);
   }

   // Unintrospectable method: pop() / g_test_log_buffer_pop()
   // Internal function for gtester to retrieve test log messages, no ABI guarantees provided.
   TestLogMsg* pop() {
      return g_test_log_buffer_pop(&this);
   }
   // Internal function for gtester to decode test log messages, no ABI guarantees provided.
   void push(uint n_bytes, ubyte* bytes) {
      g_test_log_buffer_push(&this, n_bytes, bytes);
   }

   // Unintrospectable function: new() / g_test_log_buffer_new()
   // Internal function for gtester to decode test log messages, no ABI guarantees provided.
   static TestLogBuffer* new_() {
      return g_test_log_buffer_new();
   }
}


// Specifies the prototype of fatal log handler functions.
// RETURNS: %TRUE if the program should abort, %FALSE otherwise
// <log_domain>: the log domain of the message
// <log_level>: the log level of the message (including the fatal and recursion flags)
// <message>: the message to process
// <user_data>: user data, set in g_test_log_set_fatal_handler()
extern (C) alias int function (char* log_domain, LogLevelFlags log_level, char* message, void* user_data) TestLogFatalFunc;

struct TestLogMsg {
   TestLogType log_type;
   uint n_strings;
   char** strings;
   uint n_nums;
   c_long* nums;

   // Internal function for gtester to free test log messages, no ABI guarantees provided.
   void free() {
      g_test_log_msg_free(&this);
   }
}

enum TestLogType {
   NONE = 0,
   ERROR = 1,
   START_BINARY = 2,
   LIST_CASE = 3,
   SKIP_CASE = 4,
   START_CASE = 5,
   STOP_CASE = 6,
   MIN_RESULT = 7,
   MAX_RESULT = 8,
   MESSAGE = 9
}
struct TestSuite {

   // Adds @test_case to @suite.
   // <test_case>: a #GTestCase
   void add(TestCase* test_case) {
      g_test_suite_add(&this, test_case);
   }

   // Adds @nestedsuite to @suite.
   // <nestedsuite>: another #GTestSuite
   void add_suite(TestSuite* nestedsuite) {
      g_test_suite_add_suite(&this, nestedsuite);
   }
}

enum TestTrapFlags {
   SILENCE_STDOUT = 128,
   SILENCE_STDERR = 256,
   INHERIT_STDIN = 512
}

// The #GThread struct represents a running thread. It has three public
// read-only members, but the underlying struct is bigger, so you must
// not copy this struct.
// 
// <note><para>Resources for a joinable thread are not fully released
// until g_thread_join() is called for that thread.</para></note>
struct Thread {
   private ThreadFunc func;
   private void* data;
   private int joinable;
   private ThreadPriority priority;


   // Unintrospectable method: join() / g_thread_join()
   // Waits until @thread finishes, i.e. the function @func, as given to
   // g_thread_create(), returns or g_thread_exit() is called by @thread.
   // All resources of @thread including the #GThread struct are released.
   // @thread must have been created with @joinable=%TRUE in
   // g_thread_create(). The value returned by @func or given to
   // g_thread_exit() by @thread is returned by this function.
   void* join() {
      return g_thread_join(&this);
   }

   // Changes the priority of @thread to @priority.
   // 
   // <note><para>It is not guaranteed that threads with different
   // priorities really behave accordingly. On some systems (e.g. Linux)
   // there are no thread priorities. On other systems (e.g. Solaris) there
   // doesn't seem to be different scheduling for different priorities. All
   // in all try to avoid being dependent on priorities.</para></note>
   // <priority>: a new priority for @thread.
   void set_priority(ThreadPriority priority) {
      g_thread_set_priority(&this, priority);
   }

   // Unintrospectable function: create_full() / g_thread_create_full()
   // This function creates a new thread with the priority @priority. If
   // the underlying thread implementation supports it, the thread gets a
   // stack size of @stack_size or the default value for the current
   // platform, if @stack_size is 0.
   // 
   // If @joinable is %TRUE, you can wait for this threads termination
   // calling g_thread_join(). Otherwise the thread will just disappear
   // when it terminates. If @bound is %TRUE, this thread will be
   // scheduled in the system scope, otherwise the implementation is free
   // to do scheduling in the process scope. The first variant is more
   // expensive resource-wise, but generally faster. On some systems (e.g.
   // Linux) all threads are bound.
   // 
   // The new thread executes the function @func 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.
   // 
   // <note><para>It is not guaranteed that threads with different priorities
   // really behave accordingly. On some systems (e.g. Linux) there are no
   // thread priorities. On other systems (e.g. Solaris) there doesn't
   // seem to be different scheduling for different priorities. All in all
   // try to avoid being dependent on priorities. Use
   // %G_THREAD_PRIORITY_NORMAL here as a default.</para></note>
   // 
   // <note><para>Only use g_thread_create_full() if you really can't use
   // g_thread_create() instead. g_thread_create() does not take
   // @stack_size, @bound, and @priority as arguments, as they should only
   // be used in cases in which it is unavoidable.</para></note>
   // <func>: a function to execute in the new thread.
   // <data>: an argument to supply to the new thread.
   // <stack_size>: a stack size for the new thread.
   // <joinable>: should this thread be joinable?
   // <bound>: should this thread be bound to a system thread?
   // <priority>: a priority for the thread.
   static Thread* create_full(ThreadFunc func, void* data, c_ulong stack_size, int joinable, int bound, ThreadPriority priority, GLib2.Error** error=null) {
      return g_thread_create_full(func, data, stack_size, joinable, bound, priority, error);
   }
   static Quark error_quark() {
      return g_thread_error_quark();
   }

   // Exits the current thread. If another thread is waiting for that
   // thread using g_thread_join() and the current thread is joinable, the
   // waiting thread will be woken up and get @retval as the return value
   // of g_thread_join(). If the current thread is not joinable, @retval
   // is ignored. Calling
   // 
   // <informalexample>
   // <programlisting>
   // g_thread_exit (retval);
   // </programlisting>
   // </informalexample>
   // 
   // is equivalent to returning @retval from the function @func, as given
   // to g_thread_create().
   // 
   // <note><para>Never call g_thread_exit() from within a thread of a
   // #GThreadPool, as that will mess up the bookkeeping and lead to funny
   // and unwanted results.</para></note>
   // <retval>: the return value of this thread.
   static void exit(void* retval) {
      g_thread_exit(retval);
   }

   // Unintrospectable function: foreach() / g_thread_foreach()
   // Call @thread_func on all existing #GThread structures. Note that
   // threads may decide to exit while @thread_func 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>: function to call for all GThread structures
   // <user_data>: second argument to @thread_func
   static void foreach_(Func thread_func, void* user_data) {
      g_thread_foreach(thread_func, user_data);
   }

   // Indicates if g_thread_init() has been called.
   // RETURNS: %TRUE if threads have been initialized.
   static int get_initialized() {
      return g_thread_get_initialized();
   }

   // If you use GLib from more than one thread, you must initialize the
   // thread system by calling g_thread_init(). Most of the time you will
   // only have to call <literal>g_thread_init (NULL)</literal>.
   // 
   // <note><para>Do not call g_thread_init() with a non-%NULL parameter unless
   // you really know what you are doing.</para></note>
   // 
   // <note><para>g_thread_init() must not be called directly or indirectly as a
   // callback from GLib. Also no mutexes may be currently locked while
   // calling g_thread_init().</para></note>
   // 
   // <note><para>g_thread_init() changes the way in which #GTimer measures
   // elapsed time. As a consequence, timers that are running while
   // g_thread_init() is called may report unreliable times.</para></note>
   // 
   // Calling g_thread_init() multiple times is allowed (since version
   // 2.24), but nothing happens except for the first call. If the
   // argument is non-%NULL on such a call a warning will be printed, but
   // otherwise the argument is ignored.
   // 
   // If no thread system is available and @vtable is %NULL or if not all
   // elements of @vtable are non-%NULL, then g_thread_init() will abort.
   // 
   // <note><para>To use g_thread_init() in your program, you have to link with
   // the libraries that the command <command>pkg-config --libs
   // gthread-2.0</command> outputs. 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.</para></note>
   // <vtable>: a function table of type #GThreadFunctions, that provides the entry points to the thread system to be used.
   static void init(ThreadFunctions* vtable) {
      g_thread_init(vtable);
   }
   static void init_with_errorcheck_mutexes(ThreadFunctions* vtable) {
      g_thread_init_with_errorcheck_mutexes(vtable);
   }

   // Unintrospectable function: self() / g_thread_self()
   // This functions returns the #GThread corresponding to the calling
   // thread.
   static Thread* self() {
      return g_thread_self();
   }
}

// Possible errors of thread related functions.
enum ThreadError {
   THREAD_ERROR_AGAIN = 0
}

// Unintrospectable callback: ThreadFunc() / ()
// Specifies the type of the @func functions passed to
// g_thread_create() or g_thread_create_full().
// <data>: data passed to the thread.
extern (C) alias void* function (void* data) ThreadFunc;


// This function table is used by g_thread_init() to initialize the
// thread system. The functions in the table are directly used by their
// g_* prepended counterparts (described in this document).  For
// example, if you call g_mutex_new() then mutex_new() from the table
// provided to g_thread_init() will be called.
// 
// <note><para>Do not use this struct unless you know what you are
// doing.</para></note>
struct ThreadFunctions {
   // Unintrospectable functionp: mutex_new() / ()
   extern (C) Mutex* function () mutex_new;
   extern (C) void function (Mutex* mutex) mutex_lock;
   extern (C) int function (Mutex* mutex) mutex_trylock;
   extern (C) void function (Mutex* mutex) mutex_unlock;
   extern (C) void function (Mutex* mutex) mutex_free;
   // Unintrospectable functionp: cond_new() / ()
   extern (C) Cond* function () cond_new;
   extern (C) void function (Cond* cond) cond_signal;
   extern (C) void function (Cond* cond) cond_broadcast;
   extern (C) void function (Cond* cond, Mutex* mutex) cond_wait;
   extern (C) int function (Cond* cond, Mutex* mutex, TimeVal* end_time) cond_timed_wait;
   extern (C) void function (Cond* cond) cond_free;
   // Unintrospectable functionp: private_new() / ()
   extern (C) Private* function (DestroyNotify destructor) private_new;
   // Unintrospectable functionp: private_get() / ()
   extern (C) void* function (Private* private_key) private_get;
   extern (C) void function (Private* private_key, void* data) private_set;
   // Unintrospectable functionp: thread_create() / ()
   extern (C) void function (ThreadFunc func, void* data, c_ulong stack_size, int joinable, int bound, ThreadPriority priority, void* thread, GLib2.Error** error=null) thread_create;
   extern (C) void function () thread_yield;
   extern (C) void function (void* thread) thread_join;
   extern (C) void function () thread_exit;
   extern (C) void function (void* thread, ThreadPriority priority) thread_set_priority;
   extern (C) void function (void* thread) thread_self;
   extern (C) int function (void* thread1, void* thread2) thread_equal;
}


// The #GThreadPool struct represents a thread pool. It has three
// public read-only members, but the underlying struct is bigger, so
// you must not copy this struct.
struct ThreadPool {
   Func func;
   void* user_data;
   int exclusive;


   // Frees all resources allocated for @pool.
   // 
   // If @immediate is %TRUE, no new task is processed for
   // @pool. Otherwise @pool is not freed before the last task is
   // processed. Note however, that no thread of this pool is
   // interrupted, while processing a task. Instead at least all still
   // running threads can finish their tasks before the @pool is freed.
   // 
   // If @wait_ is %TRUE, the functions does not return before all tasks
   // to be processed (dependent on @immediate, whether all or only the
   // currently running) are ready. Otherwise the function returns immediately.
   // 
   // After calling this function @pool must not be used anymore.
   // <immediate>: should @pool shut down immediately?
   // <wait_>: should the function wait for all tasks to be finished?
   void free(int immediate, int wait_) {
      g_thread_pool_free(&this, immediate, wait_);
   }

   // Returns the maximal number of threads for @pool.
   // RETURNS: the maximal number of threads
   int get_max_threads() {
      return g_thread_pool_get_max_threads(&this);
   }

   // Returns the number of threads currently running in @pool.
   // RETURNS: the number of threads currently running
   uint get_num_threads() {
      return g_thread_pool_get_num_threads(&this);
   }

   // Inserts @data into the list of tasks to be executed by @pool. When
   // the number of currently running threads is lower than the maximal
   // allowed number of threads, a new thread is started (or reused) with
   // the properties given to g_thread_pool_new (). Otherwise @data stays
   // in the queue until a thread in this pool finishes its previous task
   // and processes @data.
   // 
   // @error can be %NULL to ignore errors, or non-%NULL to report
   // errors. An error can only occur when a new thread couldn't be
   // created. In that case @data is simply appended to the queue of work
   // to do.
   // <data>: a new task for @pool
   void push(void* data, GLib2.Error** error=null) {
      g_thread_pool_push(&this, data, error);
   }

   // Sets the maximal allowed number of threads for @pool. A value of -1
   // means, that the maximal number of threads is unlimited.
   // 
   // Setting @max_threads to 0 means stopping all work for @pool. It is
   // effectively frozen until @max_threads is set to a non-zero value
   // again.
   // 
   // A thread is never terminated while calling @func, as supplied by
   // g_thread_pool_new (). Instead the maximal number of threads only
   // has effect for the allocation of new threads in g_thread_pool_push().
   // A new thread is allocated, whenever the number of currently
   // running threads in @pool is smaller than the maximal number.
   // 
   // @error can be %NULL to ignore errors, or non-%NULL to report
   // errors. An error can only occur when a new thread couldn't be
   // created.
   // <max_threads>: a new maximal number of threads for @pool
   void set_max_threads(int max_threads, GLib2.Error** error=null) {
      g_thread_pool_set_max_threads(&this, max_threads, error);
   }

   // Unintrospectable method: set_sort_function() / g_thread_pool_set_sort_function()
   // Sets the function used to sort the list of tasks. This allows the
   // tasks to be processed by a priority determined by @func, and not
   // just in the order in which they were added to the pool.
   // 
   // Note, if the maximum number of threads is more than 1, the order
   // that threads are executed cannot be guaranteed 100%. Threads are
   // scheduled by the operating system and are executed at random. It
   // cannot be assumed that threads are executed in the order they are
   // created.
   // <func>: the #GCompareDataFunc used to sort the list of tasks. This function is passed two tasks. It should return 0 if the order in which they are handled does not matter, a negative value if the first task should be processed before the second or a positive value if the second task should be processed first.
   // <user_data>: user data passed to @func.
   void set_sort_function(CompareDataFunc func, void* user_data) {
      g_thread_pool_set_sort_function(&this, func, user_data);
   }

   // Returns the number of tasks still unprocessed in @pool.
   // RETURNS: the number of unprocessed tasks
   uint unprocessed() {
      return g_thread_pool_unprocessed(&this);
   }

   // 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.
   // 
   // thread pool before stopping the thread (1/1000ths of a second).
   // RETURNS: the maximum @interval to wait for new tasks in the
   static uint get_max_idle_time() {
      return g_thread_pool_get_max_idle_time();
   }

   // Returns the maximal allowed number of unused threads.
   // RETURNS: the maximal number of unused threads
   static int get_max_unused_threads() {
      return g_thread_pool_get_max_unused_threads();
   }

   // Returns the number of currently unused threads.
   // RETURNS: the number of currently unused threads
   static uint get_num_unused_threads() {
      return g_thread_pool_get_num_unused_threads();
   }

   // Unintrospectable function: new() / g_thread_pool_new()
   // This function creates a new thread pool.
   // 
   // Whenever you call g_thread_pool_push(), either a new thread is
   // created or an unused one is reused. At most @max_threads threads
   // are running concurrently for this thread pool. @max_threads = -1
   // allows unlimited threads to be created for this thread pool. The
   // newly created or reused thread now executes the function @func with
   // the two arguments. The first one is the parameter to
   // g_thread_pool_push() and the second one is @user_data.
   // 
   // The parameter @exclusive determines, whether the thread pool owns
   // all threads exclusive or whether the threads are shared
   // globally. If @exclusive is %TRUE, @max_threads threads are started
   // immediately and they will run exclusively for this thread pool until
   // it is destroyed by g_thread_pool_free(). If @exclusive is %FALSE,
   // threads are created, when needed and shared between all
   // non-exclusive thread pools. This implies that @max_threads may not
   // be -1 for exclusive thread pools.
   // 
   // @error can be %NULL to ignore errors, or non-%NULL to report
   // errors. An error can only occur when @exclusive is set to %TRUE and
   // not all @max_threads threads could be created.
   // RETURNS: the new #GThreadPool
   // <func>: a function to execute in the threads of the new thread pool
   // <user_data>: user data that is handed over to @func every time it is called
   // <max_threads>: the maximal number of threads to execute concurrently in the new thread pool, -1 means no limit
   // <exclusive>: should this thread pool be exclusive?
   static ThreadPool* new_(Func func, void* user_data, int max_threads, int exclusive, GLib2.Error** error=null) {
      return g_thread_pool_new(func, user_data, max_threads, exclusive, error);
   }

   // 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.
   // 
   // This function makes use of g_async_queue_timed_pop () using
   // @interval.
   // <interval>: the maximum @interval (1/1000ths of a second) a thread can be idle.
   static void set_max_idle_time(uint interval) {
      g_thread_pool_set_max_idle_time(interval);
   }

   // Sets the maximal number of unused threads to @max_threads. If
   // @max_threads is -1, no limit is imposed on the number of unused
   // threads.
   // <max_threads>: maximal number of unused threads
   static void set_max_unused_threads(int max_threads) {
      g_thread_pool_set_max_unused_threads(max_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().
   static void stop_unused_threads() {
      g_thread_pool_stop_unused_threads();
   }
}


// Specifies the priority of a thread.
// 
// <note><para>It is not guaranteed that threads with different priorities
// really behave accordingly. On some systems (e.g. Linux) there are no
// thread priorities. On other systems (e.g. Solaris) there doesn't
// seem to be different scheduling for different priorities. All in all
// try to avoid being dependent on priorities.</para></note>
enum ThreadPriority {
   LOW = 0,
   NORMAL = 1,
   HIGH = 2,
   URGENT = 3
}

// Disambiguates a given time in two ways.
// 
// First, specifies if the given time is in universal or local time.
// 
// Second, if the time is in local time, specifies if it is local
// standard time or local daylight time.  This is important for the case
// where the same local time occurs twice (during daylight savings time
// transitions, for example).
enum TimeType {
   STANDARD = 0,
   DAYLIGHT = 1,
   UNIVERSAL = 2
}
struct TimeVal {
   c_long tv_sec, tv_usec;


   // Adds the given number of microseconds to @time_. @microseconds can
   // also be negative to decrease the value of @time_.
   // <microseconds>: number of microseconds to add to @time
   void add(c_long microseconds) {
      g_time_val_add(&this, microseconds);
   }

   // Converts @time_ into an ISO 8601 encoded string, relative to the
   // Coordinated Universal Time (UTC).
   // RETURNS: a newly allocated string containing an ISO 8601 date
   char* /*new*/ to_iso8601() {
      return g_time_val_to_iso8601(&this);
   }

   // Converts a string containing an ISO 8601 encoded date and time
   // to a #GTimeVal and puts it into @time_.
   // RETURNS: %TRUE if the conversion was successful.
   // <iso_date>: an ISO 8601 encoded date string
   // <time_>: a #GTimeVal
   static int from_iso8601(char* iso_date, TimeVal* time_) {
      return g_time_val_from_iso8601(iso_date, time_);
   }
}


// #GDateTime is an opaque structure whose members cannot be accessed
// directly.
struct TimeZone /* Version 2.26 */ {

   // Finds an interval within @tz that corresponds to the given @time_,
   // possibly adjusting @time_ if required to fit into an interval.
   // The meaning of @time_ depends on @type.
   // 
   // This function is similar to g_time_zone_find_interval(), with the
   // difference that it always succeeds (by making the adjustments
   // described below).
   // 
   // In any of the cases where g_time_zone_find_interval() succeeds then
   // this function returns the same value, without modifying @time_.
   // 
   // This function may, however, modify @time_ in order to deal with
   // non-existent times.  If the non-existent local @time_ of 02:30 were
   // requested on March 13th 2010 in Toronto then this function would
   // adjust @time_ to be 03:00 and return the interval containing the
   // adjusted time.
   // RETURNS: the interval containing @time_, never -1
   // <type>: the #GTimeType of @time_
   // <time_>: a pointer to a number of seconds since January 1, 1970
   int adjust_time(TimeType type, long* time_) {
      return g_time_zone_adjust_time(&this, type, time_);
   }

   // Finds an the interval within @tz that corresponds to the given @time_.
   // The meaning of @time_ depends on @type.
   // 
   // If @type is %G_TIME_TYPE_UNIVERSAL then this function will always
   // succeed (since universal time is monotonic and continuous).
   // 
   // Otherwise @time_ is treated is local time.  The distinction between
   // %G_TIME_TYPE_STANDARD and %G_TIME_TYPE_DAYLIGHT is ignored except in
   // the case that the given @time_ is ambiguous.  In Toronto, for example,
   // 01:30 on November 7th 2010 occurred twice (once inside of daylight
   // savings time and the next, an hour later, outside of daylight savings
   // time).  In this case, the different value of @type would result in a
   // different interval being returned.
   // 
   // It is still possible for this function to fail.  In Toronto, for
   // example, 02:00 on March 14th 2010 does not exist (due to the leap
   // forward to begin daylight savings time).  -1 is returned in that
   // case.
   // RETURNS: the interval containing @time_, or -1 in case of failure
   // <type>: the #GTimeType of @time_
   // <time_>: a number of seconds since January 1, 1970
   int find_interval(TimeType type, long time_) {
      return g_time_zone_find_interval(&this, type, time_);
   }

   // Determines the time zone abbreviation to be used during a particular
   // @interval of time in the time zone @tz.
   // 
   // For example, in Toronto this is currently "EST" during the winter
   // months and "EDT" during the summer months when daylight savings time
   // is in effect.
   // RETURNS: the time zone abbreviation, which belongs to @tz
   // <interval>: an interval within the timezone
   char* get_abbreviation(int interval) {
      return g_time_zone_get_abbreviation(&this, interval);
   }

   // Determines the offset to UTC in effect during a particular @interval
   // of time in the time zone @tz.
   // 
   // The offset is the number of seconds that you add to UTC time to
   // arrive at local time for @tz (ie: negative numbers for time zones
   // west of GMT, positive numbers for east).
   // 
   // local time in @tz
   // RETURNS: the number of seconds that should be added to UTC to get the
   // <interval>: an interval within the timezone
   int get_offset(int interval) {
      return g_time_zone_get_offset(&this, interval);
   }

   // Determines if daylight savings time is in effect during a particular
   // @interval of time in the time zone @tz.
   // RETURNS: %TRUE if daylight savings time is in effect
   // <interval>: an interval within the timezone
   int is_dst(int interval) {
      return g_time_zone_is_dst(&this, interval);
   }

   // Unintrospectable method: ref() / g_time_zone_ref()
   // Increases the reference count on @tz.
   // RETURNS: a new reference to @tz.
   TimeZone* ref_() {
      return g_time_zone_ref(&this);
   }
   // Decreases the reference count on @tz.
   void unref() {
      g_time_zone_unref(&this);
   }

   // Unintrospectable function: new() / g_time_zone_new()
   // Creates a #GTimeZone corresponding to @identifier.
   // 
   // @identifier can either be an RFC3339/ISO 8601 time offset or
   // something that would pass as a valid value for the
   // <varname>TZ</varname> environment variable (including %NULL).
   // 
   // Valid RFC3339 time offsets are <literal>"Z"</literal> (for UTC) or
   // <literal>"±hh:mm"</literal>.  ISO 8601 additionally specifies
   // <literal>"±hhmm"</literal> and <literal>"±hh"</literal>.
   // 
   // The <varname>TZ</varname> environment variable typically corresponds
   // to the name of a file in the zoneinfo database, but there are many
   // other possibilities.  Note that those other possibilities are not
   // currently implemented, but are planned.
   // 
   // g_time_zone_new_local() calls this function with the value of the
   // <varname>TZ</varname> environment variable.  This function itself is
   // independent of the value of <varname>TZ</varname>, but if @identifier
   // is %NULL then <filename>/etc/localtime</filename> will be consulted
   // to discover the correct timezone.
   // 
   // See <ulink
   // url='http://tools.ietf.org/html/rfc3339#section-5.6'>RFC3339
   // §5.6</ulink> for a precise definition of valid RFC3339 time offsets
   // (the <varname>time-offset</varname> expansion) and ISO 8601 for the
   // full list of valid time offsets.  See <ulink
   // url='http://www.gnu.org/s/libc/manual/html_node/TZ-Variable.html'>The
   // GNU C Library manual</ulink> for an explanation of the possible
   // values of the <varname>TZ</varname> environment variable.
   // 
   // You should release the return value by calling g_time_zone_unref()
   // when you are done with it.
   // RETURNS: the requested timezone
   // <identifier>: a timezone identifier
   static TimeZone* new_(char* identifier=null) {
      return g_time_zone_new(identifier);
   }

   // Unintrospectable function: new_local() / g_time_zone_new_local()
   // Creates a #GTimeZone corresponding to local time.  The local time
   // zone may change between invocations to this function; for example,
   // if the system administrator changes it.
   // 
   // This is equivalent to calling g_time_zone_new() with the value of the
   // <varname>TZ</varname> environment variable (including the possibility
   // of %NULL).
   // 
   // You should release the return value by calling g_time_zone_unref()
   // when you are done with it.
   // RETURNS: the local timezone
   static TimeZone* new_local() {
      return g_time_zone_new_local();
   }

   // Unintrospectable function: new_utc() / g_time_zone_new_utc()
   // Creates a #GTimeZone corresponding to UTC.
   // 
   // This is equivalent to calling g_time_zone_new() with a value like
   // "Z", "UTC", "+00", etc.
   // 
   // You should release the return value by calling g_time_zone_unref()
   // when you are done with it.
   // RETURNS: the universal timezone
   static TimeZone* new_utc() {
      return g_time_zone_new_utc();
   }
}

// Opaque datatype that records a start time.
struct Timer {

   // Resumes a timer that has previously been stopped with
   // g_timer_stop(). g_timer_stop() must be called before using this
   // function.
   void continue_() {
      g_timer_continue(&this);
   }
   // Destroys a timer, freeing associated resources.
   void destroy() {
      g_timer_destroy(&this);
   }

   // If @timer has been started but not stopped, obtains the time since
   // the timer was started. If @timer has been stopped, obtains the
   // elapsed time between the time it was started and the time it was
   // stopped. The return value is the number of seconds elapsed,
   // including any fractional part. The @microseconds out parameter is
   // essentially useless.
   // 
   // <warning><para>
   // Calling initialization functions, in particular g_thread_init(), while a
   // timer is running will cause invalid return values from this function.
   // </para></warning>
   // <microseconds>: return location for the fractional part of seconds elapsed, in microseconds (that is, the total number of microseconds elapsed, modulo 1000000), or %NULL
   double elapsed(c_ulong* microseconds) {
      return g_timer_elapsed(&this, microseconds);
   }

   // This function is useless; it's fine to call g_timer_start() on an
   // already-started timer to reset the start time, so g_timer_reset()
   // serves no purpose.
   void reset() {
      g_timer_reset(&this);
   }

   // Marks a start time, so that future calls to g_timer_elapsed() will
   // report the time since g_timer_start() was called. g_timer_new()
   // automatically marks the start time, so no need to call
   // g_timer_start() immediately after creating the timer.
   void start() {
      g_timer_start(&this);
   }

   // Marks an end time, so calls to g_timer_elapsed() will return the
   // difference between this end time and the start time.
   void stop() {
      g_timer_stop(&this);
   }

   // Unintrospectable function: new() / g_timer_new()
   // Creates a new timer, and starts timing (i.e. g_timer_start() is
   // implicitly called for you).
   static Timer* new_() {
      return g_timer_new();
   }
}

enum TokenType {
   EOF = 0,
   LEFT_PAREN = 40,
   RIGHT_PAREN = 41,
   LEFT_CURLY = 123,
   RIGHT_CURLY = 125,
   LEFT_BRACE = 91,
   RIGHT_BRACE = 93,
   EQUAL_SIGN = 61,
   COMMA = 44,
   NONE = 256,
   ERROR = 257,
   CHAR = 258,
   BINARY = 259,
   OCTAL = 260,
   INT = 261,
   HEX = 262,
   FLOAT = 263,
   STRING = 264,
   SYMBOL = 265,
   IDENTIFIER = 266,
   IDENTIFIER_NULL = 267,
   COMMENT_SINGLE = 268,
   COMMENT_MULTI = 269,
   LAST = 270
}
union TokenValue {
   void* v_symbol;
   char* v_identifier;
   c_ulong v_binary, v_octal, v_int;
   ulong v_int64;
   double v_float;
   c_ulong v_hex;
   char* v_string, v_comment;
   ubyte v_char;
   uint v_error;
}


// The type of functions which are used to translate user-visible
// strings, for <option>--help</option> output.
// 
// The returned string is owned by GLib and must not be freed.
// RETURNS: a translation of the string for the current locale.
// <str>: the untranslated string
// <data>: user data specified when installing the function, e.g. in g_option_group_set_translate_func()
extern (C) alias char* function (char* str, void* data) TranslateFunc;

struct TrashStack {
   TrashStack* next;

   static uint height(TrashStack** stack_p) {
      return g_trash_stack_height(stack_p);
   }
   // Unintrospectable function: peek() / g_trash_stack_peek()
   static void* peek(TrashStack** stack_p) {
      return g_trash_stack_peek(stack_p);
   }
   // Unintrospectable function: pop() / g_trash_stack_pop()
   static void* pop(TrashStack** stack_p) {
      return g_trash_stack_pop(stack_p);
   }
   static void push(TrashStack** stack_p, void* data_p) {
      g_trash_stack_push(stack_p, data_p);
   }
}


// Specifies which nodes are visited during several of the tree
// functions, including g_node_traverse() and g_node_find().
enum TraverseFlags {
   LEAVES = 1,
   NON_LEAVES = 2,
   ALL = 3,
   MASK = 3,
   LEAFS = 1,
   NON_LEAFS = 2
}

// 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.
// <key>: a key of a #GTree node.
// <value>: the value corresponding to the key.
// <data>: user data passed to g_tree_traverse().
extern (C) alias int function (void* key, void* value, void* data) TraverseFunc;


// Specifies the type of traveral performed by g_tree_traverse(),
// g_node_traverse() and g_node_find().
enum TraverseType {
   IN_ORDER = 0,
   PRE_ORDER = 1,
   POST_ORDER = 2,
   LEVEL_ORDER = 3
}

// The <structname>GTree</structname> struct is an opaque data
// structure representing a <link
// linkend="glib-Balanced-Binary-Trees">Balanced Binary Tree</link>. It
// should be accessed only by using the following functions.
struct Tree {

   // Removes all keys and values from the #GTree and decreases its
   // reference count by one. If keys and/or values are dynamically
   // allocated, you should either free them first or create the #GTree
   // using g_tree_new_full().  In the latter case the destroy functions
   // you supplied will be called on all keys and values before destroying
   // the #GTree.
   void destroy() {
      g_tree_destroy(&this);
   }

   // Unintrospectable method: foreach() / g_tree_foreach()
   // Calls the given function for each of the key/value pairs in the #GTree.
   // The function is passed the key and value of each pair, and the given
   // @data parameter. The tree is traversed in sorted order.
   // 
   // The tree may not be modified while iterating over it (you can't
   // add/remove items). To remove all items matching a predicate, you need
   // to add each item to a list in your #GTraverseFunc as you walk over
   // the tree, then walk the list and remove each item.
   // <func>: the function to call for each node visited. If this function returns %TRUE, the traversal is stopped.
   // <user_data>: user data to pass to the function.
   void foreach_(TraverseFunc func, void* user_data) {
      g_tree_foreach(&this, func, user_data);
   }

   // Gets the height of a #GTree.
   // 
   // If the #GTree contains no nodes, the height is 0.
   // If the #GTree contains only one root node the height is 1.
   // If the root node has children the height is 2, etc.
   // RETURNS: the height of the #GTree.
   int height() {
      return g_tree_height(&this);
   }

   // Inserts a key/value pair into a #GTree. If the given key already exists
   // in the #GTree its corresponding value is set to the new value. If you
   // supplied a value_destroy_func when creating the #GTree, the old value is
   // freed using that function. If you supplied a @key_destroy_func when
   // creating the #GTree, the passed key is freed using that function.
   // 
   // The tree is automatically 'balanced' as new key/value pairs are added,
   // so that the distance from the root to every leaf is as small as possible.
   // <key>: the key to insert.
   // <value>: the value corresponding to the key.
   void insert(void* key, void* value) {
      g_tree_insert(&this, key, value);
   }

   // Unintrospectable method: lookup() / g_tree_lookup()
   // Gets the value corresponding to the given key. Since a #GTree is
   // automatically balanced as key/value pairs are added, key lookup is very
   // fast.
   // 
   // not found.
   // RETURNS: the value corresponding to the key, or %NULL if the key was
   // <key>: the key to look up.
   void* lookup(const(void)* key) {
      return g_tree_lookup(&this, key);
   }

   // Looks up a key in the #GTree, 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_tree_remove().
   // RETURNS: %TRUE if the key was found in the #GTree.
   // <lookup_key>: the key to look up.
   // <orig_key>: returns the original key.
   // <value>: returns the value associated with the key.
   int lookup_extended(const(void)* lookup_key, void** orig_key, void** value) {
      return g_tree_lookup_extended(&this, lookup_key, orig_key, value);
   }

   // Gets the number of nodes in a #GTree.
   // RETURNS: the number of nodes in the #GTree.
   int nnodes() {
      return g_tree_nnodes(&this);
   }

   // Unintrospectable method: ref() / g_tree_ref()
   // Increments the reference count of @tree by one.  It is safe to call
   // this function from any thread.
   // RETURNS: the passed in #GTree.
   Tree* ref_() {
      return g_tree_ref(&this);
   }

   // Removes a key/value pair from a #GTree.
   // 
   // If the #GTree was created using g_tree_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.
   // If the key does not exist in the #GTree, the function does nothing.
   // 
   // nothing)
   // RETURNS: %TRUE if the key was found (prior to 2.8, this function returned
   // <key>: the key to remove.
   int remove(const(void)* key) {
      return g_tree_remove(&this, key);
   }

   // Inserts a new key and value into a #GTree similar to g_tree_insert().
   // The difference is that if the key already exists in the #GTree, it gets
   // replaced by the new key. If you supplied a @value_destroy_func when
   // creating the #GTree, the old value is freed using that function. If you
   // supplied a @key_destroy_func when creating the #GTree, the old key is
   // freed using that function.
   // 
   // The tree is automatically 'balanced' as new key/value pairs are added,
   // so that the distance from the root to every leaf is as small as possible.
   // <key>: the key to insert.
   // <value>: the value corresponding to the key.
   void replace(void* key, void* value) {
      g_tree_replace(&this, key, value);
   }

   // Unintrospectable method: search() / g_tree_search()
   // Searches a #GTree using @search_func.
   // 
   // The @search_func is called with a pointer to the key of a key/value
   // pair in the tree, and the passed in @user_data. If @search_func returns
   // 0 for a key/value pair, then the corresponding value is returned as
   // the result of g_tree_search(). If @search_func returns -1, searching
   // will proceed among the key/value pairs that have a smaller key; if
   // @search_func returns 1, searching will proceed among the key/value
   // pairs that have a larger key.
   // 
   // the key was not found.
   // RETURNS: the value corresponding to the found key, or %NULL if
   // <search_func>: a function used to search the #GTree
   // <user_data>: the data passed as the second argument to @search_func
   void* search(CompareFunc search_func, const(void)* user_data) {
      return g_tree_search(&this, search_func, user_data);
   }

   // Removes a key and its associated value from a #GTree without calling
   // the key and value destroy functions.
   // 
   // If the key does not exist in the #GTree, the function does nothing.
   // 
   // nothing)
   // RETURNS: %TRUE if the key was found (prior to 2.8, this function returned
   // <key>: the key to remove.
   int steal(const(void)* key) {
      return g_tree_steal(&this, key);
   }

   // Unintrospectable method: traverse() / g_tree_traverse()
   // Calls the given function for each node in the #GTree.
   // 
   // Deprecated:2.2: The order of a balanced tree is somewhat arbitrary. If you
   // just want to visit all nodes in sorted order, use g_tree_foreach()
   // instead. If you really need to visit nodes in a different order, consider
   // using an <link linkend="glib-N-ary-Trees">N-ary Tree</link>.
   // <traverse_func>: the function to call for each node visited. If this function returns %TRUE, the traversal is stopped.
   // <traverse_type>: the order in which nodes are visited, one of %G_IN_ORDER, %G_PRE_ORDER and %G_POST_ORDER.
   // <user_data>: user data to pass to the function.
   void traverse(TraverseFunc traverse_func, TraverseType traverse_type, void* user_data) {
      g_tree_traverse(&this, traverse_func, traverse_type, user_data);
   }

   // Decrements the reference count of @tree by one.  If the reference count
   // drops to 0, all keys and values will be destroyed (if destroy
   // functions were specified) and all memory allocated by @tree will be
   // released.
   // 
   // It is safe to call this function from any thread.
   void unref() {
      g_tree_unref(&this);
   }

   // Unintrospectable function: new() / g_tree_new()
   // Creates a new #GTree.
   // RETURNS: a new #GTree.
   // <key_compare_func>: the function used to order the nodes in the #GTree. It should return values similar to the standard strcmp() function - 0 if the two arguments are equal, a negative value if the first argument comes before the second, or a positive value if the first argument comes after the second.
   static Tree* new_(CompareFunc key_compare_func) {
      return g_tree_new(key_compare_func);
   }

   // Unintrospectable function: new_full() / g_tree_new_full()
   // Creates a new #GTree like g_tree_new() and allows to specify functions
   // to free the memory allocated for the key and value that get called when
   // removing the entry from the #GTree.
   // RETURNS: a new #GTree.
   // <key_compare_func>: qsort()-style comparison function.
   // <key_compare_data>: data to pass to comparison function.
   // <key_destroy_func>: a function to free the memory allocated for the key used when removing the entry from the #GTree or %NULL if you don't want to supply such a function.
   // <value_destroy_func>: a function to free the memory allocated for the value used when removing the entry from the #GTree or %NULL if you don't want to supply such a function.
   static Tree* new_full(CompareDataFunc key_compare_func, void* key_compare_data, DestroyNotify key_destroy_func, DestroyNotify value_destroy_func) {
      return g_tree_new_full(key_compare_func, key_compare_data, key_destroy_func, value_destroy_func);
   }

   // Unintrospectable function: new_with_data() / g_tree_new_with_data()
   // Creates a new #GTree with a comparison function that accepts user data.
   // See g_tree_new() for more details.
   // RETURNS: a new #GTree.
   // <key_compare_func>: qsort()-style comparison function.
   // <key_compare_data>: data to pass to comparison function.
   static Tree* new_with_data(CompareDataFunc key_compare_func, void* key_compare_data) {
      return g_tree_new_with_data(key_compare_func, key_compare_data);
   }
}


// The #GTuples struct is used to return records (or tuples) from the
// #GRelation by g_relation_select(). It only contains one public
// member - the number of records that matched. To access the matched
// records, you must use g_tuples_index().
struct Tuples {
   uint len;


   // Frees the records which were returned by g_relation_select(). This
   // should always be called after g_relation_select() when you are
   // finished with the records. The records are not removed from the
   // #GRelation.
   void destroy() {
      g_tuples_destroy(&this);
   }

   // Unintrospectable method: index() / g_tuples_index()
   // Gets a field from the records returned by g_relation_select(). It
   // returns the given field of the record at the given index. The
   // returned value should not be changed.
   // <index_>: the index of the record.
   // <field>: the field to return.
   void* index(int index_, int field) {
      return g_tuples_index(&this, index_, field);
   }
}

enum URI_RESERVED_CHARS_GENERIC_DELIMITERS = ":/?#[]@";
enum URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS = "!$&'()*+,;=";
enum int USEC_PER_SEC = 1000000;

// These are the possible line break classifications.
// 
// The five Hangul types were added in Unicode 4.1, so, has been
// introduced in GLib 2.10. Note that new types may be added in the future.
// Applications should be ready to handle unknown values.
// They may be regarded as %G_UNICODE_BREAK_UNKNOWN.
// 
// See <ulink url="http://www.unicode.org/unicode/reports/tr14/">http://www.unicode.org/unicode/reports/tr14/</ulink>.
enum UnicodeBreakType {
   MANDATORY = 0,
   CARRIAGE_RETURN = 1,
   LINE_FEED = 2,
   COMBINING_MARK = 3,
   SURROGATE = 4,
   ZERO_WIDTH_SPACE = 5,
   INSEPARABLE = 6,
   NON_BREAKING_GLUE = 7,
   CONTINGENT = 8,
   SPACE = 9,
   AFTER = 10,
   BEFORE = 11,
   BEFORE_AND_AFTER = 12,
   HYPHEN = 13,
   NON_STARTER = 14,
   OPEN_PUNCTUATION = 15,
   CLOSE_PUNCTUATION = 16,
   QUOTATION = 17,
   EXCLAMATION = 18,
   IDEOGRAPHIC = 19,
   NUMERIC = 20,
   INFIX_SEPARATOR = 21,
   SYMBOL = 22,
   ALPHABETIC = 23,
   PREFIX = 24,
   POSTFIX = 25,
   COMPLEX_CONTEXT = 26,
   AMBIGUOUS = 27,
   UNKNOWN = 28,
   NEXT_LINE = 29,
   WORD_JOINER = 30,
   HANGUL_L_JAMO = 31,
   HANGUL_V_JAMO = 32,
   HANGUL_T_JAMO = 33,
   HANGUL_LV_SYLLABLE = 34,
   HANGUL_LVT_SYLLABLE = 35,
   CLOSE_PARANTHESIS = 36
}

// The #GUnicodeScript enumeration identifies different writing
// systems. The values correspond to the names as defined in the
// Unicode standard. The enumeration has been added in GLib 2.14,
// and is interchangeable with #PangoScript.
// 
// Note that new types may be added in the future. Applications
// should be ready to handle unknown values.
// See <ulink
// url="http://www.unicode.org/reports/tr24/">Unicode Standard Annex
// #24: Script names</ulink>.
enum UnicodeScript {
   INVALID_CODE = -1,
   COMMON = 0,
   INHERITED = 1,
   ARABIC = 2,
   ARMENIAN = 3,
   BENGALI = 4,
   BOPOMOFO = 5,
   CHEROKEE = 6,
   COPTIC = 7,
   CYRILLIC = 8,
   DESERET = 9,
   DEVANAGARI = 10,
   ETHIOPIC = 11,
   GEORGIAN = 12,
   GOTHIC = 13,
   GREEK = 14,
   GUJARATI = 15,
   GURMUKHI = 16,
   HAN = 17,
   HANGUL = 18,
   HEBREW = 19,
   HIRAGANA = 20,
   KANNADA = 21,
   KATAKANA = 22,
   KHMER = 23,
   LAO = 24,
   LATIN = 25,
   MALAYALAM = 26,
   MONGOLIAN = 27,
   MYANMAR = 28,
   OGHAM = 29,
   OLD_ITALIC = 30,
   ORIYA = 31,
   RUNIC = 32,
   SINHALA = 33,
   SYRIAC = 34,
   TAMIL = 35,
   TELUGU = 36,
   THAANA = 37,
   THAI = 38,
   TIBETAN = 39,
   CANADIAN_ABORIGINAL = 40,
   YI = 41,
   TAGALOG = 42,
   HANUNOO = 43,
   BUHID = 44,
   TAGBANWA = 45,
   BRAILLE = 46,
   CYPRIOT = 47,
   LIMBU = 48,
   OSMANYA = 49,
   SHAVIAN = 50,
   LINEAR_B = 51,
   TAI_LE = 52,
   UGARITIC = 53,
   NEW_TAI_LUE = 54,
   BUGINESE = 55,
   GLAGOLITIC = 56,
   TIFINAGH = 57,
   SYLOTI_NAGRI = 58,
   OLD_PERSIAN = 59,
   KHAROSHTHI = 60,
   UNKNOWN = 61,
   BALINESE = 62,
   CUNEIFORM = 63,
   PHOENICIAN = 64,
   PHAGS_PA = 65,
   NKO = 66,
   KAYAH_LI = 67,
   LEPCHA = 68,
   REJANG = 69,
   SUNDANESE = 70,
   SAURASHTRA = 71,
   CHAM = 72,
   OL_CHIKI = 73,
   VAI = 74,
   CARIAN = 75,
   LYCIAN = 76,
   LYDIAN = 77,
   AVESTAN = 78,
   BAMUM = 79,
   EGYPTIAN_HIEROGLYPHS = 80,
   IMPERIAL_ARAMAIC = 81,
   INSCRIPTIONAL_PAHLAVI = 82,
   INSCRIPTIONAL_PARTHIAN = 83,
   JAVANESE = 84,
   KAITHI = 85,
   LISU = 86,
   MEETEI_MAYEK = 87,
   OLD_SOUTH_ARABIAN = 88,
   OLD_TURKIC = 89,
   SAMARITAN = 90,
   TAI_THAM = 91,
   TAI_VIET = 92,
   BATAK = 93,
   BRAHMI = 94,
   MANDAIC = 95
}

// These are the possible character classifications from the
// Unicode specification.
// See <ulink url="http://www.unicode.org/Public/UNIDATA/UnicodeData.html">http://www.unicode.org/Public/UNIDATA/UnicodeData.html</ulink>.
enum UnicodeType {
   CONTROL = 0,
   FORMAT = 1,
   UNASSIGNED = 2,
   PRIVATE_USE = 3,
   SURROGATE = 4,
   LOWERCASE_LETTER = 5,
   MODIFIER_LETTER = 6,
   OTHER_LETTER = 7,
   TITLECASE_LETTER = 8,
   UPPERCASE_LETTER = 9,
   SPACING_MARK = 10,
   ENCLOSING_MARK = 11,
   NON_SPACING_MARK = 12,
   DECIMAL_NUMBER = 13,
   LETTER_NUMBER = 14,
   OTHER_NUMBER = 15,
   CONNECT_PUNCTUATION = 16,
   DASH_PUNCTUATION = 17,
   CLOSE_PUNCTUATION = 18,
   FINAL_PUNCTUATION = 19,
   INITIAL_PUNCTUATION = 20,
   OTHER_PUNCTUATION = 21,
   OPEN_PUNCTUATION = 22,
   CURRENCY_SYMBOL = 23,
   MODIFIER_SYMBOL = 24,
   MATH_SYMBOL = 25,
   OTHER_SYMBOL = 26,
   LINE_SEPARATOR = 27,
   PARAGRAPH_SEPARATOR = 28,
   SPACE_SEPARATOR = 29
}

// These are logical ids for special directories which are defined
// depending on the platform used. You should use g_get_user_special_dir()
// to retrieve the full path associated to the logical id.
// 
// The #GUserDirectory enumeration can be extended at later date. Not
// every platform has a directory for every logical id in this
// enumeration.
enum UserDirectory /* Version 2.14 */ {
   DIRECTORY_DESKTOP = 0,
   DIRECTORY_DOCUMENTS = 1,
   DIRECTORY_DOWNLOAD = 2,
   DIRECTORY_MUSIC = 3,
   DIRECTORY_PICTURES = 4,
   DIRECTORY_PUBLIC_SHARE = 5,
   DIRECTORY_TEMPLATES = 6,
   DIRECTORY_VIDEOS = 7,
   N_DIRECTORIES = 8
}

// #GVariant is a variant datatype; it stores a value along with
// information about the type of that value.  The range of possible
// values is determined by the type.  The type system used by #GVariant
// is #GVariantType.
// 
// #GVariant instances always have a type and a value (which are given
// at construction time).  The type and value of a #GVariant instance
// can never change other than by the #GVariant itself being
// destroyed.  A #GVariant cannot contain a pointer.
// 
// #GVariant is reference counted using g_variant_ref() and
// g_variant_unref().  #GVariant also has floating reference counts --
// see g_variant_ref_sink().
// 
// #GVariant is completely threadsafe.  A #GVariant instance can be
// concurrently accessed in any way from any number of threads without
// problems.
// 
// #GVariant is heavily optimised for dealing with data in serialised
// form.  It works particularly well with data located in memory-mapped
// files.  It can perform nearly all deserialisation operations in a
// small constant time, usually touching only a single memory page.
// Serialised #GVariant data can also be sent over the network.
// 
// #GVariant is largely compatible with D-Bus.  Almost all types of
// #GVariant instances can be sent over D-Bus.  See #GVariantType for
// exceptions.
// 
// For convenience to C programmers, #GVariant features powerful
// varargs-based value construction and destruction.  This feature is
// designed to be embedded in other libraries.
// 
// There is a Python-inspired text language for describing #GVariant
// values.  #GVariant includes a printer for this language and a parser
// with type inferencing.
// 
// <refsect2>
// <title>Memory Use</title>
// <para>
// #GVariant tries to be quite efficient with respect to memory use.
// This section gives a rough idea of how much memory is used by the
// current implementation.  The information here is subject to change
// in the future.
// </para>
// <para>
// The memory allocated by #GVariant can be grouped into 4 broad
// purposes: memory for serialised data, memory for the type
// information cache, buffer management memory and memory for the
// #GVariant structure itself.
// </para>
// <refsect3>
// <title>Serialised Data Memory</title>
// <para>
// This is the memory that is used for storing GVariant data in
// serialised form.  This is what would be sent over the network or
// what would end up on disk.
// </para>
// <para>
// The amount of memory required to store a boolean is 1 byte.  16,
// 32 and 64 bit integers and double precision floating point numbers
// use their "natural" size.  Strings (including object path and
// signature strings) are stored with a nul terminator, and as such
// use the length of the string plus 1 byte.
// </para>
// <para>
// Maybe types use no space at all to represent the null value and
// use the same amount of space (sometimes plus one byte) as the
// equivalent non-maybe-typed value to represent the non-null case.
// </para>
// <para>
// Arrays use the amount of space required to store each of their
// members, concatenated.  Additionally, if the items stored in an
// array are not of a fixed-size (ie: strings, other arrays, etc)
// then an additional framing offset is stored for each item.  The
// size of this offset is either 1, 2 or 4 bytes depending on the
// overall size of the container.  Additionally, extra padding bytes
// are added as required for alignment of child values.
// </para>
// <para>
// Tuples (including dictionary entries) use the amount of space
// required to store each of their members, concatenated, plus one
// framing offset (as per arrays) for each non-fixed-sized item in
// the tuple, except for the last one.  Additionally, extra padding
// bytes are added as required for alignment of child values.
// </para>
// <para>
// Variants use the same amount of space as the item inside of the
// variant, plus 1 byte, plus the length of the type string for the
// item inside the variant.
// </para>
// <para>
// As an example, consider a dictionary mapping strings to variants.
// In the case that the dictionary is empty, 0 bytes are required for
// the serialisation.
// </para>
// <para>
// If we add an item "width" that maps to the int32 value of 500 then
// we will use 4 byte to store the int32 (so 6 for the variant
// containing it) and 6 bytes for the string.  The variant must be
// aligned to 8 after the 6 bytes of the string, so that's 2 extra
// bytes.  6 (string) + 2 (padding) + 6 (variant) is 14 bytes used
// for the dictionary entry.  An additional 1 byte is added to the
// array as a framing offset making a total of 15 bytes.
// </para>
// <para>
// If we add another entry, "title" that maps to a nullable string
// that happens to have a value of null, then we use 0 bytes for the
// null value (and 3 bytes for the variant to contain it along with
// its type string) plus 6 bytes for the string.  Again, we need 2
// padding bytes.  That makes a total of 6 + 2 + 3 = 11 bytes.
// </para>
// <para>
// We now require extra padding between the two items in the array.
// After the 14 bytes of the first item, that's 2 bytes required.  We
// now require 2 framing offsets for an extra two bytes.  14 + 2 + 11
// + 2 = 29 bytes to encode the entire two-item dictionary.
// </para>
// </refsect3>
// <refsect3>
// <title>Type Information Cache</title>
// <para>
// For each GVariant type that currently exists in the program a type
// information structure is kept in the type information cache.  The
// type information structure is required for rapid deserialisation.
// </para>
// <para>
// Continuing with the above example, if a #GVariant exists with the
// type "a{sv}" then a type information struct will exist for
// "a{sv}", "{sv}", "s", and "v".  Multiple uses of the same type
// will share the same type information.  Additionally, all
// single-digit types are stored in read-only static memory and do
// not contribute to the writable memory footprint of a program using
// #GVariant.
// </para>
// <para>
// Aside from the type information structures stored in read-only
// memory, there are two forms of type information.  One is used for
// container types where there is a single element type: arrays and
// maybe types.  The other is used for container types where there
// are multiple element types: tuples and dictionary entries.
// </para>
// <para>
// Array type info structures are 6 * sizeof (void *), plus the
// memory required to store the type string itself.  This means that
// on 32bit systems, the cache entry for "a{sv}" would require 30
// bytes of memory (plus malloc overhead).
// </para>
// <para>
// Tuple type info structures are 6 * sizeof (void *), plus 4 *
// sizeof (void *) for each item in the tuple, plus the memory
// required to store the type string itself.  A 2-item tuple, for
// example, would have a type information structure that consumed
// writable memory in the size of 14 * sizeof (void *) (plus type
// string)  This means that on 32bit systems, the cache entry for
// "{sv}" would require 61 bytes of memory (plus malloc overhead).
// </para>
// <para>
// This means that in total, for our "a{sv}" example, 91 bytes of
// type information would be allocated.
// </para>
// <para>
// The type information cache, additionally, uses a #GHashTable to
// store and lookup the cached items and stores a pointer to this
// hash table in static storage.  The hash table is freed when there
// are zero items in the type cache.
// </para>
// <para>
// Although these sizes may seem large it is important to remember
// that a program will probably only have a very small number of
// different types of values in it and that only one type information
// structure is required for many different values of the same type.
// </para>
// </refsect3>
// <refsect3>
// <title>Buffer Management Memory</title>
// <para>
// #GVariant uses an internal buffer management structure to deal
// with the various different possible sources of serialised data
// that it uses.  The buffer is responsible for ensuring that the
// correct call is made when the data is no longer in use by
// #GVariant.  This may involve a g_free() or a g_slice_free() or
// even g_mapped_file_unref().
// </para>
// <para>
// One buffer management structure is used for each chunk of
// serialised data.  The size of the buffer management structure is 4
// * (void *).  On 32bit systems, that's 16 bytes.
// </para>
// </refsect3>
// <refsect3>
// <title>GVariant structure</title>
// <para>
// The size of a #GVariant structure is 6 * (void *).  On 32 bit
// systems, that's 24 bytes.
// </para>
// <para>
// #GVariant structures only exist if they are explicitly created
// with API calls.  For example, if a #GVariant is constructed out of
// serialised data for the example given above (with the dictionary)
// then although there are 9 individual values that comprise the
// entire dictionary (two keys, two values, two variants containing
// the values, two dictionary entries, plus the dictionary itself),
// only 1 #GVariant instance exists -- the one referring to the
// dictionary.
// </para>
// <para>
// If calls are made to start accessing the other values then
// #GVariant instances will exist for those values only for as long
// as they are in use (ie: until you call g_variant_unref()).  The
// type information is shared.  The serialised data and the buffer
// management structure for that serialised data is shared by the
// child.
// </para>
// </refsect3>
// <refsect3>
// <title>Summary</title>
// <para>
// To put the entire example together, for our dictionary mapping
// strings to variants (with two entries, as given above), we are
// using 91 bytes of memory for type information, 29 byes of memory
// for the serialised data, 16 bytes for buffer management and 24
// bytes for the #GVariant instance, or a total of 160 bytes, plus
// malloc overhead.  If we were to use g_variant_get_child_value() to
// access the two dictionary entries, we would use an additional 48
// bytes.  If we were to have other dictionaries of the same type, we
// would use more memory for the serialised data and buffer
// management for those dictionaries, but the type information would
// be shared.
// </para>
// </refsect3>
// </refsect2>
struct Variant /* Version 2.24 */ {

   // Unintrospectable constructor: new() / g_variant_new()
   // Creates a new #GVariant instance.
   // 
   // Think of this function as an analogue to g_strdup_printf().
   // 
   // The type of the created instance and the arguments that are
   // expected by this function are determined by @format_string.  See the
   // section on <link linkend='gvariant-format-strings'>GVariant Format
   // Strings</link>.  Please note that the syntax of the format string is
   // very likely to be extended in the future.
   // 
   // The first character of the format string must not be '*' '?' '@' or
   // 'r'; in essence, a new #GVariant must always be constructed by this
   // function (and not merely passed through it unmodified).
   // RETURNS: a new floating #GVariant instance
   // <format_string>: a #GVariant format string
   alias g_variant_new new_; // Variadic

   // Creates a new #GVariant array from @children.
   // 
   // @child_type must be non-%NULL if @n_children is zero.  Otherwise, the
   // child type is determined by inspecting the first element of the
   // @children array.  If @child_type is non-%NULL then it must be a
   // definite type.
   // 
   // The items of the array are taken from the @children array.  No entry
   // in the @children array may be %NULL.
   // 
   // All items in the array must have the same type, which must be the
   // same as @child_type, if given.
   // 
   // If the @children are floating references (see g_variant_ref_sink()), the
   // new instance takes ownership of them as if via g_variant_ref_sink().
   // RETURNS: a floating reference to a new #GVariant array
   // <child_type>: the element type of the new array
   // <children>: an array of #GVariant pointers, the children
   // <n_children>: the length of @children
   static Variant* new_array(VariantType* child_type, Variant** children, size_t n_children) {
      return g_variant_new_array(child_type, children, n_children);
   }

   // Creates a new boolean #GVariant instance -- either %TRUE or %FALSE.
   // RETURNS: a floating reference to a new boolean #GVariant instance
   // <value>: a #gboolean value
   static Variant* new_boolean(int value) {
      return g_variant_new_boolean(value);
   }

   // Creates a new byte #GVariant instance.
   // RETURNS: a floating reference to a new byte #GVariant instance
   // <value>: a #guint8 value
   static Variant* new_byte(ubyte value) {
      return g_variant_new_byte(value);
   }

   // Creates an array-of-bytes #GVariant with the contents of @string.
   // This function is just like g_variant_new_string() except that the
   // string need not be valid utf8.
   // 
   // The nul terminator character at the end of the string is stored in
   // the array.
   // RETURNS: a floating reference to a new bytestring #GVariant instance
   // <string>: a normal nul-terminated string in no particular encoding
   static Variant* new_bytestring(ubyte* string_) {
      return g_variant_new_bytestring(string_);
   }

   // Constructs an array of bytestring #GVariant from the given array of
   // strings.
   // 
   // If @length is -1 then @strv is %NULL-terminated.
   // RETURNS: a new floating #GVariant instance
   // <strv>: an array of strings
   // <length>: the length of @strv, or -1
   static Variant* new_bytestring_array(char** strv, ssize_t length) {
      return g_variant_new_bytestring_array(strv, length);
   }

   // Creates a new dictionary entry #GVariant. @key and @value must be
   // non-%NULL. @key must be a value of a basic type (ie: not a container).
   // 
   // If the @key or @value are floating references (see g_variant_ref_sink()),
   // the new instance takes ownership of them as if via g_variant_ref_sink().
   // RETURNS: a floating reference to a new dictionary entry #GVariant
   // <key>: a basic #GVariant, the key
   // <value>: a #GVariant, the value
   static Variant* new_dict_entry(Variant* key, Variant* value) {
      return g_variant_new_dict_entry(key, value);
   }

   // Creates a new double #GVariant instance.
   // RETURNS: a floating reference to a new double #GVariant instance
   // <value>: a #gdouble floating point value
   static Variant* new_double(double value) {
      return g_variant_new_double(value);
   }

   // Creates a new #GVariant instance from serialised data.
   // 
   // @type is the type of #GVariant instance that will be constructed.
   // The interpretation of @data depends on knowing the type.
   // 
   // @data is not modified by this function and must remain valid with an
   // unchanging value until such a time as @notify is called with
   // @user_data.  If the contents of @data change before that time then
   // the result is undefined.
   // 
   // If @data is trusted to be serialised data in normal form then
   // @trusted should be %TRUE.  This applies to serialised data created
   // within this process or read from a trusted location on the disk (such
   // as a file installed in /usr/lib alongside your application).  You
   // should set trusted to %FALSE if @data is read from the network, a
   // file in the user's home directory, etc.
   // 
   // @notify will be called with @user_data when @data is no longer
   // needed.  The exact time of this call is unspecified and might even be
   // before this function returns.
   // RETURNS: a new floating #GVariant of type @type
   // <type>: a definite #GVariantType
   // <data>: the serialised data
   // <size>: the size of @data
   // <trusted>: %TRUE if @data is definitely in normal form
   // <notify>: function to call when @data is no longer needed
   // <user_data>: data for @notify
   static Variant* new_from_data(VariantType* type, const(ubyte)* data, size_t size, int trusted, DestroyNotify notify, void* user_data) {
      return g_variant_new_from_data(type, data, size, trusted, notify, user_data);
   }

   // Creates a new handle #GVariant instance.
   // 
   // By convention, handles are indexes into an array of file descriptors
   // that are sent alongside a D-Bus message.  If you're not interacting
   // with D-Bus, you probably don't need them.
   // RETURNS: a floating reference to a new handle #GVariant instance
   // <value>: a #gint32 value
   static Variant* new_handle(int value) {
      return g_variant_new_handle(value);
   }

   // Creates a new int16 #GVariant instance.
   // RETURNS: a floating reference to a new int16 #GVariant instance
   // <value>: a #gint16 value
   static Variant* new_int16(short value) {
      return g_variant_new_int16(value);
   }

   // Creates a new int32 #GVariant instance.
   // RETURNS: a floating reference to a new int32 #GVariant instance
   // <value>: a #gint32 value
   static Variant* new_int32(int value) {
      return g_variant_new_int32(value);
   }

   // Creates a new int64 #GVariant instance.
   // RETURNS: a floating reference to a new int64 #GVariant instance
   // <value>: a #gint64 value
   static Variant* new_int64(long value) {
      return g_variant_new_int64(value);
   }

   // Depending on if @child is %NULL, either wraps @child inside of a
   // maybe container or creates a Nothing instance for the given @type.
   // 
   // At least one of @child_type and @child must be non-%NULL.
   // If @child_type is non-%NULL then it must be a definite type.
   // If they are both non-%NULL then @child_type must be the type
   // of @child.
   // 
   // If @child is a floating reference (see g_variant_ref_sink()), the new
   // instance takes ownership of @child.
   // RETURNS: a floating reference to a new #GVariant maybe instance
   // <child_type>: the #GVariantType of the child, or %NULL
   // <child>: the child value, or %NULL
   static Variant* new_maybe(VariantType* child_type=null, Variant* child=null) {
      return g_variant_new_maybe(child_type, child);
   }

   // Creates a D-Bus object path #GVariant with the contents of @string.
   // @string must be a valid D-Bus object path.  Use
   // g_variant_is_object_path() if you're not sure.
   // RETURNS: a floating reference to a new object path #GVariant instance
   // <object_path>: a normal C nul-terminated string
   static Variant* new_object_path(char* object_path) {
      return g_variant_new_object_path(object_path);
   }

   // Constructs an array of object paths #GVariant from the given array of
   // strings.
   // 
   // Each string must be a valid #GVariant object path; see
   // g_variant_is_object_path().
   // 
   // If @length is -1 then @strv is %NULL-terminated.
   // RETURNS: a new floating #GVariant instance
   // <strv>: an array of strings
   // <length>: the length of @strv, or -1
   static Variant* new_objv(char** strv, ssize_t length) {
      return g_variant_new_objv(strv, length);
   }

   // Unintrospectable constructor: new_parsed() / g_variant_new_parsed()
   // Parses @format and returns the result.
   // 
   // point that a value may appear in the text, a '%' character followed
   // by a GVariant format string (as per g_variant_new()) may appear.  In
   // that case, the same arguments are collected from the argument list as
   // g_variant_new() would have collected.
   // 
   // Consider this simple example:
   // 
   // <informalexample><programlisting>
   // g_variant_new_parsed ("[('one', 1), ('two', %i), (%s, 3)]", 2, "three");
   // </programlisting></informalexample>
   // 
   // In the example, the variable argument parameters are collected and
   // filled in as if they were part of the original string to produce the
   // result of <code>[('one', 1), ('two', 2), ('three', 3)]</code>.
   // 
   // This function is intended only to be used with @format as a string
   // literal.  Any parse error is fatal to the calling process.  If you
   // want to parse data from untrusted sources, use g_variant_parse().
   // 
   // You may not use this function to return, unmodified, a single
   // #GVariant pointer from the argument list.  ie: @format may not solely
   // be anything along the lines of "%*", "%?", "%r", or anything starting
   // with "%@".
   // RETURNS: a new floating #GVariant instance
   // <format>: a text format #GVariant
   alias g_variant_new_parsed new_parsed; // Variadic

   // Unintrospectable constructor: new_parsed_va() / g_variant_new_parsed_va()
   // Parses @format and returns the result.
   // 
   // This is the version of g_variant_new_parsed() intended to be used
   // from libraries.
   // 
   // The return value will be floating if it was a newly created GVariant
   // instance.  In the case that @format simply specified the collection
   // of a #GVariant pointer (eg: @format was "%*") then the collected
   // #GVariant pointer will be returned unmodified, without adding any
   // additional references.
   // 
   // In order to behave correctly in all cases it is necessary for the
   // calling function to g_variant_ref_sink() the return result before
   // returning control to the user that originally provided the pointer.
   // At this point, the caller will have their own full reference to the
   // result.  This can also be done by adding the result to a container,
   // or by passing it to another g_variant_new() call.
   // RETURNS: a new, usually floating, #GVariant
   // <format>: a text format #GVariant
   // <app>: a pointer to a #va_list
   static Variant* /*new*/ new_parsed_va(char* format, va_list* app) {
      return g_variant_new_parsed_va(format, app);
   }

   // Creates a D-Bus type signature #GVariant with the contents of
   // @string.  @string must be a valid D-Bus type signature.  Use
   // g_variant_is_signature() if you're not sure.
   // RETURNS: a floating reference to a new signature #GVariant instance
   // <signature>: a normal C nul-terminated string
   static Variant* new_signature(char* signature) {
      return g_variant_new_signature(signature);
   }

   // Creates a string #GVariant with the contents of @string.
   // 
   // @string must be valid utf8.
   // RETURNS: a floating reference to a new string #GVariant instance
   // <string>: a normal utf8 nul-terminated string
   static Variant* new_string(char* string_) {
      return g_variant_new_string(string_);
   }

   // Constructs an array of strings #GVariant from the given array of
   // strings.
   // 
   // If @length is -1 then @strv is %NULL-terminated.
   // RETURNS: a new floating #GVariant instance
   // <strv>: an array of strings
   // <length>: the length of @strv, or -1
   static Variant* new_strv(char** strv, ssize_t length) {
      return g_variant_new_strv(strv, length);
   }

   // Creates a new tuple #GVariant out of the items in @children.  The
   // type is determined from the types of @children.  No entry in the
   // @children array may be %NULL.
   // 
   // If @n_children is 0 then the unit tuple is constructed.
   // 
   // If the @children are floating references (see g_variant_ref_sink()), the
   // new instance takes ownership of them as if via g_variant_ref_sink().
   // RETURNS: a floating reference to a new #GVariant tuple
   // <children>: the items to make the tuple out of
   // <n_children>: the length of @children
   static Variant* new_tuple(Variant** children, size_t n_children) {
      return g_variant_new_tuple(children, n_children);
   }

   // Creates a new uint16 #GVariant instance.
   // RETURNS: a floating reference to a new uint16 #GVariant instance
   // <value>: a #guint16 value
   static Variant* new_uint16(ushort value) {
      return g_variant_new_uint16(value);
   }

   // Creates a new uint32 #GVariant instance.
   // RETURNS: a floating reference to a new uint32 #GVariant instance
   // <value>: a #guint32 value
   static Variant* new_uint32(uint value) {
      return g_variant_new_uint32(value);
   }

   // Creates a new uint64 #GVariant instance.
   // RETURNS: a floating reference to a new uint64 #GVariant instance
   // <value>: a #guint64 value
   static Variant* new_uint64(ulong value) {
      return g_variant_new_uint64(value);
   }

   // Unintrospectable constructor: new_va() / g_variant_new_va()
   // This function is intended to be used by libraries based on
   // #GVariant that want to provide g_variant_new()-like functionality
   // to their users.
   // 
   // The API is more general than g_variant_new() to allow a wider range
   // of possible uses.
   // 
   // @format_string must still point to a valid format string, but it only
   // needs to be nul-terminated if @endptr is %NULL.  If @endptr is
   // non-%NULL then it is updated to point to the first character past the
   // end of the format string.
   // 
   // @app is a pointer to a #va_list.  The arguments, according to
   // @format_string, are collected from this #va_list and the list is left
   // pointing to the argument following the last.
   // 
   // These two generalisations allow mixing of multiple calls to
   // g_variant_new_va() and g_variant_get_va() within a single actual
   // varargs call by the user.
   // 
   // The return value will be floating if it was a newly created GVariant
   // instance (for example, if the format string was "(ii)").  In the case
   // that the format_string was '*', '?', 'r', or a format starting with
   // '@' then the collected #GVariant pointer will be returned unmodified,
   // without adding any additional references.
   // 
   // In order to behave correctly in all cases it is necessary for the
   // calling function to g_variant_ref_sink() the return result before
   // returning control to the user that originally provided the pointer.
   // At this point, the caller will have their own full reference to the
   // result.  This can also be done by adding the result to a container,
   // or by passing it to another g_variant_new() call.
   // RETURNS: a new, usually floating, #GVariant
   // <format_string>: a string that is prefixed with a format string
   // <endptr>: location to store the end pointer, or %NULL
   // <app>: a pointer to a #va_list
   static Variant* /*new*/ new_va(char* format_string, char** endptr, va_list* app) {
      return g_variant_new_va(format_string, endptr, app);
   }

   // Boxes @value.  The result is a #GVariant instance representing a
   // variant containing the original value.
   // 
   // If @child is a floating reference (see g_variant_ref_sink()), the new
   // instance takes ownership of @child.
   // RETURNS: a floating reference to a new variant #GVariant instance
   // <value>: a #GVariant instance
   static Variant* new_variant(Variant* value) {
      return g_variant_new_variant(value);
   }

   // Performs a byteswapping operation on the contents of @value.  The
   // result is that all multi-byte numeric data contained in @value is
   // byteswapped.  That includes 16, 32, and 64bit signed and unsigned
   // integers as well as file handles and double precision floating point
   // values.
   // 
   // This function is an identity mapping on any value that does not
   // contain multi-byte numeric data.  That include strings, booleans,
   // bytes and containers containing only these things (recursively).
   // 
   // The returned value is always in normal form and is marked as trusted.
   // RETURNS: the byteswapped form of @value
   Variant* /*new*/ byteswap() {
      return g_variant_byteswap(&this);
   }

   // Classifies @value according to its top-level type.
   // RETURNS: the #GVariantClass of @value
   VariantClass classify() {
      return g_variant_classify(&this);
   }

   // Compares @one and @two.
   // 
   // The types of @one and @two are #gconstpointer only to allow use of
   // this function with #GTree, #GPtrArray, etc.  They must each be a
   // #GVariant.
   // 
   // Comparison is only defined for basic types (ie: booleans, numbers,
   // strings).  For booleans, %FALSE is less than %TRUE.  Numbers are
   // ordered in the usual way.  Strings are in ASCII lexographical order.
   // 
   // It is a programmer error to attempt to compare container values or
   // two values that have types that are not exactly equal.  For example,
   // you cannot compare a 32-bit signed integer with a 32-bit unsigned
   // integer.  Also note that this function is not particularly
   // well-behaved when it comes to comparison of doubles; in particular,
   // the handling of incomparable values (ie: NaN) is undefined.
   // 
   // If you only require an equality comparison, g_variant_equal() is more
   // general.
   // RETURNS: negative value if a &lt; b; zero if a = b; positive value if a &gt; b.
   // <two>: a #GVariant instance of the same type
   int compare(const(Variant)* two) {
      return g_variant_compare(&this, two);
   }

   // Similar to g_variant_get_bytestring() except that instead of
   // returning a constant string, the string is duplicated.
   // 
   // The return value must be freed using g_free().
   // RETURNS: a newly allocated string
   // <length>: a pointer to a #gsize, to store the length (not including the nul terminator)
   ubyte* /*new*/ dup_bytestring(/*out*/ size_t* length=null) {
      return g_variant_dup_bytestring(&this, length);
   }

   // Gets the contents of an array of array of bytes #GVariant.  This call
   // makes a deep copy; the return result should be released with
   // g_strfreev().
   // 
   // If @length is non-%NULL then the number of elements in the result is
   // stored there.  In any case, the resulting array will be
   // %NULL-terminated.
   // 
   // For an empty array, @length will be set to 0 and a pointer to a
   // %NULL pointer will be returned.
   // RETURNS: an array of strings
   // <length>: the length of the result, or %NULL
   char** /*new*/ dup_bytestring_array(/*out*/ size_t* length=null) {
      return g_variant_dup_bytestring_array(&this, length);
   }

   // Gets the contents of an array of object paths #GVariant.  This call
   // makes a deep copy; the return result should be released with
   // g_strfreev().
   // 
   // If @length is non-%NULL then the number of elements in the result
   // is stored there.  In any case, the resulting array will be
   // %NULL-terminated.
   // 
   // For an empty array, @length will be set to 0 and a pointer to a
   // %NULL pointer will be returned.
   // RETURNS: an array of strings
   // <length>: the length of the result, or %NULL
   char** /*new*/ dup_objv(/*out*/ size_t* length=null) {
      return g_variant_dup_objv(&this, length);
   }

   // Similar to g_variant_get_string() except that instead of returning
   // a constant string, the string is duplicated.
   // 
   // The string will always be utf8 encoded.
   // 
   // The return value must be freed using g_free().
   // RETURNS: a newly allocated string, utf8 encoded
   // <length>: a pointer to a #gsize, to store the length
   char* /*new*/ dup_string(/*out*/ size_t* length) {
      return g_variant_dup_string(&this, length);
   }

   // Gets the contents of an array of strings #GVariant.  This call
   // makes a deep copy; the return result should be released with
   // g_strfreev().
   // 
   // If @length is non-%NULL then the number of elements in the result
   // is stored there.  In any case, the resulting array will be
   // %NULL-terminated.
   // 
   // For an empty array, @length will be set to 0 and a pointer to a
   // %NULL pointer will be returned.
   // RETURNS: an array of strings
   // <length>: the length of the result, or %NULL
   char** /*new*/ dup_strv(/*out*/ size_t* length=null) {
      return g_variant_dup_strv(&this, length);
   }

   // Checks if @one and @two have the same type and value.
   // 
   // The types of @one and @two are #gconstpointer only to allow use of
   // this function with #GHashTable.  They must each be a #GVariant.
   // RETURNS: %TRUE if @one and @two are equal
   // <two>: a #GVariant instance
   int equal(const(Variant)* two) {
      return g_variant_equal(&this, two);
   }

   // Unintrospectable method: get() / g_variant_get()
   // Deconstructs a #GVariant instance.
   // 
   // Think of this function as an analogue to scanf().
   // 
   // The arguments that are expected by this function are entirely
   // determined by @format_string.  @format_string also restricts the
   // permissible types of @value.  It is an error to give a value with
   // an incompatible type.  See the section on <link
   // linkend='gvariant-format-strings'>GVariant Format Strings</link>.
   // Please note that the syntax of the format string is very likely to be
   // extended in the future.
   // <format_string>: a #GVariant format string
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_variant_get get; // Variadic
   +/

   // Returns the boolean value of @value.
   // 
   // It is an error to call this function with a @value of any type
   // other than %G_VARIANT_TYPE_BOOLEAN.
   // RETURNS: %TRUE or %FALSE
   int get_boolean() {
      return g_variant_get_boolean(&this);
   }

   // Returns the byte value of @value.
   // 
   // It is an error to call this function with a @value of any type
   // other than %G_VARIANT_TYPE_BYTE.
   // RETURNS: a #guchar
   ubyte get_byte() {
      return g_variant_get_byte(&this);
   }

   // Returns the string value of a #GVariant instance with an
   // array-of-bytes type.  The string has no particular encoding.
   // 
   // If the array does not end with a nul terminator character, the empty
   // string is returned.  For this reason, you can always trust that a
   // non-%NULL nul-terminated string will be returned by this function.
   // 
   // If the array contains a nul terminator character somewhere other than
   // the last byte then the returned string is the string, up to the first
   // such nul character.
   // 
   // It is an error to call this function with a @value that is not an
   // array of bytes.
   // 
   // The return value remains valid as long as @value exists.
   // RETURNS: the constant string
   ubyte* get_bytestring() {
      return g_variant_get_bytestring(&this);
   }

   // Gets the contents of an array of array of bytes #GVariant.  This call
   // makes a shallow copy; the return result should be released with
   // g_free(), but the individual strings must not be modified.
   // 
   // If @length is non-%NULL then the number of elements in the result is
   // stored there.  In any case, the resulting array will be
   // %NULL-terminated.
   // 
   // For an empty array, @length will be set to 0 and a pointer to a
   // %NULL pointer will be returned.
   // RETURNS: an array of constant strings
   // <length>: the length of the result, or %NULL
   char** /*new container*/ get_bytestring_array(/*out*/ size_t* length=null) {
      return g_variant_get_bytestring_array(&this, length);
   }

   // Unintrospectable method: get_child() / g_variant_get_child()
   // Reads a child item out of a container #GVariant instance and
   // deconstructs it according to @format_string.  This call is
   // essentially a combination of g_variant_get_child_value() and
   // g_variant_get().
   // <index_>: the index of the child to deconstruct
   // <format_string>: a #GVariant format string
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_variant_get_child get_child; // Variadic
   +/

   // Reads a child item out of a container #GVariant instance.  This
   // includes variants, maybes, arrays, tuples and dictionary
   // entries.  It is an error to call this function on any other type of
   // #GVariant.
   // 
   // It is an error if @index_ is greater than the number of child items
   // in the container.  See g_variant_n_children().
   // 
   // This function is O(1).
   // RETURNS: the child at the specified index
   // <index_>: the index of the child to fetch
   Variant* /*new*/ get_child_value(size_t index_) {
      return g_variant_get_child_value(&this, index_);
   }

   // Returns a pointer to the serialised form of a #GVariant instance.
   // The returned data may not be in fully-normalised form if read from an
   // untrusted source.  The returned data must not be freed; it remains
   // valid for as long as @value exists.
   // 
   // If @value is a fixed-sized value that was deserialised from a
   // corrupted serialised container then %NULL may be returned.  In this
   // case, the proper thing to do is typically to use the appropriate
   // number of nul bytes in place of @value.  If @value is not fixed-sized
   // then %NULL is never returned.
   // 
   // In the case that @value is already in serialised form, this function
   // is O(1).  If the value is not already in serialised form,
   // serialisation occurs implicitly and is approximately O(n) in the size
   // of the result.
   // RETURNS: the serialised form of @value, or %NULL
   const(void)* get_data() {
      return g_variant_get_data(&this);
   }

   // Returns the double precision floating point value of @value.
   // 
   // It is an error to call this function with a @value of any type
   // other than %G_VARIANT_TYPE_DOUBLE.
   // RETURNS: a #gdouble
   double get_double() {
      return g_variant_get_double(&this);
   }

   // Provides access to the serialised data for an array of fixed-sized
   // items.
   // 
   // @value must be an array with fixed-sized elements.  Numeric types are
   // fixed-size as are tuples containing only other fixed-sized types.
   // 
   // @element_size must be the size of a single element in the array.  For
   // example, if calling this function for an array of 32 bit integers,
   // you might say <code>sizeof (gint32)</code>.  This value isn't used
   // except for the purpose of a double-check that the form of the
   // seralised data matches the caller's expectation.
   // 
   // @n_elements, which must be non-%NULL is set equal to the number of
   // items in the array.
   // RETURNS: a pointer to the fixed array
   // <n_elements>: a pointer to the location to store the number of items
   // <element_size>: the size of each element
   const(void)* get_fixed_array(/*out*/ size_t* n_elements, size_t element_size) {
      return g_variant_get_fixed_array(&this, n_elements, element_size);
   }

   // Returns the 32-bit signed integer value of @value.
   // 
   // It is an error to call this function with a @value of any type other
   // than %G_VARIANT_TYPE_HANDLE.
   // 
   // By convention, handles are indexes into an array of file descriptors
   // that are sent alongside a D-Bus message.  If you're not interacting
   // with D-Bus, you probably don't need them.
   // RETURNS: a #gint32
   int get_handle() {
      return g_variant_get_handle(&this);
   }

   // Returns the 16-bit signed integer value of @value.
   // 
   // It is an error to call this function with a @value of any type
   // other than %G_VARIANT_TYPE_INT16.
   // RETURNS: a #gint16
   short get_int16() {
      return g_variant_get_int16(&this);
   }

   // Returns the 32-bit signed integer value of @value.
   // 
   // It is an error to call this function with a @value of any type
   // other than %G_VARIANT_TYPE_INT32.
   // RETURNS: a #gint32
   int get_int32() {
      return g_variant_get_int32(&this);
   }

   // Returns the 64-bit signed integer value of @value.
   // 
   // It is an error to call this function with a @value of any type
   // other than %G_VARIANT_TYPE_INT64.
   // RETURNS: a #gint64
   long get_int64() {
      return g_variant_get_int64(&this);
   }

   // Given a maybe-typed #GVariant instance, extract its value.  If the
   // value is Nothing, then this function returns %NULL.
   // RETURNS: the contents of @value, or %NULL
   Variant* /*new*/ get_maybe() {
      return g_variant_get_maybe(&this);
   }

   // Gets a #GVariant instance that has the same value as @value and is
   // trusted to be in normal form.
   // 
   // If @value is already trusted to be in normal form then a new
   // reference to @value is returned.
   // 
   // If @value is not already trusted, then it is scanned to check if it
   // is in normal form.  If it is found to be in normal form then it is
   // marked as trusted and a new reference to it is returned.
   // 
   // If @value is found not to be in normal form then a new trusted
   // #GVariant is created with the same value as @value.
   // 
   // It makes sense to call this function if you've received #GVariant
   // data from untrusted sources and you want to ensure your serialised
   // output is definitely in normal form.
   // RETURNS: a trusted #GVariant
   Variant* /*new*/ get_normal_form() {
      return g_variant_get_normal_form(&this);
   }

   // Gets the contents of an array of object paths #GVariant.  This call
   // makes a shallow copy; the return result should be released with
   // g_free(), but the individual strings must not be modified.
   // 
   // If @length is non-%NULL then the number of elements in the result
   // is stored there.  In any case, the resulting array will be
   // %NULL-terminated.
   // 
   // For an empty array, @length will be set to 0 and a pointer to a
   // %NULL pointer will be returned.
   // RETURNS: an array of constant strings
   // <length>: the length of the result, or %NULL
   char** /*new container*/ get_objv(/*out*/ size_t* length=null) {
      return g_variant_get_objv(&this, length);
   }

   // Determines the number of bytes that would be required to store @value
   // with g_variant_store().
   // 
   // If @value has a fixed-sized type then this function always returned
   // that fixed size.
   // 
   // In the case that @value is already in serialised form or the size has
   // already been calculated (ie: this function has been called before)
   // then this function is O(1).  Otherwise, the size is calculated, an
   // operation which is approximately O(n) in the number of values
   // involved.
   // RETURNS: the serialised size of @value
   size_t get_size() {
      return g_variant_get_size(&this);
   }

   // Returns the string value of a #GVariant instance with a string
   // type.  This includes the types %G_VARIANT_TYPE_STRING,
   // %G_VARIANT_TYPE_OBJECT_PATH and %G_VARIANT_TYPE_SIGNATURE.
   // 
   // The string will always be utf8 encoded.
   // 
   // If @length is non-%NULL then the length of the string (in bytes) is
   // returned there.  For trusted values, this information is already
   // known.  For untrusted values, a strlen() will be performed.
   // 
   // It is an error to call this function with a @value of any type
   // other than those three.
   // 
   // The return value remains valid as long as @value exists.
   // RETURNS: the constant string, utf8 encoded
   // <length>: a pointer to a #gsize, to store the length
   char* get_string(/*out*/ size_t* length=null) {
      return g_variant_get_string(&this, length);
   }

   // Gets the contents of an array of strings #GVariant.  This call
   // makes a shallow copy; the return result should be released with
   // g_free(), but the individual strings must not be modified.
   // 
   // If @length is non-%NULL then the number of elements in the result
   // is stored there.  In any case, the resulting array will be
   // %NULL-terminated.
   // 
   // For an empty array, @length will be set to 0 and a pointer to a
   // %NULL pointer will be returned.
   // RETURNS: an array of constant strings
   // <length>: the length of the result, or %NULL
   char** /*new container*/ get_strv(/*out*/ size_t* length=null) {
      return g_variant_get_strv(&this, length);
   }

   // Returns the type string of @value.  Unlike the result of calling
   // g_variant_type_peek_string(), this string is nul-terminated.  This
   // string belongs to #GVariant and must not be freed.
   // RETURNS: the type string for the type of @value
   char* get_type_string() {
      return g_variant_get_type_string(&this);
   }

   // Returns the 16-bit unsigned integer value of @value.
   // 
   // It is an error to call this function with a @value of any type
   // other than %G_VARIANT_TYPE_UINT16.
   // RETURNS: a #guint16
   ushort get_uint16() {
      return g_variant_get_uint16(&this);
   }

   // Returns the 32-bit unsigned integer value of @value.
   // 
   // It is an error to call this function with a @value of any type
   // other than %G_VARIANT_TYPE_UINT32.
   // RETURNS: a #guint32
   uint get_uint32() {
      return g_variant_get_uint32(&this);
   }

   // Returns the 64-bit unsigned integer value of @value.
   // 
   // It is an error to call this function with a @value of any type
   // other than %G_VARIANT_TYPE_UINT64.
   // RETURNS: a #guint64
   ulong get_uint64() {
      return g_variant_get_uint64(&this);
   }

   // Unintrospectable method: get_va() / g_variant_get_va()
   // This function is intended to be used by libraries based on #GVariant
   // that want to provide g_variant_get()-like functionality to their
   // users.
   // 
   // The API is more general than g_variant_get() to allow a wider range
   // of possible uses.
   // 
   // @format_string must still point to a valid format string, but it only
   // need to be nul-terminated if @endptr is %NULL.  If @endptr is
   // non-%NULL then it is updated to point to the first character past the
   // end of the format string.
   // 
   // @app is a pointer to a #va_list.  The arguments, according to
   // @format_string, are collected from this #va_list and the list is left
   // pointing to the argument following the last.
   // 
   // These two generalisations allow mixing of multiple calls to
   // g_variant_new_va() and g_variant_get_va() within a single actual
   // varargs call by the user.
   // <format_string>: a string that is prefixed with a format string
   // <endptr>: location to store the end pointer, or %NULL
   // <app>: a pointer to a #va_list
   void get_va(char* format_string, char** endptr, va_list* app) {
      g_variant_get_va(&this, format_string, endptr, app);
   }

   // Unboxes @value.  The result is the #GVariant instance that was
   // contained in @value.
   // RETURNS: the item contained in the variant
   Variant* /*new*/ get_variant() {
      return g_variant_get_variant(&this);
   }

   // Generates a hash value for a #GVariant instance.
   // 
   // The output of this function is guaranteed to be the same for a given
   // value only per-process.  It may change between different processor
   // architectures or even different versions of GLib.  Do not use this
   // function as a basis for building protocols or file formats.
   // 
   // The type of @value is #gconstpointer only to allow use of this
   // function with #GHashTable.  @value must be a #GVariant.
   // RETURNS: a hash value corresponding to @value
   uint hash() {
      return g_variant_hash(&this);
   }

   // Checks if @value is a container.
   // RETURNS: %TRUE if @value is a container
   int is_container() {
      return g_variant_is_container(&this);
   }

   // Checks whether @value has a floating reference count.
   // 
   // This function should only ever be used to assert that a given variant
   // is or is not floating, or for debug purposes. To acquire a reference
   // to a variant that might be floating, always use g_variant_ref_sink()
   // or g_variant_take_ref().
   // 
   // See g_variant_ref_sink() for more information about floating reference
   // counts.
   // RETURNS: whether @value is floating
   int is_floating() {
      return g_variant_is_floating(&this);
   }

   // Checks if @value is in normal form.
   // 
   // The main reason to do this is to detect if a given chunk of
   // serialised data is in normal form: load the data into a #GVariant
   // using g_variant_new_from_data() and then use this function to
   // check.
   // 
   // If @value is found to be in normal form then it will be marked as
   // being trusted.  If the value was already marked as being trusted then
   // this function will immediately return %TRUE.
   // RETURNS: %TRUE if @value is in normal form
   int is_normal_form() {
      return g_variant_is_normal_form(&this);
   }

   // Checks if a value has a type matching the provided type.
   // RETURNS: %TRUE if the type of @value matches @type
   // <type>: a #GVariantType
   int is_of_type(VariantType* type) {
      return g_variant_is_of_type(&this, type);
   }

   // Unintrospectable method: iter_new() / g_variant_iter_new()
   // Creates a heap-allocated #GVariantIter for iterating over the items
   // in @value.
   // 
   // Use g_variant_iter_free() to free the return value when you no longer
   // need it.
   // 
   // A reference is taken to @value and will be released only when
   // g_variant_iter_free() is called.
   // RETURNS: a new heap-allocated #GVariantIter
   VariantIter* /*new*/ iter_new() {
      return g_variant_iter_new(&this);
   }

   // Unintrospectable method: lookup() / g_variant_lookup()
   // Looks up a value in a dictionary #GVariant.
   // 
   // This function is a wrapper around g_variant_lookup_value() and
   // g_variant_get().  In the case that %NULL would have been returned,
   // this function returns %FALSE.  Otherwise, it unpacks the returned
   // value and returns %TRUE.
   // 
   // See g_variant_get() for information about @format_string.
   // RETURNS: %TRUE if a value was unpacked
   // <key>: the key to lookup in the dictionary
   // <format_string>: a GVariant format string
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_variant_lookup lookup; // Variadic
   +/

   // Looks up a value in a dictionary #GVariant.
   // 
   // This function works with dictionaries of the type
   // <literal>a{s*}</literal> (and equally well with type
   // <literal>a{o*}</literal>, but we only further discuss the string case
   // for sake of clarity).
   // 
   // In the event that @dictionary has the type <literal>a{sv}</literal>,
   // the @expected_type string specifies what type of value is expected to
   // be inside of the variant.  If the value inside the variant has a
   // different type then %NULL is returned.  In the event that @dictionary
   // has a value type other than <literal>v</literal> then @expected_type
   // must directly match the key type and it is used to unpack the value
   // directly or an error occurs.
   // 
   // In either case, if @key is not found in @dictionary, %NULL is
   // returned.
   // 
   // If the key is found and the value has the correct type, it is
   // returned.  If @expected_type was specified then any non-%NULL return
   // value will have this type.
   // RETURNS: the value of the dictionary key, or %NULL
   // <key>: the key to lookup in the dictionary
   // <expected_type>: a #GVariantType, or %NULL
   Variant* /*new*/ lookup_value(char* key, VariantType* expected_type=null) {
      return g_variant_lookup_value(&this, key, expected_type);
   }

   // Determines the number of children in a container #GVariant instance.
   // This includes variants, maybes, arrays, tuples and dictionary
   // entries.  It is an error to call this function on any other type of
   // #GVariant.
   // 
   // For variants, the return value is always 1.  For values with maybe
   // types, it is always zero or one.  For arrays, it is the length of the
   // array.  For tuples it is the number of tuple items (which depends
   // only on the type).  For dictionary entries, it is always 2
   // 
   // This function is O(1).
   // RETURNS: the number of children in the container
   size_t n_children() {
      return g_variant_n_children(&this);
   }

   // Pretty-prints @value in the format understood by g_variant_parse().
   // 
   // The format is described <link linkend='gvariant-text'>here</link>.
   // 
   // If @type_annotate is %TRUE, then type information is included in
   // the output.
   // RETURNS: a newly-allocated string holding the result.
   // <type_annotate>: %TRUE if type information should be included in the output
   char* /*new*/ print(int type_annotate) {
      return g_variant_print(&this, type_annotate);
   }

   // Unintrospectable method: print_string() / g_variant_print_string()
   // Behaves as g_variant_print(), but operates on a #GString.
   // 
   // If @string is non-%NULL then it is appended to and returned.  Else,
   // a new empty #GString is allocated and it is returned.
   // RETURNS: a #GString containing the string
   // <string>: a #GString, or %NULL
   // <type_annotate>: %TRUE if type information should be included in the output
   String* /*new*/ print_string(String* string_, int type_annotate) {
      return g_variant_print_string(&this, string_, type_annotate);
   }

   // Increases the reference count of @value.
   // RETURNS: the same @value
   Variant* /*new*/ ref_() {
      return g_variant_ref(&this);
   }

   // #GVariant uses a floating reference count system.  All functions with
   // names starting with <literal>g_variant_new_</literal> return floating
   // references.
   // 
   // Calling g_variant_ref_sink() on a #GVariant with a floating reference
   // will convert the floating reference into a full reference.  Calling
   // g_variant_ref_sink() on a non-floating #GVariant results in an
   // additional normal reference being added.
   // 
   // In other words, if the @value is floating, then this call "assumes
   // ownership" of the floating reference, converting it to a normal
   // reference.  If the @value is not floating, then this call adds a
   // new normal reference increasing the reference count by one.
   // 
   // All calls that result in a #GVariant instance being inserted into a
   // container will call g_variant_ref_sink() on the instance.  This means
   // that if the value was just created (and has only its floating
   // reference) then the container will assume sole ownership of the value
   // at that point and the caller will not need to unreference it.  This
   // makes certain common styles of programming much easier while still
   // maintaining normal refcounting semantics in situations where values
   // are not floating.
   // RETURNS: the same @value
   Variant* /*new*/ ref_sink() {
      return g_variant_ref_sink(&this);
   }

   // Stores the serialised form of @value at @data.  @data should be
   // large enough.  See g_variant_get_size().
   // 
   // The stored data is in machine native byte order but may not be in
   // fully-normalised form if read from an untrusted source.  See
   // g_variant_get_normal_form() for a solution.
   // 
   // This function is approximately O(n) in the size of @data.
   // <data>: the location to store the serialised data at
   void store(void* data) {
      g_variant_store(&this, data);
   }

   // If @value is floating, sink it.  Otherwise, do nothing.
   // 
   // Typically you want to use g_variant_ref_sink() in order to
   // automatically do the correct thing with respect to floating or
   // non-floating references, but there is one specific scenario where
   // this function is helpful.
   // 
   // The situation where this function is helpful is when creating an API
   // that allows the user to provide a callback function that returns a
   // #GVariant.  We certainly want to allow the user the flexibility to
   // return a non-floating reference from this callback (for the case
   // where the value that is being returned already exists).
   // 
   // At the same time, the style of the #GVariant API makes it likely that
   // for newly-created #GVariant instances, the user can be saved some
   // typing if they are allowed to return a #GVariant with a floating
   // reference.
   // 
   // Using this function on the return value of the user's callback allows
   // the user to do whichever is more convenient for them.  The caller
   // will alway receives exactly one full reference to the value: either
   // the one that was returned in the first place, or a floating reference
   // that has been converted to a full reference.
   // 
   // This function has an odd interaction when combined with
   // g_variant_ref_sink() running at the same time in another thread on
   // the same #GVariant instance.  If g_variant_ref_sink() runs first then
   // the result will be that the floating reference is converted to a hard
   // reference.  If g_variant_take_ref() runs first then the result will
   // be that the floating reference is converted to a hard reference and
   // an additional reference on top of that one is added.  It is best to
   // avoid this situation.
   // RETURNS: the same @value
   Variant* /*new*/ take_ref() {
      return g_variant_take_ref(&this);
   }

   // Decreases the reference count of @value.  When its reference count
   // drops to 0, the memory used by the variant is freed.
   void unref() {
      g_variant_unref(&this);
   }

   // 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.
   // RETURNS: %TRUE if @string is a D-Bus object path
   // <string>: a normal C nul-terminated string
   static int is_object_path(char* string_) {
      return g_variant_is_object_path(string_);
   }

   // Determines if a given string is a valid D-Bus type signature.  You
   // should ensure that a string is a valid D-Bus type signature before
   // passing it to g_variant_new_signature().
   // 
   // D-Bus type signatures consist of zero or more definite #GVariantType
   // strings in sequence.
   // RETURNS: %TRUE if @string is a D-Bus type signature
   // <string>: a normal C nul-terminated string
   static int is_signature(char* string_) {
      return g_variant_is_signature(string_);
   }

   // Parses a #GVariant from a text representation.
   // 
   // A single #GVariant is parsed from the content of @text.
   // 
   // The format is described <link linkend='gvariant-text'>here</link>.
   // 
   // 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 @endptr is %NULL and there is extra data
   // then an error is returned.
   // 
   // If @type is 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.
   // 
   // 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 g_variant_print()".
   // <type>: a #GVariantType, or %NULL
   // <text>: a string containing a GVariant in text form
   // <limit>: a pointer to the end of @text, or %NULL
   // <endptr>: a location to store the end pointer, or %NULL
   static Variant* /*new*/ parse(VariantType* type, char* text, char* limit, char** endptr, GLib2.Error** error=null) {
      return g_variant_parse(type, text, limit, endptr, error);
   }
   static Quark parser_get_error_quark() {
      return g_variant_parser_get_error_quark();
   }
}


// A utility type for constructing container-type #GVariant instances.
// 
// This is an opaque structure and may only be accessed using the
// following functions.
// 
// #GVariantBuilder is not threadsafe in any way.  Do not attempt to
// access it from more than one thread.
struct VariantBuilder {
   private size_t[16] x;


   // Allocates and initialises a new #GVariantBuilder.
   // 
   // You should call g_variant_builder_unref() on the return value when it
   // is no longer needed.  The memory will not be automatically freed by
   // any other call.
   // 
   // In most cases it is easier to place a #GVariantBuilder directly on
   // the stack of the calling function and initialise it with
   // g_variant_builder_init().
   // RETURNS: a #GVariantBuilder
   // <type>: a container type
   static VariantBuilder* /*new*/ new_(VariantType* type) {
      return g_variant_builder_new(type);
   }

   // Unintrospectable method: add() / g_variant_builder_add()
   // Adds to a #GVariantBuilder.
   // 
   // This call is a convenience wrapper that is exactly equivalent to
   // calling g_variant_new() followed by g_variant_builder_add_value().
   // 
   // This function might be used as follows:
   // 
   // <programlisting>
   // GVariant *
   // make_pointless_dictionary (void)
   // {
   // GVariantBuilder *builder;
   // int i;
   // 
   // builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
   // for (i = 0; i < 16; i++)
   // {
   // gchar buf[3];
   // 
   // sprintf (buf, "%d", i);
   // g_variant_builder_add (builder, "{is}", i, buf);
   // }
   // 
   // return g_variant_builder_end (builder);
   // }
   // </programlisting>
   // <format_string>: a #GVariant varargs format string
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_variant_builder_add add; // Variadic
   +/

   // Unintrospectable method: add_parsed() / g_variant_builder_add_parsed()
   // Adds to a #GVariantBuilder.
   // 
   // This call is a convenience wrapper that is exactly equivalent to
   // calling g_variant_new_parsed() followed by
   // g_variant_builder_add_value().
   // 
   // This function might be used as follows:
   // 
   // <programlisting>
   // GVariant *
   // make_pointless_dictionary (void)
   // {
   // GVariantBuilder *builder;
   // int i;
   // 
   // builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
   // g_variant_builder_add_parsed (builder, "{'width', <%i>}", 600);
   // g_variant_builder_add_parsed (builder, "{'title', <%s>}", "foo");
   // g_variant_builder_add_parsed (builder, "{'transparency', <0.5>}");
   // return g_variant_builder_end (builder);
   // }
   // </programlisting>
   // <format>: a text format #GVariant
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_variant_builder_add_parsed add_parsed; // Variadic
   +/

   // Adds @value to @builder.
   // 
   // It is an error to call this function in any way that would create an
   // inconsistent value to be constructed.  Some examples of this are
   // putting different types of items into an array, putting the wrong
   // types or number of items in a tuple, putting more than one value into
   // a variant, etc.
   // 
   // If @value is a floating reference (see g_variant_ref_sink()),
   // the @builder instance takes ownership of @value.
   // <value>: a #GVariant
   void add_value(Variant* value) {
      g_variant_builder_add_value(&this, value);
   }

   // Unintrospectable method: clear() / g_variant_builder_clear()
   // Releases all memory associated with a #GVariantBuilder without
   // freeing the #GVariantBuilder structure itself.
   // 
   // It typically only makes sense to do this on a stack-allocated
   // #GVariantBuilder if you want to abort building the value part-way
   // through.  This function need not be called if you call
   // g_variant_builder_end() and it also doesn't need to be called on
   // builders allocated with g_variant_builder_new (see
   // g_variant_builder_unref() for that).
   // 
   // This function leaves the #GVariantBuilder structure set to all-zeros.
   // It is valid to call this function on either an initialised
   // #GVariantBuilder or one that is set to all-zeros but it is not valid
   // to call this function on uninitialised memory.
   void clear() {
      g_variant_builder_clear(&this);
   }

   // Closes the subcontainer inside the given @builder that was opened by
   // the most recent call to g_variant_builder_open().
   // 
   // It is an error to call this function in any way that would create an
   // inconsistent value to be constructed (ie: too few values added to the
   // subcontainer).
   void close() {
      g_variant_builder_close(&this);
   }

   // Ends the builder process and returns the constructed value.
   // 
   // It is not permissible to use @builder in any way after this call
   // except for reference counting operations (in the case of a
   // heap-allocated #GVariantBuilder) or by reinitialising it with
   // g_variant_builder_init() (in the case of stack-allocated).
   // 
   // It is an error to call this function in any way that would create an
   // inconsistent value to be constructed (ie: insufficient number of
   // items added to a container with a specific number of children
   // required).  It is also an error to call this function if the builder
   // was created with an indefinite array or maybe type and no children
   // have been added; in this case it is impossible to infer the type of
   // the empty array.
   // RETURNS: a new, floating, #GVariant
   Variant* end() {
      return g_variant_builder_end(&this);
   }

   // Unintrospectable method: init() / g_variant_builder_init()
   // Initialises a #GVariantBuilder structure.
   // 
   // @type must be non-%NULL.  It specifies the type of container to
   // construct.  It can be an indefinite type such as
   // %G_VARIANT_TYPE_ARRAY or a definite type such as "as" or "(ii)".
   // Maybe, array, tuple, dictionary entry and variant-typed values may be
   // constructed.
   // 
   // After the builder is initialised, values are added using
   // g_variant_builder_add_value() or g_variant_builder_add().
   // 
   // After all the child values are added, g_variant_builder_end() frees
   // the memory associated with the builder and returns the #GVariant that
   // was created.
   // 
   // This function completely ignores the previous contents of @builder.
   // On one hand this means that it is valid to pass in completely
   // uninitialised memory.  On the other hand, this means that if you are
   // initialising over top of an existing #GVariantBuilder you need to
   // first call g_variant_builder_clear() in order to avoid leaking
   // memory.
   // 
   // You must not call g_variant_builder_ref() or
   // g_variant_builder_unref() on a #GVariantBuilder that was initialised
   // with this function.  If you ever pass a reference to a
   // #GVariantBuilder outside of the control of your own code then you
   // should assume that the person receiving that reference may try to use
   // reference counting; you should use g_variant_builder_new() instead of
   // this function.
   // <type>: a container type
   void init(VariantType* type) {
      g_variant_builder_init(&this, type);
   }

   // Opens a subcontainer inside the given @builder.  When done adding
   // items to the subcontainer, g_variant_builder_close() must be called.
   // 
   // It is an error to call this function in any way that would cause an
   // inconsistent value to be constructed (ie: adding too many values or
   // a value of an incorrect type).
   // <type>: a #GVariantType
   void open(VariantType* type) {
      g_variant_builder_open(&this, type);
   }

   // Increases the reference count on @builder.
   // 
   // Don't call this on stack-allocated #GVariantBuilder instances or bad
   // things will happen.
   // RETURNS: a new reference to @builder
   VariantBuilder* /*new*/ ref_() {
      return g_variant_builder_ref(&this);
   }

   // Decreases the reference count on @builder.
   // 
   // In the event that there are no more references, releases all memory
   // associated with the #GVariantBuilder.
   // 
   // Don't call this on stack-allocated #GVariantBuilder instances or bad
   // things will happen.
   void unref() {
      g_variant_builder_unref(&this);
   }
}

// The range of possible top-level types of #GVariant instances.
enum VariantClass /* Version 2.24 */ {
   BOOLEAN = 98,
   BYTE = 121,
   INT16 = 110,
   UINT16 = 113,
   INT32 = 105,
   UINT32 = 117,
   INT64 = 120,
   UINT64 = 116,
   HANDLE = 104,
   DOUBLE = 100,
   STRING = 115,
   OBJECT_PATH = 111,
   SIGNATURE = 103,
   VARIANT = 118,
   MAYBE = 109,
   ARRAY = 97,
   TUPLE = 40,
   DICT_ENTRY = 123
}

// #GVariantIter is an opaque data structure and can only be accessed
// using the following functions.
struct VariantIter {
   private size_t[16] x;


   // Unintrospectable method: copy() / g_variant_iter_copy()
   // Creates a new heap-allocated #GVariantIter to iterate over the
   // container that was being iterated over by @iter.  Iteration begins on
   // the new iterator from the current position of the old iterator but
   // the two copies are independent past that point.
   // 
   // Use g_variant_iter_free() to free the return value when you no longer
   // need it.
   // 
   // A reference is taken to the container that @iter is iterating over
   // and will be releated only when g_variant_iter_free() is called.
   // RETURNS: a new heap-allocated #GVariantIter
   VariantIter* /*new*/ copy() {
      return g_variant_iter_copy(&this);
   }

   // Frees a heap-allocated #GVariantIter.  Only call this function on
   // iterators that were returned by g_variant_iter_new() or
   // g_variant_iter_copy().
   void free() {
      g_variant_iter_free(&this);
   }

   // Unintrospectable method: init() / g_variant_iter_init()
   // Initialises (without allocating) a #GVariantIter.  @iter may be
   // completely uninitialised prior to this call; its old value is
   // ignored.
   // 
   // The iterator remains valid for as long as @value exists, and need not
   // be freed in any way.
   // RETURNS: the number of items in @value
   // <value>: a container #GVariant
   size_t init(Variant* value) {
      return g_variant_iter_init(&this, value);
   }

   // Unintrospectable method: loop() / g_variant_iter_loop()
   // Gets the next item in the container and unpacks it into the variable
   // argument list according to @format_string, returning %TRUE.
   // 
   // If no more items remain then %FALSE is returned.
   // 
   // On the first call to this function, the pointers appearing on the
   // variable argument list are assumed to point at uninitialised memory.
   // On the second and later calls, it is assumed that the same pointers
   // will be given and that they will point to the memory as set by the
   // previous call to this function.  This allows the previous values to
   // be freed, as appropriate.
   // 
   // This function is intended to be used with a while loop as
   // demonstrated in the following example.  This function can only be
   // used when iterating over an array.  It is only valid to call this
   // function with a string constant for the format string and the same
   // string constant must be used each time.  Mixing calls to this
   // function and g_variant_iter_next() or g_variant_iter_next_value() on
   // the same iterator is not recommended.
   // 
   // See the section on <link linkend='gvariant-format-strings'>GVariant
   // Format Strings</link>.
   // 
   // <example>
   // <title>Memory management with g_variant_iter_loop()</title>
   // <programlisting>
   // /<!-- -->* Iterates a dictionary of type 'a{sv}' *<!-- -->/
   // void
   // iterate_dictionary (GVariant *dictionary)
   // {
   // GVariantIter iter;
   // GVariant *value;
   // gchar *key;
   // 
   // g_variant_iter_init (&iter, dictionary);
   // while (g_variant_iter_loop (&iter, "{sv}", &key, &value))
   // {
   // g_print ("Item '%s' has type '%s'\n", key,
   // g_variant_get_type_string (value));
   // 
   // /<!-- -->* no need to free 'key' and 'value' here *<!-- -->/
   // }
   // }
   // </programlisting>
   // </example>
   // 
   // For most cases you should use g_variant_iter_next().
   // 
   // This function is really only useful when unpacking into #GVariant or
   // #GVariantIter in order to allow you to skip the call to
   // g_variant_unref() or g_variant_iter_free().
   // 
   // For example, if you are only looping over simple integer and string
   // types, g_variant_iter_next() is definitely preferred.  For string
   // types, use the '&' prefix to avoid allocating any memory at all (and
   // thereby avoiding the need to free anything as well).
   // RETURNS: %TRUE if a value was unpacked, or %FALSE if there as no value
   // <format_string>: a GVariant format string
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_variant_iter_loop loop; // Variadic
   +/

   // Queries the number of child items in the container that we are
   // iterating over.  This is the total number of items -- not the number
   // of items remaining.
   // 
   // This function might be useful for preallocation of arrays.
   // RETURNS: the number of children in the container
   size_t n_children() {
      return g_variant_iter_n_children(&this);
   }

   // Unintrospectable method: next() / g_variant_iter_next()
   // Gets the next item in the container and unpacks it into the variable
   // argument list according to @format_string, returning %TRUE.
   // 
   // If no more items remain then %FALSE is returned.
   // 
   // All of the pointers given on the variable arguments list of this
   // function are assumed to point at uninitialised memory.  It is the
   // responsibility of the caller to free all of the values returned by
   // the unpacking process.
   // 
   // See the section on <link linkend='gvariant-format-strings'>GVariant
   // Format Strings</link>.
   // 
   // <example>
   // <title>Memory management with g_variant_iter_next()</title>
   // <programlisting>
   // /<!-- -->* Iterates a dictionary of type 'a{sv}' *<!-- -->/
   // void
   // iterate_dictionary (GVariant *dictionary)
   // {
   // GVariantIter iter;
   // GVariant *value;
   // gchar *key;
   // 
   // g_variant_iter_init (&iter, dictionary);
   // while (g_variant_iter_next (&iter, "{sv}", &key, &value))
   // {
   // g_print ("Item '%s' has type '%s'\n", key,
   // g_variant_get_type_string (value));
   // 
   // /<!-- -->* must free data for ourselves *<!-- -->/
   // g_variant_unref (value);
   // g_free (key);
   // }
   // }
   // </programlisting>
   // </example>
   // 
   // For a solution that is likely to be more convenient to C programmers
   // when dealing with loops, see g_variant_iter_loop().
   // RETURNS: %TRUE if a value was unpacked, or %FALSE if there as no value
   // <format_string>: a GVariant format string
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias g_variant_iter_next next; // Variadic
   +/

   // Gets the next item in the container.  If no more items remain then
   // %NULL is returned.
   // 
   // Use g_variant_unref() to drop your reference on the return value when
   // you no longer need it.
   // 
   // <example>
   // <title>Iterating with g_variant_iter_next_value()</title>
   // <programlisting>
   // /<!-- -->* recursively iterate a container *<!-- -->/
   // void
   // iterate_container_recursive (GVariant *container)
   // {
   // GVariantIter iter;
   // GVariant *child;
   // 
   // g_variant_iter_init (&iter, container);
   // while ((child = g_variant_iter_next_value (&iter)))
   // {
   // g_print ("type '%s'\n", g_variant_get_type_string (child));
   // 
   // if (g_variant_is_container (child))
   // iterate_container_recursive (child);
   // 
   // g_variant_unref (child);
   // }
   // }
   // </programlisting>
   // </example>
   // RETURNS: a #GVariant, or %NULL
   Variant* /*new*/ next_value() {
      return g_variant_iter_next_value(&this);
   }
}

// Error codes returned by parsing text-format GVariants.
enum VariantParseError {
   FAILED = 0,
   BASIC_TYPE_EXPECTED = 1,
   CANNOT_INFER_TYPE = 2,
   DEFINITE_TYPE_EXPECTED = 3,
   INPUT_NOT_AT_END = 4,
   INVALID_CHARACTER = 5,
   INVALID_FORMAT_STRING = 6,
   INVALID_OBJECT_PATH = 7,
   INVALID_SIGNATURE = 8,
   INVALID_TYPE_STRING = 9,
   NO_COMMON_TYPE = 10,
   NUMBER_OUT_OF_RANGE = 11,
   NUMBER_TOO_BIG = 12,
   TYPE_ERROR = 13,
   UNEXPECTED_TOKEN = 14,
   UNKNOWN_KEYWORD = 15,
   UNTERMINATED_STRING_CONSTANT = 16,
   VALUE_EXPECTED = 17
}

// This section introduces the GVariant type system.  It is based, in
// large part, on the D-Bus type system, with two major changes and some minor
// lifting of restrictions.  The <ulink
// url='http://dbus.freedesktop.org/doc/dbus-specification.html'>DBus
// specification</ulink>, therefore, provides a significant amount of
// information that is useful when working with GVariant.
// 
// The first major change with respect to the D-Bus type system is the
// introduction of maybe (or "nullable") types.  Any type in GVariant can be
// converted to a maybe type, in which case, "nothing" (or "null") becomes a
// valid value.  Maybe types have been added by introducing the
// character "<literal>m</literal>" to type strings.
// 
// The second major change is that the GVariant type system supports the
// concept of "indefinite types" -- types that are less specific than
// the normal types found in D-Bus.  For example, it is possible to speak
// of "an array of any type" in GVariant, where the D-Bus type system
// would require you to speak of "an array of integers" or "an array of
// strings".  Indefinite types have been added by introducing the
// characters "<literal>*</literal>", "<literal>?</literal>" and
// "<literal>r</literal>" to type strings.
// 
// Finally, all arbitrary restrictions relating to the complexity of
// types are lifted along with the restriction that dictionary entries
// may only appear nested inside of arrays.
// 
// Just as in D-Bus, GVariant types are described with strings ("type
// strings").  Subject to the differences mentioned above, these strings
// are of the same form as those found in DBus.  Note, however: D-Bus
// always works in terms of messages and therefore individual type
// strings appear nowhere in its interface.  Instead, "signatures"
// are a concatenation of the strings of the type of each argument in a
// message.  GVariant deals with single values directly so GVariant type
// strings always describe the type of exactly one value.  This means
// that a D-Bus signature string is generally not a valid GVariant type
// string -- except in the case that it is the signature of a message
// containing exactly one argument.
// 
// An indefinite type is similar in spirit to what may be called an
// abstract type in other type systems.  No value can exist that has an
// indefinite type as its type, but values can exist that have types
// that are subtypes of indefinite types.  That is to say,
// g_variant_get_type() will never return an indefinite type, but
// calling g_variant_is_of_type() with an indefinite type may return
// %TRUE.  For example, you cannot have a value that represents "an
// array of no particular type", but you can have an "array of integers"
// which certainly matches the type of "an array of no particular type",
// since "array of integers" is a subtype of "array of no particular
// type".
// 
// This is similar to how instances of abstract classes may not
// directly exist in other type systems, but instances of their
// non-abstract subtypes may.  For example, in GTK, no object that has
// the type of #GtkBin can exist (since #GtkBin is an abstract class),
// but a #GtkWindow can certainly be instantiated, and you would say
// that the #GtkWindow is a #GtkBin (since #GtkWindow is a subclass of
// #GtkBin).
// 
// A detailed description of GVariant type strings is given here:
// 
// <refsect2 id='gvariant-typestrings'>
// <title>GVariant Type Strings</title>
// <para>
// A GVariant type string can be any of the following:
// </para>
// <itemizedlist>
// <listitem>
// <para>
// any basic type string (listed below)
// </para>
// </listitem>
// <listitem>
// <para>
// "<literal>v</literal>", "<literal>r</literal>" or
// "<literal>*</literal>"
// </para>
// </listitem>
// <listitem>
// <para>
// one of the characters '<literal>a</literal>' or
// '<literal>m</literal>', followed by another type string
// </para>
// </listitem>
// <listitem>
// <para>
// the character '<literal>(</literal>', followed by a concatenation
// of zero or more other type strings, followed by the character
// '<literal>)</literal>'
// </para>
// </listitem>
// <listitem>
// <para>
// the character '<literal>{</literal>', followed by a basic type
// string (see below), followed by another type string, followed by
// the character '<literal>}</literal>'
// </para>
// </listitem>
// </itemizedlist>
// <para>
// A basic type string describes a basic type (as per
// g_variant_type_is_basic()) and is always a single
// character in length.  The valid basic type strings are
// "<literal>b</literal>", "<literal>y</literal>",
// "<literal>n</literal>", "<literal>q</literal>",
// "<literal>i</literal>", "<literal>u</literal>",
// "<literal>x</literal>", "<literal>t</literal>",
// "<literal>h</literal>", "<literal>d</literal>",
// "<literal>s</literal>", "<literal>o</literal>",
// "<literal>g</literal>" and "<literal>?</literal>".
// </para>
// <para>
// The above definition is recursive to arbitrary depth.
// "<literal>aaaaai</literal>" and "<literal>(ui(nq((y)))s)</literal>"
// are both valid type strings, as is
// "<literal>a(aa(ui)(qna{ya(yd)}))</literal>".
// </para>
// <para>
// The meaning of each of the characters is as follows:
// </para>
// <informaltable>
// <tgroup cols='2'>
// <tbody>
// <row>
// <entry>
// <para>
// <emphasis role='strong'>Character</emphasis>
// </para>
// </entry>
// <entry>
// <para>
// <emphasis role='strong'>Meaning</emphasis>
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>b</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_BOOLEAN; a boolean value.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>y</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_BYTE; a byte.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>n</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_INT16; a signed 16 bit
// integer.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>q</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_UINT16; an unsigned 16 bit
// integer.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>i</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_INT32; a signed 32 bit
// integer.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>u</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_UINT32; an unsigned 32 bit
// integer.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>x</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_INT64; a signed 64 bit
// integer.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>t</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_UINT64; an unsigned 64 bit
// integer.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>h</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_HANDLE; a signed 32 bit
// value that, by convention, is used as an index into an array
// of file descriptors that are sent alongside a D-Bus message.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>d</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_DOUBLE; a double precision
// floating point value.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>s</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_STRING; a string.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>o</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_OBJECT_PATH; a string in
// the form of a D-Bus object path.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>g</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_STRING; a string in the
// form of a D-Bus type signature.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>?</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_BASIC; an indefinite type
// that is a supertype of any of the basic types.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>v</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_VARIANT; a container type
// that contain any other type of value.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>a</literal>
// </para>
// </entry>
// <entry>
// <para>
// used as a prefix on another type string to mean an array of
// that type; the type string "<literal>ai</literal>", for
// example, is the type of an array of 32 bit signed integers.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>m</literal>
// </para>
// </entry>
// <entry>
// <para>
// used as a prefix on another type string to mean a "maybe", or
// "nullable", version of that type; the type string
// "<literal>ms</literal>", for example, is the type of a value
// that maybe contains a string, or maybe contains nothing.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>()</literal>
// </para>
// </entry>
// <entry>
// <para>
// used to enclose zero or more other concatenated type strings
// to create a tuple type; the type string
// "<literal>(is)</literal>", for example, is the type of a pair
// of an integer and a string.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>r</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_TUPLE; an indefinite type
// that is a supertype of any tuple type, regardless of the
// number of items.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>{}</literal>
// </para>
// </entry>
// <entry>
// <para>
// used to enclose a basic type string concatenated with another
// type string to create a dictionary entry type, which usually
// appears inside of an array to form a dictionary; the type
// string "<literal>a{sd}</literal>", for example, is the type of
// a dictionary that maps strings to double precision floating
// point values.
// </para>
// <para>
// The first type (the basic type) is the key type and the second
// type is the value type.  The reason that the first type is
// restricted to being a basic type is so that it can easily be
// hashed.
// </para>
// </entry>
// </row>
// <row>
// <entry>
// <para>
// <literal>*</literal>
// </para>
// </entry>
// <entry>
// <para>
// the type string of %G_VARIANT_TYPE_ANY; the indefinite type
// that is a supertype of all types.  Note that, as with all type
// strings, this character represents exactly one type.  It
// cannot be used inside of tuples to mean "any number of items".
// </para>
// </entry>
// </row>
// </tbody>
// </tgroup>
// </informaltable>
// <para>
// Any type string of a container that contains an indefinite type is,
// itself, an indefinite type.  For example, the type string
// "<literal>a*</literal>" (corresponding to %G_VARIANT_TYPE_ARRAY) is
// an indefinite type that is a supertype of every array type.
// "<literal>(*s)</literal>" is a supertype of all tuples that
// contain exactly two items where the second item is a string.
// </para>
// <para>
// "<literal>a{?*}</literal>" is an indefinite type that is a
// supertype of all arrays containing dictionary entries where the key
// is any basic type and the value is any type at all.  This is, by
// definition, a dictionary, so this type string corresponds to
// %G_VARIANT_TYPE_DICTIONARY.  Note that, due to the restriction that
// the key of a dictionary entry must be a basic type,
// "<literal>{**}</literal>" is not a valid type string.
// </para>
// </refsect2>
struct VariantType {

   // Creates a new #GVariantType corresponding to the type string given
   // by @type_string.  It is appropriate to call g_variant_type_free() on
   // the return value.
   // 
   // It is a programmer error to call this function with an invalid type
   // string.  Use g_variant_type_string_is_valid() if you are unsure.
   // RETURNS: a new #GVariantType
   // <type_string>: a valid GVariant type string
   static VariantType* /*new*/ new_(char* type_string) {
      return g_variant_type_new(type_string);
   }

   // Constructs a new tuple type, from @items.
   // 
   // @length is the number of items in @items, or -1 to indicate that
   // @items is %NULL-terminated.
   // 
   // It is appropriate to call g_variant_type_free() on the return value.
   // 
   // Since 2.24
   // RETURNS: a new tuple #GVariantType
   // <items>: an array of #GVariantTypes, one for each item
   // <length>: the length of @items, or -1
   static VariantType* /*new*/ new_tuple(VariantType** items, int length) {
      return g_variant_type_new_tuple(items, length);
   }

   // Makes a copy of a #GVariantType.  It is appropriate to call
   // g_variant_type_free() on the return value.  @type may not be %NULL.
   // 
   // Since 2.24
   // RETURNS: a new #GVariantType
   VariantType* /*new*/ copy() {
      return g_variant_type_copy(&this);
   }

   // Returns a newly-allocated copy of the type string corresponding to
   // @type.  The returned string is nul-terminated.  It is appropriate to
   // call g_free() on the return value.
   // 
   // Since 2.24
   // RETURNS: the corresponding type string
   char* /*new*/ dup_string() {
      return g_variant_type_dup_string(&this);
   }

   // Determines the element type of an array or maybe type.
   // 
   // This function may only be used with array or maybe types.
   // 
   // Since 2.24
   // RETURNS: the element type of @type
   VariantType* element() {
      return g_variant_type_element(&this);
   }

   // Compares @type1 and @type2 for equality.
   // 
   // Only returns %TRUE if the types are exactly equal.  Even if one type
   // is an indefinite type and the other is a subtype of it, %FALSE will
   // be returned if they are not exactly equal.  If you want to check for
   // subtypes, use g_variant_type_is_subtype_of().
   // 
   // The argument types of @type1 and @type2 are only #gconstpointer to
   // allow use with #GHashTable without function pointer casting.  For
   // both arguments, a valid #GVariantType must be provided.
   // 
   // Since 2.24
   // RETURNS: %TRUE if @type1 and @type2 are exactly equal
   // <type2>: a #GVariantType
   int equal(const(VariantType)* type2) {
      return g_variant_type_equal(&this, type2);
   }

   // Determines the first item type of a tuple or dictionary entry
   // type.
   // 
   // This function may only be used with tuple or dictionary entry types,
   // but must not be used with the generic tuple type
   // %G_VARIANT_TYPE_TUPLE.
   // 
   // In the case of a dictionary entry type, this returns the type of
   // the key.
   // 
   // %NULL is returned in case of @type being %G_VARIANT_TYPE_UNIT.
   // 
   // This call, together with g_variant_type_next() provides an iterator
   // interface over tuple and dictionary entry types.
   // 
   // Since 2.24
   // RETURNS: the first item type of @type, or %NULL
   VariantType* first() {
      return g_variant_type_first(&this);
   }

   // Frees a #GVariantType that was allocated with
   // g_variant_type_copy(), g_variant_type_new() or one of the container
   // type constructor functions.
   // 
   // In the case that @type is %NULL, this function does nothing.
   // 
   // Since 2.24
   void free() {
      g_variant_type_free(&this);
   }

   // Returns the length of the type string corresponding to the given
   // @type.  This function must be used to determine the valid extent of
   // the memory region returned by g_variant_type_peek_string().
   // 
   // Since 2.24
   // RETURNS: the length of the corresponding type string
   size_t get_string_length() {
      return g_variant_type_get_string_length(&this);
   }

   // Hashes @type.
   // 
   // The argument type of @type is only #gconstpointer to allow use with
   // #GHashTable without function pointer casting.  A valid
   // #GVariantType must be provided.
   // 
   // Since 2.24
   // RETURNS: the hash value
   uint hash() {
      return g_variant_type_hash(&this);
   }

   // Determines if the given @type is an array type.  This is true if the
   // type string for @type starts with an 'a'.
   // 
   // This function returns %TRUE for any indefinite type for which every
   // definite subtype is an array type -- %G_VARIANT_TYPE_ARRAY, for
   // example.
   // 
   // Since 2.24
   // RETURNS: %TRUE if @type is an array type
   int is_array() {
      return g_variant_type_is_array(&this);
   }

   // Determines if the given @type is a basic type.
   // 
   // Basic types are booleans, bytes, integers, doubles, strings, object
   // paths and signatures.
   // 
   // Only a basic type may be used as the key of a dictionary entry.
   // 
   // This function returns %FALSE for all indefinite types except
   // %G_VARIANT_TYPE_BASIC.
   // 
   // Since 2.24
   // RETURNS: %TRUE if @type is a basic type
   int is_basic() {
      return g_variant_type_is_basic(&this);
   }

   // Determines if the given @type is a container type.
   // 
   // Container types are any array, maybe, tuple, or dictionary
   // entry types plus the variant type.
   // 
   // This function returns %TRUE for any indefinite type for which every
   // definite subtype is a container -- %G_VARIANT_TYPE_ARRAY, for
   // example.
   // 
   // Since 2.24
   // RETURNS: %TRUE if @type is a container type
   int is_container() {
      return g_variant_type_is_container(&this);
   }

   // Determines if the given @type is definite (ie: not indefinite).
   // 
   // A type is definite if its type string does not contain any indefinite
   // type characters ('*', '?', or 'r').
   // 
   // A #GVariant instance may not have an indefinite type, so calling
   // this function on the result of g_variant_get_type() will always
   // result in %TRUE being returned.  Calling this function on an
   // indefinite type like %G_VARIANT_TYPE_ARRAY, however, will result in
   // %FALSE being returned.
   // 
   // Since 2.24
   // RETURNS: %TRUE if @type is definite
   int is_definite() {
      return g_variant_type_is_definite(&this);
   }

   // Determines if the given @type is a dictionary entry type.  This is
   // true if the type string for @type starts with a '{'.
   // 
   // This function returns %TRUE for any indefinite type for which every
   // definite subtype is a dictionary entry type --
   // %G_VARIANT_TYPE_DICT_ENTRY, for example.
   // 
   // Since 2.24
   // RETURNS: %TRUE if @type is a dictionary entry type
   int is_dict_entry() {
      return g_variant_type_is_dict_entry(&this);
   }

   // Determines if the given @type is a maybe type.  This is true if the
   // type string for @type starts with an 'm'.
   // 
   // This function returns %TRUE for any indefinite type for which every
   // definite subtype is a maybe type -- %G_VARIANT_TYPE_MAYBE, for
   // example.
   // 
   // Since 2.24
   // RETURNS: %TRUE if @type is a maybe type
   int is_maybe() {
      return g_variant_type_is_maybe(&this);
   }

   // Checks if @type is a subtype of @supertype.
   // 
   // This function returns %TRUE if @type is a subtype of @supertype.  All
   // types are considered to be subtypes of themselves.  Aside from that,
   // only indefinite types can have subtypes.
   // 
   // Since 2.24
   // RETURNS: %TRUE if @type is a subtype of @supertype
   // <supertype>: a #GVariantType
   int is_subtype_of(VariantType* supertype) {
      return g_variant_type_is_subtype_of(&this, supertype);
   }

   // Determines if the given @type is a tuple type.  This is true if the
   // type string for @type starts with a '(' or if @type is
   // %G_VARIANT_TYPE_TUPLE.
   // 
   // This function returns %TRUE for any indefinite type for which every
   // definite subtype is a tuple type -- %G_VARIANT_TYPE_TUPLE, for
   // example.
   // 
   // Since 2.24
   // RETURNS: %TRUE if @type is a tuple type
   int is_tuple() {
      return g_variant_type_is_tuple(&this);
   }

   // Determines if the given @type is the variant type.
   // 
   // Since 2.24
   // RETURNS: %TRUE if @type is the variant type
   int is_variant() {
      return g_variant_type_is_variant(&this);
   }

   // Determines the key type of a dictionary entry type.
   // 
   // This function may only be used with a dictionary entry type.  Other
   // than the additional restriction, this call is equivalent to
   // g_variant_type_first().
   // 
   // Since 2.24
   // RETURNS: the key type of the dictionary entry
   VariantType* key() {
      return g_variant_type_key(&this);
   }

   // Determines the number of items contained in a tuple or
   // dictionary entry type.
   // 
   // This function may only be used with tuple or dictionary entry types,
   // but must not be used with the generic tuple type
   // %G_VARIANT_TYPE_TUPLE.
   // 
   // In the case of a dictionary entry type, this function will always
   // return 2.
   // 
   // Since 2.24
   // RETURNS: the number of items in @type
   size_t n_items() {
      return g_variant_type_n_items(&this);
   }

   // Constructs the type corresponding to an array of elements of the
   // type @type.
   // 
   // It is appropriate to call g_variant_type_free() on the return value.
   // 
   // Since 2.24
   // RETURNS: a new array #GVariantType
   VariantType* /*new*/ new_array() {
      return g_variant_type_new_array(&this);
   }

   // Constructs the type corresponding to a dictionary entry with a key
   // of type @key and a value of type @value.
   // 
   // It is appropriate to call g_variant_type_free() on the return value.
   // 
   // Since 2.24
   // RETURNS: a new dictionary entry #GVariantType
   // <value>: a #GVariantType
   VariantType* /*new*/ new_dict_entry(VariantType* value) {
      return g_variant_type_new_dict_entry(&this, value);
   }

   // Constructs the type corresponding to a maybe instance containing
   // type @type or Nothing.
   // 
   // It is appropriate to call g_variant_type_free() on the return value.
   // 
   // Since 2.24
   // RETURNS: a new maybe #GVariantType
   VariantType* /*new*/ new_maybe() {
      return g_variant_type_new_maybe(&this);
   }

   // Determines the next item type of a tuple or dictionary entry
   // type.
   // 
   // @type must be the result of a previous call to
   // g_variant_type_first() or g_variant_type_next().
   // 
   // If called on the key type of a dictionary entry then this call
   // returns the value type.  If called on the value type of a dictionary
   // entry then this call returns %NULL.
   // 
   // For tuples, %NULL is returned when @type is the last item in a tuple.
   // 
   // Since 2.24
   // RETURNS: the next #GVariantType after @type, or %NULL
   VariantType* next() {
      return g_variant_type_next(&this);
   }

   // Unintrospectable method: peek_string() / g_variant_type_peek_string()
   // Returns the type string corresponding to the given @type.  The
   // result is not nul-terminated; in order to determine its length you
   // must call g_variant_type_get_string_length().
   // 
   // To get a nul-terminated string, see g_variant_type_dup_string().
   // 
   // Since 2.24
   // RETURNS: the corresponding type string (not nul-terminated)
   char* peek_string() {
      return g_variant_type_peek_string(&this);
   }

   // Determines the value type of a dictionary entry type.
   // 
   // This function may only be used with a dictionary entry type.
   // 
   // Since 2.24
   // RETURNS: the value type of the dictionary entry
   VariantType* value() {
      return g_variant_type_value(&this);
   }
   static VariantType* checked_(char* arg_a) {
      return g_variant_type_checked_(arg_a);
   }

   // Checks if @type_string is a valid GVariant type string.  This call is
   // equivalent to calling g_variant_type_string_scan() and confirming
   // that the following character is a nul terminator.
   // 
   // Since 2.24
   // RETURNS: %TRUE if @type_string is exactly one valid type string
   // <type_string>: a pointer to any string
   static int string_is_valid(char* type_string) {
      return g_variant_type_string_is_valid(type_string);
   }

   // 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 g_variant_type_string_is_valid().
   // RETURNS: %TRUE if a valid type string was found
   // <string>: a pointer to any string
   // <limit>: the end of @string, or %NULL
   // <endptr>: location to store the end pointer, or %NULL
   static int string_scan(char* string_, char* limit=null, /*out*/ char** endptr=null) {
      return g_variant_type_string_scan(string_, limit, endptr);
   }
}


// 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().
extern (C) alias void function () VoidFunc;

enum int WIN32_MSG_HANDLE = 19981206;

// 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().
// 
// object that has all the tested permissions, or -1 otherwise or on
// error.
// RETURNS: zero if the pathname refers to an existing file system
// <filename>: a pathname in the GLib file name encoding (UTF-8 on Windows)
// <mode>: as in access()
static int access(char* filename, int mode) {
   return g_access(filename, mode);
}


// Frees the memory allocated for the #GArray. If @free_segment is
// %TRUE it frees the memory block holding the elements as well and
// also each element if @array has a @element_free_func set. Pass
// %FALSE if you want to free the #GArray wrapper but preserve the
// underlying array for use elsewhere. If the reference count of @array
// is greater than one, the #GArray wrapper is preserved but the size
// of @array will be set to zero.
// 
// <note><para>If array elements contain dynamically-allocated memory,
// they should be freed separately.</para></note>
// <array>: a #GArray.
// <free_segment>: if %TRUE the actual element data is freed as well.
static char* /*new*/ array_free(Array* array, int free_segment) {
   return g_array_free(array, free_segment);
}


// Gets the size of the elements in @array.
// RETURNS: Size of each element, in bytes.
// <array>: A #GArray.
static uint array_get_element_size(Array* array) {
   return g_array_get_element_size(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 MT-safe and may be called from any
// thread.
// <array>: A #GArray.
static void array_unref(Array* array) {
   g_array_unref(array);
}


// Determines the numeric value of a character as a decimal
// digit. Differs from g_unichar_digit_value() because it takes
// a char, so there's no worry about sign extension if characters
// are signed.
// 
// g_ascii_isdigit()), its numeric value. Otherwise, -1.
// RETURNS: If @c is a decimal digit (according to
// <c>: an ASCII character.
static int ascii_digit_value(char c) {
   return g_ascii_digit_value(c);
}


// Converts a #gdouble to a string, using the '.' as
// decimal point.
// 
// This functions generates enough precision that converting
// the string back using g_ascii_strtod() gives the same machine-number
// (on machines with IEEE compatible 64bit doubles). It is
// guaranteed that the size of the resulting string will never
// be larger than @G_ASCII_DTOSTR_BUF_SIZE bytes.
// RETURNS: The pointer to the buffer with the converted string.
// <buffer>: A buffer to place the resulting string in
// <buf_len>: The length of the buffer.
// <d>: The #gdouble to convert
static char* /*new*/ ascii_dtostr(char* buffer, int buf_len, double d) {
   return g_ascii_dtostr(buffer, buf_len, d);
}


// Converts a #gdouble to a string, using the '.' as
// decimal point. To format the number you pass in
// a printf()-style format string. Allowed conversion
// specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'.
// 
// If you just want to want to serialize the value into a
// string, use g_ascii_dtostr().
// RETURNS: The pointer to the buffer with the converted string.
// <buffer>: A buffer to place the resulting string in
// <buf_len>: The length of the buffer.
// <format>: The printf()-style format to use for the code to use for converting.
// <d>: The #gdouble to convert
static char* /*new*/ ascii_formatd(char* buffer, int buf_len, char* format, double d) {
   return g_ascii_formatd(buffer, buf_len, format, d);
}


// 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.
// 
// or a positive value if @s1 &gt; @s2.
// RETURNS: 0 if the strings match, a negative value if @s1 &lt; @s2,
// <s1>: string to compare with @s2.
// <s2>: string to compare with @s1.
static int ascii_strcasecmp(char* s1, char* s2) {
   return g_ascii_strcasecmp(s1, s2);
}


// Converts all upper case ASCII letters to lower case ASCII letters.
// 
// characters in @str converted to lower case, with
// semantics that exactly match g_ascii_tolower(). (Note
// that this is unlike the old g_strdown(), which modified
// the string in place.)
// RETURNS: a newly-allocated string, with all the upper case
// <str>: a string.
// <len>: length of @str in bytes, or -1 if @str is nul-terminated.
static char* /*new*/ ascii_strdown(char* str, ssize_t len) {
   return g_ascii_strdown(str, len);
}


// Compare @s1 and @s2, ignoring the case of ASCII characters and any
// characters after the first @n in each string.
// 
// Unlike the BSD strcasecmp() function, this only recognizes standard
// ASCII letters and ignores the locale, treating all non-ASCII
// characters as if they are not letters.
// 
// The same warning as in g_ascii_strcasecmp() applies: Use this
// function only on strings known to be in encodings where bytes
// corresponding to ASCII letters always represent themselves.
// 
// or a positive value if @s1 &gt; @s2.
// RETURNS: 0 if the strings match, a negative value if @s1 &lt; @s2,
// <s1>: string to compare with @s2.
// <s2>: string to compare with @s1.
// <n>: number of characters to compare.
static int ascii_strncasecmp(char* s1, char* s2, size_t n) {
   return g_ascii_strncasecmp(s1, s2, n);
}


// Converts a string to a #gdouble 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 system strtod() function.
// 
// To convert from a #gdouble to a string in a locale-insensitive
// way, use g_ascii_dtostr().
// 
// If the correct value would cause overflow, plus or minus %HUGE_VAL
// is returned (according to the sign of the value), and %ERANGE is
// stored in %errno. If the correct value would cause underflow,
// zero is returned and %ERANGE is stored in %errno.
// 
// This function resets %errno before calling strtod() so that
// you can reliably detect overflow and underflow.
// RETURNS: the #gdouble value.
// <nptr>: the string to convert to a numeric value.
// <endptr>: if non-%NULL, it returns the character after the last character used in the conversion.
static double ascii_strtod(char* nptr, char** endptr) {
   return g_ascii_strtod(nptr, endptr);
}


// Converts a string to a #gint64 value.
// This function behaves like the standard strtoll() 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 system strtoll() function.
// 
// If the correct value would cause overflow, %G_MAXINT64 or %G_MININT64
// is returned, and %ERANGE is stored in %errno.  If the base is
// outside the valid range, zero is returned, and %EINVAL is stored
// in %errno.  If the string conversion fails, zero is returned, and
// @endptr returns @nptr (if @endptr is non-%NULL).
// RETURNS: the #gint64 value or zero on error.
// <nptr>: the string to convert to a numeric value.
// <endptr>: if non-%NULL, it returns the character after the last character used in the conversion.
// <base>: to be used for the conversion, 2..36 or 0
static long ascii_strtoll(char* nptr, char** endptr, uint base) {
   return g_ascii_strtoll(nptr, endptr, base);
}


// Converts a string to a #guint64 value.
// This function behaves like the standard strtoull() 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 system strtoull() function.
// 
// If the correct value would cause overflow, %G_MAXUINT64
// is returned, and %ERANGE is stored in %errno.  If the base is
// outside the valid range, zero is returned, and %EINVAL is stored
// in %errno.  If the string conversion fails, zero is returned, and
// @endptr returns @nptr (if @endptr is non-%NULL).
// RETURNS: the #guint64 value or zero on error.
// <nptr>: the string to convert to a numeric value.
// <endptr>: if non-%NULL, it returns the character after the last character used in the conversion.
// <base>: to be used for the conversion, 2..36 or 0
static ulong ascii_strtoull(char* nptr, char** endptr, uint base) {
   return g_ascii_strtoull(nptr, endptr, base);
}


// Converts all lower case ASCII letters to upper case ASCII letters.
// 
// characters in @str converted to upper case, with
// semantics that exactly match g_ascii_toupper(). (Note
// that this is unlike the old g_strup(), which modified
// the string in place.)
// RETURNS: a newly allocated string, with all the lower case
// <str>: a string.
// <len>: length of @str in bytes, or -1 if @str is nul-terminated.
static char* /*new*/ ascii_strup(char* str, ssize_t len) {
   return g_ascii_strup(str, len);
}


// Convert a character to ASCII lower case.
// 
// Unlike the standard C library tolower() function, this only
// recognizes standard ASCII letters and ignores the locale, returning
// all non-ASCII characters unchanged, even if they are lower case
// letters in a particular character set. Also unlike the standard
// library function, this takes and returns a char, not an int, so
// don't call it on %EOF but no need to worry about casting to #guchar
// before passing a possibly non-ASCII character in.
// 
// If @c is not an ASCII upper case letter,
// @c is returned unchanged.
// RETURNS: the result of converting @c to lower case.
// <c>: any character.
static char ascii_tolower(char c) {
   return g_ascii_tolower(c);
}


// Convert a character to ASCII upper case.
// 
// Unlike the standard C library toupper() function, this only
// recognizes standard ASCII letters and ignores the locale, returning
// all non-ASCII characters unchanged, even if they are upper case
// letters in a particular character set. Also unlike the standard
// library function, this takes and returns a char, not an int, so
// don't call it on %EOF but no need to worry about casting to #guchar
// before passing a possibly non-ASCII character in.
// 
// If @c is not an ASCII lower case letter,
// @c is returned unchanged.
// RETURNS: the result of converting @c to upper case.
// <c>: any character.
static char ascii_toupper(char c) {
   return g_ascii_toupper(c);
}


// Determines the numeric value of a character as a hexidecimal
// digit. Differs from g_unichar_xdigit_value() because it takes
// a char, so there's no worry about sign extension if characters
// are signed.
// 
// g_ascii_isxdigit()), its numeric value. Otherwise, -1.
// RETURNS: If @c is a hex digit (according to
// <c>: an ASCII character.
static int ascii_xdigit_value(char c) {
   return g_ascii_xdigit_value(c);
}

static void assert_warning(char* log_domain, char* file, int line, char* pretty_function, char* expression) {
   g_assert_warning(log_domain, file, line, pretty_function, expression);
}

static void assertion_message(char* domain, char* file, int line, char* func, char* message) {
   g_assertion_message(domain, file, line, func, message);
}

// Unintrospectable function: assertion_message_cmpnum() / g_assertion_message_cmpnum()
static void assertion_message_cmpnum(char* domain, char* file, int line, char* func, char* expr, real arg1, char* cmp, real arg2, char numtype) {
   g_assertion_message_cmpnum(domain, file, line, func, expr, arg1, cmp, arg2, numtype);
}

static void assertion_message_cmpstr(char* domain, char* file, int line, char* func, char* expr, char* arg1, char* cmp, char* arg2) {
   g_assertion_message_cmpstr(domain, file, line, func, expr, arg1, cmp, arg2);
}

static void assertion_message_error(char* domain, char* file, int line, char* func, char* expr, Error* error, Quark error_domain, int error_code) {
   g_assertion_message_error(domain, file, line, func, expr, error, error_domain, error_code);
}

static void assertion_message_expr(char* domain, char* file, int line, char* func, char* expr) {
   g_assertion_message_expr(domain, file, line, func, expr);
}


// 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>: the function to call on normal program termination.
static void atexit(VoidFunc func) {
   g_atexit(func);
}


// Atomically adds @val to the value of @atomic.
// 
// Think of this operation as an atomic version of
// <literal>{ tmp = *atomic; *@atomic += @val; return tmp; }</literal>
// 
// 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).
// RETURNS: the value of @atomic before the add, signed
// <atomic>: a pointer to a #gint or #guint
// <val>: the value to add
static int atomic_int_add(int* atomic, int val) {
   return g_atomic_int_add(atomic, 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
// <literal>{ tmp = *atomic; *@atomic &= @val; return tmp; }</literal>
// RETURNS: the value of @atomic before the operation, unsigned
// <atomic>: a pointer to a #gint or #guint
// <val>: the value to 'and'
static uint atomic_int_and(uint* atomic, uint val) {
   return g_atomic_int_and(atomic, val);
}


// 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
// <literal>{ if (*@atomic == @oldval) { *@atomic = @newval; return TRUE; } else return FALSE; }</literal>
// 
// This call acts as a full compiler and hardware memory barrier.
// RETURNS: %TRUE if the exchange took place
// <atomic>: a pointer to a #gint or #guint
// <oldval>: the value to compare with
// <newval>: the value to conditionally replace with
static int atomic_int_compare_and_exchange(int* atomic, int oldval, int newval) {
   return g_atomic_int_compare_and_exchange(atomic, oldval, newval);
}


// Decrements the value of @atomic by 1.
// 
// Think of this operation as an atomic version of
// <literal>{ *@atomic -= 1; return (*@atomic == 0); }</literal>
// 
// This call acts as a full compiler and hardware memory barrier.
// RETURNS: %TRUE if the resultant value is zero
// <atomic>: a pointer to a #gint or #guint
static int atomic_int_dec_and_test(int* atomic) {
   return g_atomic_int_dec_and_test(atomic);
}


// 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.
// RETURNS: the value of @atomic before the add, signed
// <atomic>: a pointer to a #gint
// <val>: the value to add
static int atomic_int_exchange_and_add(int* atomic, int val) {
   return g_atomic_int_exchange_and_add(atomic, val);
}


// Gets the current value of @atomic.
// 
// This call acts as a full compiler and hardware
// memory barrier (before the get).
// RETURNS: the value of the integer
// <atomic>: a pointer to a #gint or #guint
static int atomic_int_get(int* atomic) {
   return g_atomic_int_get(atomic);
}


// Increments the value of @atomic by 1.
// 
// Think of this operation as an atomic version of
// <literal>{ *@atomic += 1; }</literal>
// 
// This call acts as a full compiler and hardware memory barrier.
// <atomic>: a pointer to a #gint or #guint
static void atomic_int_inc(int* atomic) {
   g_atomic_int_inc(atomic);
}


// 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
// <literal>{ tmp = *atomic; *@atomic |= @val; return tmp; }</literal>
// 
// This call acts as a full compiler and hardware memory barrier.
// RETURNS: the value of @atomic before the operation, unsigned
// <atomic>: a pointer to a #gint or #guint
// <val>: the value to 'or'
static uint atomic_int_or(uint* atomic, uint val) {
   return g_atomic_int_or(atomic, val);
}


// Sets the value of @atomic to @newval.
// 
// This call acts as a full compiler and hardware
// memory barrier (after the set).
// <atomic>: a pointer to a #gint or #guint
// <newval>: a new value to store
static void atomic_int_set(int* atomic, int newval) {
   g_atomic_int_set(atomic, newval);
}


// 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
// <literal>{ tmp = *atomic; *@atomic ^= @val; return tmp; }</literal>
// 
// This call acts as a full compiler and hardware memory barrier.
// RETURNS: the value of @atomic before the operation, unsigned
// <atomic>: a pointer to a #gint or #guint
// <val>: the value to 'xor'
static uint atomic_int_xor(uint* atomic, uint val) {
   return g_atomic_int_xor(atomic, val);
}


// Atomically adds @val to the value of @atomic.
// 
// Think of this operation as an atomic version of
// <literal>{ tmp = *atomic; *@atomic += @val; return tmp; }</literal>
// 
// This call acts as a full compiler and hardware memory barrier.
// RETURNS: the value of @atomic before the add, signed
// <atomic>: a pointer to a #gpointer-sized value
// <val>: the value to add
static ssize_t atomic_pointer_add(void* atomic, ssize_t val) {
   return g_atomic_pointer_add(atomic, 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
// <literal>{ tmp = *atomic; *@atomic &= @val; return tmp; }</literal>
// 
// This call acts as a full compiler and hardware memory barrier.
// RETURNS: the value of @atomic before the operation, unsigned
// <atomic>: a pointer to a #gpointer-sized value
// <val>: the value to 'and'
static size_t atomic_pointer_and(void* atomic, size_t val) {
   return g_atomic_pointer_and(atomic, val);
}


// 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
// <literal>{ if (*@atomic == @oldval) { *@atomic = @newval; return TRUE; } else return FALSE; }</literal>
// 
// This call acts as a full compiler and hardware memory barrier.
// RETURNS: %TRUE if the exchange took place
// <atomic>: a pointer to a #gpointer-sized value
// <oldval>: the value to compare with
// <newval>: the value to conditionally replace with
static int atomic_pointer_compare_and_exchange(void* atomic, void* oldval, void* newval) {
   return g_atomic_pointer_compare_and_exchange(atomic, oldval, newval);
}


// Unintrospectable function: atomic_pointer_get() / g_atomic_pointer_get()
// Gets the current value of @atomic.
// 
// This call acts as a full compiler and hardware
// memory barrier (before the get).
// RETURNS: the value of the pointer
// <atomic>: a pointer to a #gpointer-sized value
static void* atomic_pointer_get(void* atomic) {
   return g_atomic_pointer_get(atomic);
}


// 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
// <literal>{ tmp = *atomic; *@atomic |= @val; return tmp; }</literal>
// 
// This call acts as a full compiler and hardware memory barrier.
// RETURNS: the value of @atomic before the operation, unsigned
// <atomic>: a pointer to a #gpointer-sized value
// <val>: the value to 'or'
static size_t atomic_pointer_or(void* atomic, size_t val) {
   return g_atomic_pointer_or(atomic, val);
}


// Sets the value of @atomic to @newval.
// 
// This call acts as a full compiler and hardware
// memory barrier (after the set).
// <atomic>: a pointer to a #gpointer-sized value
// <newval>: a new value to store
static void atomic_pointer_set(void* atomic, void* newval) {
   g_atomic_pointer_set(atomic, newval);
}


// 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
// <literal>{ tmp = *atomic; *@atomic ^= @val; return tmp; }</literal>
// 
// This call acts as a full compiler and hardware memory barrier.
// RETURNS: the value of @atomic before the operation, unsigned
// <atomic>: a pointer to a #gpointer-sized value
// <val>: the value to 'xor'
static size_t atomic_pointer_xor(void* atomic, size_t val) {
   return g_atomic_pointer_xor(atomic, val);
}


// Decode a sequence of Base-64 encoded text into binary data
// 
// newly allocated buffer containing the binary data
// that @text represents. The returned buffer must
// be freed with g_free().
// <text>: zero-terminated string with base64 text to decode
// <out_len>: The length of the decoded data is written here
static ubyte* /*new*/ base64_decode(char* text, /*out*/ size_t* out_len) {
   return g_base64_decode(text, out_len);
}


// Decode a sequence of Base-64 encoded text into binary data
// by overwriting the input data.
// 
// is the same as the input @text.
// RETURNS: The binary data that @text responds. This pointer
// <text>: zero-terminated string with base64 text to decode
// <out_len>: The length of the decoded data is written here
static ubyte* base64_decode_inplace(/*inout*/ ubyte* text, /*inout*/ size_t* out_len) {
   return g_base64_decode_inplace(text, out_len);
}


// 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).
// RETURNS: The number of bytes of output that was written
// <in>: binary input data
// <len>: max length of @in data to decode
// <out>: output buffer
// <state>: Saved state between steps, initialize to 0
// <save>: Saved state between steps, initialize to 0
static size_t base64_decode_step(ubyte* in_, size_t len, /*out*/ ubyte* out_, /*inout*/ int* state, /*inout*/ uint* save) {
   return g_base64_decode_step(in_, len, out_, state, save);
}


// Encode a sequence of binary data into its Base-64 stringified
// representation.
// 
// encoded string representing @data. The returned string must
// be freed with g_free().
// RETURNS: a newly allocated, zero-terminated Base-64
// <data>: the binary data to encode
// <len>: the length of @data
static char* /*new*/ base64_encode(ubyte* data, size_t len) {
   return g_base64_encode(data, len);
}


// 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.
// RETURNS: The number of bytes of output that was written
// <break_lines>: whether to break long lines
// <out>: pointer to destination buffer
// <state>: Saved state from g_base64_encode_step()
// <save>: Saved state from g_base64_encode_step()
static size_t base64_encode_close(int break_lines, /*out*/ ubyte* out_, /*inout*/ int* state, /*inout*/ int* save) {
   return g_base64_encode_close(break_lines, out_, state, 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) / 72 + 1 bytes of extra space.
// 
// @break_lines is typically used when putting base64-encoded data in emails.
// It breaks the lines at 72 columns instead of putting all of the text on
// the same line. This avoids problems with long lines in the email system.
// RETURNS: The number of bytes of output that was written
// <in>: the binary data to encode
// <len>: the length of @in
// <break_lines>: whether to break long lines
// <out>: pointer to destination buffer
// <state>: Saved state between steps, initialize to 0
// <save>: Saved state between steps, initialize to 0
static size_t base64_encode_step(ubyte* in_, size_t len, int break_lines, /*out*/ ubyte* out_, /*inout*/ int* state, /*inout*/ int* save) {
   return g_base64_encode_step(in_, len, break_lines, out_, state, save);
}


// Gets the name of the file without any leading directory components.
// It returns a pointer into the given file name string.
// 
// 
// Deprecated:2.2: Use g_path_get_basename() instead, but notice that
// g_path_get_basename() allocates new memory for the returned string, unlike
// this function which returns a pointer into the argument.
// RETURNS: the name of the file without any leading directory components.
// <file_name>: the name of the file.
static char* basename(char* file_name) {
   return g_basename(file_name);
}


// 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.
// <address>: a pointer to an integer
// <lock_bit>: a bit value between 0 and 31
static void bit_lock(int* address, int lock_bit) {
   g_bit_lock(address, lock_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.
// RETURNS: the index of the first bit set which is higher than @nth_bit
// <mask>: a #gulong containing flags
// <nth_bit>: the index of the bit to start the search from
static int bit_nth_lsf(c_ulong mask, int nth_bit) {
   return g_bit_nth_lsf(mask, 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.
// RETURNS: the index of the first bit set which is lower than @nth_bit
// <mask>: a #gulong containing flags
// <nth_bit>: the index of the bit to start the search from
static int bit_nth_msf(c_ulong mask, int nth_bit) {
   return g_bit_nth_msf(mask, nth_bit);
}


// Gets the number of bits used to hold @number,
// e.g. if @number is 4, 3 bits are needed.
// RETURNS: the number of bits used to hold @number
// <number>: a #guint
static uint bit_storage(c_ulong number) {
   return g_bit_storage(number);
}


// 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.
// RETURNS: %TRUE if the lock was acquired
// <address>: a pointer to an integer
// <lock_bit>: a bit value between 0 and 31
static int bit_trylock(int* address, int lock_bit) {
   return g_bit_trylock(address, 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
// @address must be atomic in order for this function to work
// reliably.
// <address>: a pointer to an integer
// <lock_bit>: a bit value between 0 and 31
static void bit_unlock(int* address, int lock_bit) {
   g_bit_unlock(address, lock_bit);
}


// Calls g_mem_chunk_clean() on all #GMemChunk objects.
// 
// Deprecated:2.10: Use the <link linkend="glib-Memory-Slices">slice
// allocator</link> instead
static void blow_chunks() {
   g_blow_chunks();
}

static Quark bookmark_file_error_quark() {
   return g_bookmark_file_error_quark();
}


// Unintrospectable function: build_filename() / g_build_filename()
// Creates a filename from a series of elements using the correct
// separator for filenames.
// 
// On Unix, this function behaves identically to <literal>g_build_path
// (G_DIR_SEPARATOR_S, first_element, ....)</literal>.
// 
// On Windows, it takes into account that either the backslash
// (<literal>\</literal> or slash (<literal>/</literal>) 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.
// RETURNS: a newly-allocated string that must be freed with g_free().
// <first_element>: the first element in the path
alias g_build_filename build_filename; // Variadic


// 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.
// RETURNS: a newly-allocated string that must be freed with g_free().
// <args>: %NULL-terminated array of strings containing the path elements.
static char* /*new*/ build_filenamev(char** args) {
   return g_build_filenamev(args);
}


// Unintrospectable function: build_path() / g_build_path()
// 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 <literal>ABA</literal>, <literal>ABABA</literal>
// has 1 trailing copy.)
// 
// However, if there is only a single non-empty element, and there
// are no characters in that element not part of the leading or
// trailing separators, then the result is exactly the original value
// of that element.
// 
// Other than for determination of the number of leading and trailing
// copies of the separator, elements consisting only of copies
// of the separator are ignored.
// RETURNS: a newly-allocated string that must be freed with g_free().
// <separator>: a string used to separator the elements of the path.
// <first_element>: the first element in the path
alias g_build_path build_path; // Variadic


// Behaves exactly like g_build_path(), but takes the path elements
// as a string array, instead of varargs. This function is mainly
// meant for language bindings.
// RETURNS: a newly-allocated string that must be freed with g_free().
// <separator>: a string used to separator the elements of the path.
// <args>: %NULL-terminated array of strings containing the path elements.
static char* /*new*/ build_pathv(char* separator, char** args) {
   return g_build_pathv(separator, args);
}


// 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, the #GByteArray wrapper is preserved but
// the size of @array will be set to zero.
// <array>: a #GByteArray.
// <free_segment>: if %TRUE the actual byte data is freed as well.
static ubyte* byte_array_free(ByteArray* array, int free_segment) {
   return g_byte_array_free(array, free_segment);
}


// 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 MT-safe and may be called from any
// thread.
// <array>: A #GByteArray.
static void byte_array_unref(ByteArray* array) {
   g_byte_array_unref(array);
}


// 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().
// RETURNS: 0 on success, -1 if an error occurred.
// <path>: a pathname in the GLib file name encoding (UTF-8 on Windows)
static int chdir(char* path) {
   return g_chdir(path);
}


// 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.)
// 
// given version, or a string describing the version mismatch.
// The returned string is owned by GLib and must not be modified
// or freed.
// RETURNS: %NULL if the GLib library is compatible with the
// <required_major>: the required major version.
// <required_minor>: the required minor version.
// <required_micro>: the required micro version.
static char* check_version(uint required_major, uint required_minor, uint required_micro) {
   return glib_check_version(required_major, required_minor, required_micro);
}


// Gets the length in bytes of digests of type @checksum_type
// 
// not supported.
// RETURNS: the checksum length, or -1 if @checksum_type is
// <checksum_type>: a #GChecksumType
static ssize_t checksum_type_get_length(ChecksumType checksum_type) {
   return g_checksum_type_get_length(checksum_type);
}


// Unintrospectable function: child_watch_add() / g_child_watch_add()
// Sets a function to be called when the child indicated by @pid
// exits, at a default priority, #G_PRIORITY_DEFAULT.
// 
// If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes()
// you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to
// the spawn function for the child watching to work.
// 
// Note that on platforms where #GPid must be explicitly closed
// (see g_spawn_close_pid()) @pid must not be closed while the
// source is still active. Typically, you will want to call
// g_spawn_close_pid() in the callback function for the source.
// 
// GLib supports only a single callback per process id.
// 
// This internally creates a main loop source using
// g_child_watch_source_new() and attaches it to the main loop context
// using g_source_attach(). You can do these steps manually if you
// need greater control.
// RETURNS: the ID (greater than 0) of the event source.
// <pid>: process id to watch. On POSIX the pid of a child process. On Windows a handle for a process (which doesn't have to be a child).
// <function>: function to call
// <data>: data to pass to @function
static uint child_watch_add(Pid pid, ChildWatchFunc function_, void* data) {
   return g_child_watch_add(pid, function_, data);
}


// Sets a function to be called when the child indicated by @pid
// exits, at the priority @priority.
// 
// If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes()
// you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to
// the spawn function for the child watching to work.
// 
// Note that on platforms where #GPid must be explicitly closed
// (see g_spawn_close_pid()) @pid must not be closed while the
// source is still active. Typically, you will want to call
// g_spawn_close_pid() in the callback function for the source.
// 
// GLib supports only a single callback per process id.
// 
// This internally creates a main loop source using
// g_child_watch_source_new() and attaches it to the main loop context
// using g_source_attach(). You can do these steps manually if you
// need greater control.
// RETURNS: the ID (greater than 0) of the event source.
// <priority>: the priority of the idle source. Typically this will be in the range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
// <pid>: process to watch. On POSIX the pid of a child process. On Windows a handle for a process (which doesn't have to be a child).
// <function>: function to call
// <data>: data to pass to @function
// <notify>: function to call when the idle is removed, or %NULL
static uint child_watch_add_full(int priority, Pid pid, ChildWatchFunc function_, void* data, DestroyNotify notify) {
   return g_child_watch_add_full(priority, pid, function_, data, notify);
}


// Creates a new child_watch source.
// 
// The source will not initially be associated with any #GMainContext
// and must be added to one with g_source_attach() before it will be
// executed.
// 
// Note that child watch sources can only be used in conjunction with
// <literal>g_spawn...</literal> when the %G_SPAWN_DO_NOT_REAP_CHILD
// flag is used.
// 
// Note that on platforms where #GPid must be explicitly closed
// (see g_spawn_close_pid()) @pid must not be closed while the
// source is still active. Typically, you will want to call
// g_spawn_close_pid() in the callback function for the source.
// 
// Note further that using g_child_watch_source_new() is not
// compatible with calling <literal>waitpid(-1)</literal> in
// the application. Calling waitpid() for individual pids will
// still work fine.
// RETURNS: the newly-created child watch source
// <pid>: process to watch. On POSIX the pid of a child process. On Windows a handle for a process (which doesn't have to be a child).
static Source* /*new*/ child_watch_source_new(Pid pid) {
   return g_child_watch_source_new(pid);
}


// If @err is %NULL, does nothing. If @err is non-%NULL,
// calls g_error_free() on *@err and sets *@err to %NULL.
static void clear_error(GLib2.Error** error=null) {
   g_clear_error(error);
}


// 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.
// 
// The returned string should be freed with g_free() when done using it.
// RETURNS: the digest of the binary data as a string in hexadecimal.
// <checksum_type>: a #GChecksumType
// <data>: binary blob to compute the digest of
// <length>: length of @data
static char* /*new*/ compute_checksum_for_data(ChecksumType checksum_type, ubyte* data, size_t length) {
   return g_compute_checksum_for_data(checksum_type, data, length);
}


// Computes the checksum of a string.
// 
// The hexadecimal string returned will be in lower case.
// 
// should be freed with g_free() when done using it.
// RETURNS: the checksum as a hexadecimal string. The returned string
// <checksum_type>: a #GChecksumType
// <str>: the string to compute the checksum of
// <length>: the length of the string, or -1 if the string is null-terminated.
static char* /*new*/ compute_checksum_for_string(ChecksumType checksum_type, char* str, ssize_t length) {
   return g_compute_checksum_for_string(checksum_type, str, length);
}


// 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.
// 
// The returned string should be freed with g_free() when done using it.
// RETURNS: the HMAC of the binary data as a string in hexadecimal.
// <digest_type>: a #GChecksumType to use for the HMAC
// <key>: the key to use in the HMAC
// <key_len>: the length of the key
// <data>: binary blob to compute the HMAC of
// <length>: length of @data
static char* /*new*/ compute_hmac_for_data(ChecksumType digest_type, ubyte* key, size_t key_len, ubyte* data, size_t length) {
   return g_compute_hmac_for_data(digest_type, key, key_len, data, length);
}


// Computes the HMAC for a string.
// 
// The hexadecimal string returned will be in lower case.
// 
// The returned string should be freed with g_free()
// when done using it.
// RETURNS: the HMAC as a hexadecimal string.
// <digest_type>: a #GChecksumType to use for the HMAC
// <key>: the key to use in the HMAC
// <key_len>: the length of the key
// <str>: the string to compute the HMAC for
// <length>: the length of the string, or -1 if the string is nul-terminated
static char* /*new*/ compute_hmac_for_string(ChecksumType digest_type, ubyte* key, size_t key_len, char* str, ssize_t length) {
   return g_compute_hmac_for_string(digest_type, key, key_len, str, length);
}


// Converts a string from one character set to another.
// 
// Note that you should use g_iconv() for streaming
// conversions<footnoteref linkend="streaming-state"/>.
// 
// nul-terminated string, which must be freed with
// g_free(). Otherwise %NULL and @error will be set.
// RETURNS: If the conversion was successful, a newly allocated
// <str>: the string to convert
// <len>: the length of the string, or -1 if the string is nul-terminated<footnote id="nul-unsafe">
// <to_codeset>: name of character set into which to convert @str
// <from_codeset>: character set of @str.
// <bytes_read>: location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence.
// <bytes_written>: the number of bytes stored in the output buffer (not including the terminating nul).
static char* /*new*/ convert(char* str, ssize_t len, char* to_codeset, char* from_codeset, /*out*/ size_t* bytes_read, /*out*/ size_t* bytes_written, GLib2.Error** error=null) {
   return g_convert(str, len, to_codeset, from_codeset, bytes_read, bytes_written, error);
}

static Quark convert_error_quark() {
   return g_convert_error_quark();
}


// 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<footnoteref linkend="streaming-state"/>.
// 
// nul-terminated string, which must be freed with
// g_free(). Otherwise %NULL and @error will be set.
// RETURNS: If the conversion was successful, a newly allocated
// <str>: the string to convert
// <len>: the length of the string, or -1 if the string is nul-terminated<footnoteref linkend="nul-unsafe"/>.
// <to_codeset>: name of character set into which to convert @str
// <from_codeset>: character set of @str.
// <fallback>: UTF-8 string to use in place of character not present in the target encoding. (The string must be representable in the target encoding).
// <bytes_read>: location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input.
// <bytes_written>: the number of bytes stored in the output buffer (not including the terminating nul).
static char* /*new*/ convert_with_fallback(char* str, ssize_t len, char* to_codeset, char* from_codeset, char* fallback, size_t* bytes_read, size_t* bytes_written, GLib2.Error** error=null) {
   return g_convert_with_fallback(str, len, to_codeset, from_codeset, fallback, bytes_read, bytes_written, error);
}


// Converts a string from one character set to another.
// 
// Note that you should use g_iconv() for streaming
// conversions<footnote id="streaming-state">
// <para>
// Despite the fact that @byes_read can return information about partial
// characters, the <literal>g_convert_...</literal> functions
// are not generally suitable for streaming. If the underlying converter
// being used 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.)
// </para>
// </footnote>.
// 
// nul-terminated string, which must be freed with
// g_free(). Otherwise %NULL and @error will be set.
// RETURNS: If the conversion was successful, a newly allocated
// <str>: the string to convert
// <len>: the length of the string, or -1 if the string is nul-terminated<footnoteref linkend="nul-unsafe"/>.
// <converter>: conversion descriptor from g_iconv_open()
// <bytes_read>: location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence.
// <bytes_written>: the number of bytes stored in the output buffer (not including the terminating nul).
static char* /*new*/ convert_with_iconv(char* str, ssize_t len, IConv converter, size_t* bytes_read, size_t* bytes_written, GLib2.Error** error=null) {
   return g_convert_with_iconv(str, len, converter, bytes_read, bytes_written, error);
}


// Frees all the data elements of the datalist.
// The data elements' destroy functions are called
// if they have been set.
// <datalist>: a datalist.
static void datalist_clear(Data** datalist) {
   g_datalist_clear(datalist);
}


// Unintrospectable function: datalist_foreach() / g_datalist_foreach()
// 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.
// <datalist>: a datalist.
// <func>: the function to call for each data element.
// <user_data>: user data to pass to the function.
static void datalist_foreach(Data** datalist, DataForeachFunc func, void* user_data) {
   g_datalist_foreach(datalist, func, user_data);
}


// Unintrospectable function: datalist_get_data() / g_datalist_get_data()
// Gets a data element, using its string identifer. This is slower than
// g_datalist_id_get_data() because it compares strings.
// <datalist>: a datalist.
// <key>: the string identifying a data element.
static void* datalist_get_data(Data** datalist, char* key) {
   return g_datalist_get_data(datalist, key);
}


// Gets flags values packed in together with the datalist.
// See g_datalist_set_flags().
// RETURNS: the flags of the datalist
// <datalist>: pointer to the location that holds a list
static uint datalist_get_flags(Data** datalist) {
   return g_datalist_get_flags(datalist);
}


// Unintrospectable function: datalist_id_get_data() / g_datalist_id_get_data()
// Retrieves the data element corresponding to @key_id.
// <datalist>: a datalist.
// <key_id>: the #GQuark identifying a data element.
static void* datalist_id_get_data(Data** datalist, Quark key_id) {
   return g_datalist_id_get_data(datalist, key_id);
}


// Unintrospectable function: datalist_id_remove_no_notify() / g_datalist_id_remove_no_notify()
// Removes an element, without calling its destroy notification
// function.
// <datalist>: a datalist.
// <key_id>: the #GQuark identifying a data element.
static void* datalist_id_remove_no_notify(Data** datalist, Quark key_id) {
   return g_datalist_id_remove_no_notify(datalist, key_id);
}


// Sets the data corresponding to the given #GQuark id, and the
// function to be called when the element is removed from the datalist.
// Any previous data with the same key is removed, and its destroy
// function is called.
// <datalist>: a datalist.
// <key_id>: the #GQuark to identify the data element.
// <data>: the data element or %NULL to remove any previous element corresponding to @key_id.
// <destroy_func>: the function to call when the data element is removed. This function will be called with the data element and can be used to free any memory allocated for it. If @data is %NULL, then @destroy_func must also be %NULL.
static void datalist_id_set_data_full(Data** datalist, Quark key_id, void* data, DestroyNotify destroy_func) {
   g_datalist_id_set_data_full(datalist, key_id, data, destroy_func);
}


// Resets the datalist to %NULL. It does not free any memory or call
// any destroy functions.
// <datalist>: a pointer to a pointer to a datalist.
static void datalist_init(Data** datalist) {
   g_datalist_init(datalist);
}


// 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>: pointer to the location that holds a list
// <flags>: 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.
static void datalist_set_flags(Data** datalist, uint flags) {
   g_datalist_set_flags(datalist, flags);
}


// Turns off flag values for a data list. See g_datalist_unset_flags()
// <datalist>: pointer to the location that holds a list
// <flags>: 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.
static void datalist_unset_flags(Data** datalist, uint flags) {
   g_datalist_unset_flags(datalist, flags);
}


// Destroys the dataset, freeing all memory allocated, and calling any
// destroy functions set for data elements.
// <dataset_location>: the location identifying the dataset.
static void dataset_destroy(const(void)* dataset_location) {
   g_dataset_destroy(dataset_location);
}


// Unintrospectable function: dataset_foreach() / g_dataset_foreach()
// 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 @datalist can be protected from any modifications during
// invocation of this function, it should not be called.
// <dataset_location>: the location identifying the dataset.
// <func>: the function to call for each data element.
// <user_data>: user data to pass to the function.
static void dataset_foreach(const(void)* dataset_location, DataForeachFunc func, void* user_data) {
   g_dataset_foreach(dataset_location, func, user_data);
}


// Unintrospectable function: dataset_id_get_data() / g_dataset_id_get_data()
// Gets the data element corresponding to a #GQuark.
// <dataset_location>: the location identifying the dataset.
// <key_id>: the #GQuark id to identify the data element.
static void* dataset_id_get_data(const(void)* dataset_location, Quark key_id) {
   return g_dataset_id_get_data(dataset_location, key_id);
}


// Unintrospectable function: dataset_id_remove_no_notify() / g_dataset_id_remove_no_notify()
// Removes an element, without calling its destroy notification
// function.
// <dataset_location>: the location identifying the dataset.
// <key_id>: the #GQuark ID identifying the data element.
static void* dataset_id_remove_no_notify(const(void)* dataset_location, Quark key_id) {
   return g_dataset_id_remove_no_notify(dataset_location, key_id);
}


// Sets the data element associated with the given #GQuark id, and also
// the function to call when the data element is destroyed. Any
// previous data with the same key is removed, and its destroy function
// is called.
// <dataset_location>: the location identifying the dataset.
// <key_id>: the #GQuark id to identify the data element.
// <data>: the data element.
// <destroy_func>: the function to call when the data element is removed. This function will be called with the data element and can be used to free any memory allocated for it.
static void dataset_id_set_data_full(const(void)* dataset_location, Quark key_id, void* data, DestroyNotify destroy_func) {
   g_dataset_id_set_data_full(dataset_location, key_id, data, destroy_func);
}

static ubyte date_get_days_in_month(DateMonth month, DateYear year) {
   return g_date_get_days_in_month(month, year);
}

static ubyte date_get_monday_weeks_in_year(DateYear year) {
   return g_date_get_monday_weeks_in_year(year);
}

static ubyte date_get_sunday_weeks_in_year(DateYear year) {
   return g_date_get_sunday_weeks_in_year(year);
}

static int date_is_leap_year(DateYear year) {
   return g_date_is_leap_year(year);
}

static size_t date_strftime(char* s, size_t slen, char* format, Date* date) {
   return g_date_strftime(s, slen, format, date);
}


// A comparison function for #GDateTimes that is suitable
// as a #GCompareFunc. Both #GDateTimes must be non-%NULL.
// 
// than @dt2.
// RETURNS: -1, 0 or 1 if @dt1 is less than, equal to or greater
// <dt1>: first #GDateTime to compare
// <dt2>: second #GDateTime to compare
static int date_time_compare(const(void)* dt1, const(void)* dt2) {
   return g_date_time_compare(dt1, dt2);
}


// Checks to see if @dt1 and @dt2 are equal.
// 
// Equal here means that they represent the same moment after converting
// them to the same time zone.
// RETURNS: %TRUE if @dt1 and @dt2 are equal
// <dt1>: a #GDateTime
// <dt2>: a #GDateTime
static int date_time_equal(const(void)* dt1, const(void)* dt2) {
   return g_date_time_equal(dt1, dt2);
}


// Hashes @datetime into a #guint, suitable for use within #GHashTable.
// RETURNS: a #guint containing the hash
// <datetime>: a #GDateTime
static uint date_time_hash(const(void)* datetime) {
   return g_date_time_hash(datetime);
}

static int date_valid_day(DateDay day) {
   return g_date_valid_day(day);
}

static int date_valid_dmy(DateDay day, DateMonth month, DateYear year) {
   return g_date_valid_dmy(day, month, year);
}

static int date_valid_julian(uint julian_date) {
   return g_date_valid_julian(julian_date);
}

static int date_valid_month(DateMonth month) {
   return g_date_valid_month(month);
}

static int date_valid_weekday(DateWeekday weekday) {
   return g_date_valid_weekday(weekday);
}

static int date_valid_year(DateYear year) {
   return g_date_valid_year(year);
}


// 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.
// RETURNS: the translated string for the given locale category
// <domain>: the translation domain to use, or %NULL to use the domain set with textdomain()
// <msgid>: message to translate
// <category>: a locale category
static char* dcgettext(char* domain, char* msgid, int category) {
   return g_dcgettext(domain, msgid, category);
}


// 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:
// <itemizedlist>
// <listitem>@domain is not %NULL</listitem>
// <listitem>textdomain() has been called to set a default text domain</listitem>
// <listitem>there is no translations available for the default text domain
// and the current locale</listitem>
// <listitem>current locale is not "C" or any English locales (those
// starting with "en_")</listitem>
// </itemizedlist>
// 
// 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.
// RETURNS: The translated string
// <domain>: the translation domain to use, or %NULL to use the domain set with textdomain()
// <msgid>: message to translate
static char* dgettext(char* domain, char* msgid) {
   return g_dgettext(domain, msgid);
}


// 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.
// 
// 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.
// RETURNS: The actual name used. This string
// <tmpl>: Template for directory name, as in g_mkdtemp(), basename only, or %NULL for a default template
static char* /*new*/ dir_make_tmp(char* tmpl, GLib2.Error** error=null) {
   return g_dir_make_tmp(tmpl, error);
}


// 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 pointers as keys in a #GHashTable.
// RETURNS: %TRUE if the two keys match.
// <v1>: a key.
// <v2>: a key to compare with @v1.
static int direct_equal(const(void)* v1, const(void)* v2) {
   return g_direct_equal(v1, v2);
}


// Converts a gpointer to a hash value.
// It can be passed to g_hash_table_new() as the @hash_func parameter,
// when using pointers as keys in a #GHashTable.
// RETURNS: a hash value corresponding to the key.
// <v>: a #gpointer key
static uint direct_hash(const(void)* v) {
   return g_direct_hash(v);
}


// 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.
// RETURNS: The translated string
// <domain>: the translation domain to use, or %NULL to use the domain set with textdomain()
// <msgid>: message to translate
// <msgid_plural>: plural form of the message
// <n>: the quantity for which translation is needed
static char* dngettext(char* domain, char* msgid, char* msgid_plural, c_ulong n) {
   return g_dngettext(domain, msgid, msgid_plural, n);
}


// Compares the two #gdouble values being pointed to and returns
// %TRUE if they are equal.
// It can be passed to g_hash_table_new() as the @key_equal_func
// parameter, when using pointers to doubles as keys in a #GHashTable.
// RETURNS: %TRUE if the two keys match.
// <v1>: a pointer to a #gdouble key.
// <v2>: a pointer to a #gdouble key to compare with @v1.
static int double_equal(const(void)* v1, const(void)* v2) {
   return g_double_equal(v1, v2);
}


// Converts a pointer to a #gdouble to a hash value.
// It can be passed to g_hash_table_new() as the @hash_func parameter,
// when using pointers to doubles as keys in a #GHashTable.
// RETURNS: a hash value corresponding to the key.
// <v>: a pointer to a #gdouble key
static uint double_hash(const(void)* v) {
   return g_double_hash(v);
}


// 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.
// RETURNS: The translated string
// <domain>: the translation domain to use, or %NULL to use the domain set with textdomain()
// <msgctxtid>: a combined message context and message id, separated by a \004 character
// <msgidoffset>: the offset of the message id in @msgctxid
static char* dpgettext(char* domain, char* msgctxtid, size_t msgidoffset) {
   return g_dpgettext(domain, msgctxtid, 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.
// 
// 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.
// RETURNS: The translated string
// <domain>: the translation domain to use, or %NULL to use the domain set with textdomain()
// <context>: the message context
// <msgid>: the message
static char* dpgettext2(char* domain, char* context, char* msgid) {
   return g_dpgettext2(domain, context, msgid);
}



// Gets a #GFileError constant based on the passed-in @errno.
// For example, if you pass in %EEXIST this function returns
// #G_FILE_ERROR_EXIST. Unlike @errno values, you can portably
// assume that all #GFileError values will exist.
// 
// Normally a #GFileError value goes into a #GError returned
// from a function that manipulates files. So you would use
// g_file_error_from_errno() when constructing a #GError.
// RETURNS: #GFileError corresponding to the given @errno
// <err_no>: an "errno" value
static FileError file_error_from_errno(int err_no) {
   return g_file_error_from_errno(err_no);
}

static Quark file_error_quark() {
   return g_file_error_quark();
}


// 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.
// RETURNS: %TRUE on success, %FALSE if an error occurred
// <filename>: name of a file to read contents from, in the GLib file name encoding
// <contents>: location to store an allocated string, use g_free() to free the returned string
// <length>: location to store length in bytes of the contents, or %NULL
static int file_get_contents(char* filename, /*out*/ ubyte** contents, /*out*/ size_t* length, GLib2.Error** error=null) {
   return g_file_get_contents(filename, contents, length, error);
}


// 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.
// 
// 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.
// RETURNS: A file handle (as from open()) to the file opened for
// <tmpl>: Template for file name, as in g_mkstemp(), basename only, or %NULL for a default template
// <name_used>: location to store actual name used, or %NULL
static int file_open_tmp(char* tmpl, /*out*/ char** name_used, GLib2.Error** error=null) {
   return g_file_open_tmp(tmpl, name_used, error);
}


// 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.
// 
// or %NULL if an error occurred.
// RETURNS: A newly-allocated string with the contents of the symbolic link,
// <filename>: the symbolic link
static char* /*new*/ file_read_link(char* filename, GLib2.Error** error=null) {
   return g_file_read_link(filename, error);
}


// Writes all of @contents to a file named @filename, with good error checking.
// If a file called @filename already exists it will be overwritten.
// 
// This write is atomic in the sense that it is first written to a temporary
// file which is then renamed to the final name. Notes:
// <itemizedlist>
// <listitem>
// 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.
// </listitem>
// <listitem>
// 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.
// </listitem>
// <listitem>
// 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.
// </listitem>
// </itemizedlist>
// 
// 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.
// RETURNS: %TRUE on success, %FALSE if an error occurred
// <filename>: name of a file to write @contents to, in the GLib file name encoding
// <contents>: string to write to the file
// <length>: length of @contents, or -1 if @contents is a nul-terminated string
static int file_set_contents(char* filename, ubyte* contents, ssize_t length, GLib2.Error** error=null) {
   return g_file_set_contents(filename, contents, length, error);
}


// Returns %TRUE if any of the tests in the bitfield @test are
// %TRUE. For example, <literal>(G_FILE_TEST_EXISTS |
// G_FILE_TEST_IS_DIR)</literal> will return %TRUE if the file exists;
// the check whether it's a directory doesn't matter since the existence
// test is %TRUE. With the current set of available tests, there's no point
// passing in more than one test at a time.
// 
// Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links,
// so for a symbolic link to a regular file g_file_test() will return
// %TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR.
// 
// Note, that for a dangling symbolic link g_file_test() will return
// %TRUE for %G_FILE_TEST_IS_SYMLINK and %FALSE for all other flags.
// 
// You should never use g_file_test() to test whether it is safe
// to perform an operation, because there is always the possibility
// of the condition changing before you actually perform the operation.
// For example, you might think you could use %G_FILE_TEST_IS_SYMLINK
// to know whether it is safe to write to a file without being
// tricked into writing into a different location. It doesn't work!
// |[
// /&ast; DON'T DO THIS &ast;/
// if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK))
// {
// fd = g_open (filename, O_WRONLY);
// /&ast; write to fd &ast;/
// }
// ]|
// 
// Another thing to note is that %G_FILE_TEST_EXISTS and
// %G_FILE_TEST_IS_EXECUTABLE are implemented using the access()
// system call. This usually doesn't matter, but if your program
// is setuid or setgid it means that these tests will give you
// the answer for the real user ID and group ID, rather than the
// effective user ID and group ID.
// 
// On Windows, there are no symlinks, so testing for
// %G_FILE_TEST_IS_SYMLINK will always return %FALSE. Testing for
// %G_FILE_TEST_IS_EXECUTABLE will just check that the file exists and
// its name indicates that it is executable, checking for well-known
// extensions and those listed in the %PATHEXT environment variable.
// RETURNS: whether a test was %TRUE
// <filename>: a filename to test in the GLib file name encoding
// <test>: bitfield of #GFileTest flags
static int file_test(char* filename, FileTest test) {
   return g_file_test(filename, test);
}


// 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.
// 
// a rendition of the basename of the filename in valid UTF-8
// RETURNS: a newly allocated string containing
// <filename>: an absolute pathname in the GLib file name encoding
static char* /*new*/ filename_display_basename(char* filename) {
   return g_filename_display_basename(filename);
}


// Converts a filename into a valid UTF-8 string. The conversion is
// not necessarily reversible, so you should keep the original around
// and use the return value of this function only for display purposes.
// Unlike g_filename_to_utf8(), the result is guaranteed to be non-%NULL
// even if the filename actually isn't in the GLib file name encoding.
// 
// If GLib cannot make sense of the encoding of @filename, as a last resort it
// replaces unknown characters with U+FFFD, the Unicode replacement character.
// You can search the result for the UTF-8 encoding of this character (which is
// "\357\277\275" in octal notation) to find out if @filename was in an invalid
// encoding.
// 
// If you know the whole pathname of the file you should use
// g_filename_display_basename(), since that allows location-based
// translation of filenames.
// 
// a rendition of the filename in valid UTF-8
// RETURNS: a newly allocated string containing
// <filename>: a pathname hopefully in the GLib file name encoding
static char* /*new*/ filename_display_name(char* filename) {
   return g_filename_display_name(filename);
}


// Converts an escaped ASCII-encoded URI to a local filename in the
// encoding used for filenames.
// 
// filename, or %NULL on an error.
// RETURNS: a newly-allocated string holding the resulting
// <uri>: a uri describing a filename (escaped, encoded in ASCII).
// <hostname>: Location to store hostname for the URI, or %NULL. If there is no hostname in the URI, %NULL will be stored in this location.
static char* /*new*/ filename_from_uri(char* uri, char** hostname, GLib2.Error** error=null) {
   return g_filename_from_uri(uri, hostname, error);
}


// 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
// <link linkend="setlocale">current locale</link>.
// RETURNS: The converted string, or %NULL on an error.
// <utf8string>: a UTF-8 encoded string.
// <len>: the length of the string, or -1 if the string is nul-terminated.
// <bytes_read>: location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence.
// <bytes_written>: the number of bytes stored in the output buffer (not including the terminating nul).
static char* /*new*/ filename_from_utf8(char* utf8string, ssize_t len, size_t* bytes_read, size_t* bytes_written, GLib2.Error** error=null) {
   return g_filename_from_utf8(utf8string, len, bytes_read, bytes_written, error);
}


// Converts an absolute filename to an escaped ASCII-encoded URI, with the path
// component following Section 3.3. of RFC 2396.
// 
// URI, or %NULL on an error.
// RETURNS: a newly-allocated string holding the resulting
// <filename>: an absolute filename specified in the GLib file name encoding, which is the on-disk file name bytes on Unix, and UTF-8 on Windows
// <hostname>: A UTF-8 encoded hostname, or %NULL for none.
static char* /*new*/ filename_to_uri(char* filename, char* hostname, GLib2.Error** error=null) {
   return g_filename_to_uri(filename, hostname, error);
}


// 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 <link linkend="setlocale">current locale</link>.
// RETURNS: The converted string, or %NULL on an error.
// <opsysstring>: a string in the encoding for filenames
// <len>: the length of the string, or -1 if the string is nul-terminated<footnoteref linkend="nul-unsafe"/>.
// <bytes_read>: location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence.
// <bytes_written>: the number of bytes stored in the output buffer (not including the terminating nul).
static char* /*new*/ filename_to_utf8(char* opsysstring, ssize_t len, size_t* bytes_read, size_t* bytes_written, GLib2.Error** error=null) {
   return g_filename_to_utf8(opsysstring, len, bytes_read, bytes_written, error);
}


// Locates the first executable named @program in the user's path, in the
// same way that execvp() would locate it. Returns an allocated string
// with the absolute path name, or %NULL if the program is not found in
// the path. If @program is already an absolute path, returns a copy of
// @program if @program exists and is executable, and %NULL otherwise.
// 
// On Windows, if @program does not have a file type suffix, tries
// with the suffixes .exe, .cmd, .bat and .com, and the suffixes in
// the <envar>PATHEXT</envar> 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 <envar>PATH</envar> environment
// variable. If the program is found, the return value contains the
// full name including the type suffix.
// RETURNS: absolute path, or %NULL
// <program>: a program name in the GLib file name encoding
static char* /*new*/ find_program_in_path(char* program) {
   return g_find_program_in_path(program);
}


// 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 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.
// 
// file size.
// RETURNS: a newly-allocated formatted string containing a human readable
// <size>: a size in bytes
static char* /*new*/ format_size(ulong size) {
   return g_format_size(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.
// 
// file size.
// 
// Deprecated:2.30: This function is broken due to its use of SI
// suffixes to denote IEC units.  Use g_format_size()
// instead.
// RETURNS: a newly-allocated formatted string containing a human readable
// <size>: a size in bytes.
static char* /*new*/ format_size_for_display(long size) {
   return g_format_size_for_display(size);
}


// Formats a size.
// 
// This function is similar to g_format_size() but allows for flags that
// modify the output.  See #GFormatSizeFlags.
// 
// readable file size.
// RETURNS: a newly-allocated formatted string containing a human
// <size>: a size in bytes
// <flags>: #GFormatSizeFlags to modify the output
static char* /*new*/ format_size_full(ulong size, FormatSizeFlags flags) {
   return g_format_size_full(size, flags);
}


// Unintrospectable function: fprintf() / g_fprintf()
// An implementation of the standard fprintf() function which supports
// positional parameters, as specified in the Single Unix Specification.
// RETURNS: the number of bytes printed.
// <file>: the stream to write to.
// <format>: a standard printf() format string, but notice <link linkend="string-precision">string precision pitfalls</link>.
alias g_fprintf fprintf; // Variadic


// Frees the memory pointed to by @mem.
// If @mem is %NULL it simply returns.
// <mem>: the memory to free
static void free(void* mem) {
   g_free(mem);
}


// Gets a human-readable name for the application, as set by
// g_set_application_name(). This name should be localized if
// possible, and is intended for display to the user.  Contrast with
// g_get_prgname(), which gets a non-localized name. If
// g_set_application_name() has not been called, returns the result of
// g_get_prgname() (which may be %NULL if g_set_prgname() has also not
// been called).
// RETURNS: human-readable application name. may return %NULL
static char* get_application_name() {
   return g_get_application_name();
}


// Obtains the character set for the <link linkend="setlocale">current
// locale</link>; 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.
// 
// 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.
// RETURNS: %TRUE if the returned charset is UTF-8
// <charset>: return location for character set name
static int get_charset(char** charset) {
   return g_get_charset(charset);
}


// 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.
// RETURNS: the current directory.
static char* /*new*/ get_current_dir() {
   return g_get_current_dir();
}


// Equivalent to the UNIX gettimeofday() function, but portable.
// 
// You may find g_get_real_time() to be more convenient.
// <result>: #GTimeVal structure in which to store current time.
static void get_current_time(TimeVal* result) {
   g_get_current_time(result);
}


// 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.
// RETURNS: the list of environment variables
static char** /*new*/ get_environ() {
   return g_get_environ();
}


// 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 <envar>G_FILENAME_ENCODING</envar> and
// <envar>G_BROKEN_FILENAMES</envar>. On Windows, the character set
// used in the GLib API is always UTF-8 and said environment variables
// have no effect.
// 
// <envar>G_FILENAME_ENCODING</envar> may be set to a comma-separated list
// of character set names. The special token "&commat;locale" is taken to
// mean the character set for the <link linkend="setlocale">current
// locale</link>. If <envar>G_FILENAME_ENCODING</envar> is not set, but
// <envar>G_BROKEN_FILENAMES</envar> is, 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 or
// <envar>G_FILENAME_ENCODING</envar> value, the actual file names present
// on a system might be in any random encoding or just gibberish.
// RETURNS: %TRUE if the filename encoding is UTF-8.
// <charsets>: return location for the %NULL-terminated list of encoding names
static int get_filename_charsets(char*** charsets) {
   return g_get_filename_charsets(charsets);
}


// Gets the current user's home directory as defined in the
// password database.
// 
// Note that in contrast to traditional UNIX tools, this function
// prefers <filename>passwd</filename> entries over the <envar>HOME</envar>
// environment variable.
// 
// One of the reasons for this decision is that applications in many
// cases need special handling to deal with the case where
// <envar>HOME</envar> is
// <simplelist>
// <member>Not owned by the user</member>
// <member>Not writeable</member>
// <member>Not even readable</member>
// </simplelist>
// Since applications are in general <emphasis>not</emphasis> written
// to deal with these situations it was considered better to make
// g_get_home_dir() not pay attention to <envar>HOME</envar> and to
// return the real home directory for the user. If applications
// want to pay attention to <envar>HOME</envar>, they can do:
// |[
// const char *homedir = g_getenv ("HOME");
// if (!homedir)
// homedir = g_get_home_dir (<!-- -->);
// ]|
// RETURNS: the current user's home directory
static char* get_home_dir() {
   return g_get_home_dir();
}


// 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.
// RETURNS: the host name of the machine.
static char* get_host_name() {
   return g_get_host_name();
}


// 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 <envar>LANGUAGE</envar>,
// <envar>LC_ALL</envar>, <envar>LC_MESSAGES</envar> and <envar>LANG</envar>
// to find the list of locales specified by the user.
// 
// that must not be modified or freed.
// RETURNS: a %NULL-terminated array of strings owned by GLib
static char** get_language_names() {
   return g_get_language_names();
}


// 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.
// 
// For example, if @locale is "fr_BE", then the returned list
// is "fr_BE", "fr".
// 
// If you need the list of variants for the <emphasis>current locale</emphasis>,
// use g_get_language_names().
// 
// allocated array of newly allocated strings with the locale variants. Free with
// g_strfreev().
// RETURNS: a newly
// <locale>: a locale identifier
static char** /*new*/ get_locale_variants(char* locale) {
   return g_get_locale_variants(locale);
}


// Queries the system monotonic time, if available.
// 
// On POSIX systems with clock_gettime() and %CLOCK_MONOTONIC this call
// is a very shallow wrapper for that.  Otherwise, we make a best effort
// that probably involves returning the wall clock time (with at least
// microsecond accuracy, subject to the limitations of the OS kernel).
// 
// It's important to note that POSIX %CLOCK_MONOTONIC does not count
// time spent while the machine is suspended.
// 
// On Windows, "limitations of the OS kernel" is a rather substantial
// statement.  Depending on the configuration of the system, the wall
// clock time is updated as infrequently as 64 times a second (which
// is approximately every 16ms).
// RETURNS: the monotonic time, in microseconds
static long get_monotonic_time() {
   return g_get_monotonic_time();
}


// Gets the name of the program. This name should <emphasis>not</emphasis>
// be localized, contrast with g_get_application_name().
// (If you are using GDK or GTK+ the program name is set in gdk_init(),
// which is called by gtk_init(). The program name is found by taking
// the last component of <literal>argv[0]</literal>.)
// 
// to GLib and must not be modified or freed.
// RETURNS: the name of the program. The returned string belongs
static char* /*new*/ get_prgname() {
   return g_get_prgname();
}


// Gets the real name of the user. This usually comes from the user's entry
// in the <filename>passwd</filename> file. The encoding of the returned
// string is system-defined. (On Windows, it is, however, always UTF-8.)
// If the real user name cannot be determined, the string "Unknown" is
// returned.
// RETURNS: the user's real name.
static char* get_real_name() {
   return g_get_real_name();
}


// Queries the system wall-clock time.
// 
// This call is functionally equivalent to g_get_current_time() except
// that the return value is often more convenient than dealing with a
// #GTimeVal.
// 
// You should only use this call if you are actually interested in the real
// wall-clock time.  g_get_monotonic_time() is probably more useful for
// measuring intervals.
// RETURNS: the number of microseconds since January 1, 1970 UTC.
static long get_real_time() {
   return g_get_real_time();
}


// 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 <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
// XDG Base Directory Specification</ulink>.
// In this case the list of directories retrieved will be XDG_CONFIG_DIRS.
// 
// On Windows is the directory that contains application data for all users.
// A typical path is C:\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 CSIDL_COMMON_APPDATA folder.
// This information will not roam and is available to anyone using the computer.
// 
// not be modified or freed.
// RETURNS: a %NULL-terminated array of strings owned by GLib that must
static char** get_system_config_dirs() {
   return g_get_system_config_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 <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
// XDG Base Directory Specification</ulink>
// In this case the list of directories retrieved will be XDG_DATA_DIRS.
// 
// On Windows 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 CSIDL_COMMON_APPDATA and
// CSIDL_COMMON_DOCUMENTS.
// 
// 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.
// 
// not be modified or freed.
// RETURNS: a %NULL-terminated array of strings owned by GLib that must
static char** get_system_data_dirs() {
   return g_get_system_data_dirs();
}


// Gets the directory to use for temporary files. This is found from
// inspecting the environment variables <envar>TMPDIR</envar>,
// <envar>TMP</envar>, and <envar>TEMP</envar> in that order. If none
// of those are defined "/tmp" is returned on UNIX and "C:\" on Windows.
// The encoding of the returned string is system-defined. On Windows,
// it is always UTF-8. The return value is never %NULL or the empty string.
// RETURNS: the directory to use for temporary files.
static char* get_tmp_dir() {
   return g_get_tmp_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 <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
// XDG Base Directory Specification</ulink>.
// In this case the directory retrieved will be XDG_CACHE_HOME.
// 
// On Windows is the directory that serves as a common repository for
// temporary Internet files. A typical path is
// C:\Documents and Settings\username\Local Settings\Temporary Internet Files.
// See documentation for CSIDL_INTERNET_CACHE.
// 
// or freed.
// RETURNS: a string owned by GLib that must not be modified
static char* get_user_cache_dir() {
   return g_get_user_cache_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 <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
// XDG Base Directory Specification</ulink>.
// In this case the directory retrieved will be XDG_CONFIG_HOME.
// 
// On Windows this is the folder to use for local (as opposed to
// roaming) application data. See documentation for
// CSIDL_LOCAL_APPDATA. Note that on Windows it thus is the same as
// what g_get_user_data_dir() returns.
// 
// or freed.
// RETURNS: a string owned by GLib that must not be modified
static char* get_user_config_dir() {
   return g_get_user_config_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 <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
// XDG Base Directory Specification</ulink>.
// In this case the directory retrieved will be XDG_DATA_HOME.
// 
// On Windows this is the folder to use for local (as opposed to
// roaming) application data. See documentation for
// CSIDL_LOCAL_APPDATA. Note that on Windows it thus is the same as
// what g_get_user_config_dir() returns.
// 
// or freed.
// RETURNS: a string owned by GLib that must not be modified
static char* get_user_data_dir() {
   return g_get_user_data_dir();
}


// Gets the user name of the current user. The encoding of the returned
// string is system-defined. On UNIX, it might be the preferred file name
// encoding, or something else, and there is no guarantee that it is even
// consistent on a machine. On Windows, it is always UTF-8.
// RETURNS: the user name of the current user.
static char* get_user_name() {
   return g_get_user_name();
}


// Returns a directory that is unique to the current user on the local
// system.
// 
// On UNIX platforms this is determined using the mechanisms described in
// the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
// XDG Base Directory Specification</ulink>.  This is the directory
// specified in the <envar>XDG_RUNTIME_DIR</envar> environment variable.
// In the case that this variable is not set, GLib will issue a warning
// message to stderr and return the value of g_get_user_cache_dir().
// 
// On Windows this is the folder to use for local (as opposed to
// roaming) application data. See documentation for
// CSIDL_LOCAL_APPDATA.  Note that on Windows it thus is the same as
// what g_get_user_config_dir() returns.
// RETURNS: a string owned by GLib that must not be modified or freed.
static char* get_user_runtime_dir() {
   return g_get_user_runtime_dir();
}


// 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 <filename>$HOME/Desktop</filename> when XDG special
// user directories have not been set up.
// 
// Depending on the platform, the user might be able to change the path
// of the special directory without requiring the session to restart; GLib
// will not reflect any change once the special directories are loaded.
// 
// if the logical id was not found. The returned string is owned by
// GLib and should not be modified or freed.
// RETURNS: the path to the specified special directory, or %NULL
// <directory>: the logical id of special directory
static char* get_user_special_dir(UserDirectory directory) {
   return g_get_user_special_dir(directory);
}


// Returns the value of an environment variable. The name and value
// are in the GLib file name encoding. On UNIX, this means the actual
// bytes which might or might not be in some consistent character set
// and encoding. On Windows, it is in UTF-8. On Windows, in case the
// environment variable's value contains references to other
// environment variables, they are expanded.
// 
// the environment variable is not found. The returned string may be
// overwritten by the next call to g_getenv(), g_setenv() or
// g_unsetenv().
// RETURNS: the value of the environment variable, or %NULL if
// <variable>: the environment variable to get, in the GLib file name encoding.
static char* getenv(char* variable) {
   return g_getenv(variable);
}


// 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>: a #GHashTable.
static void hash_table_destroy(GLib2.HashTable* hash_table) {
   g_hash_table_destroy(hash_table);
}


// 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.
// <hash_table>: a #GHashTable.
// <key>: a key to insert.
// <value>: the value to associate with the key.
static void hash_table_insert(GLib2.HashTable* hash_table, void* key, void* value) {
   g_hash_table_insert(hash_table, key, value);
}


// 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.
// RETURNS: %TRUE if the key was found in the #GHashTable.
// <hash_table>: a #GHashTable
// <lookup_key>: the key to look up
// <orig_key>: return location for the original key, or %NULL
// <value>: return location for the value associated with the key, or %NULL
static int hash_table_lookup_extended(GLib2.HashTable* hash_table, const(void)* lookup_key, void** orig_key, void** value) {
   return g_hash_table_lookup_extended(hash_table, lookup_key, orig_key, value);
}


// 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.
// RETURNS: %TRUE if the key was found and removed from the #GHashTable.
// <hash_table>: a #GHashTable.
// <key>: the key to remove.
static int hash_table_remove(GLib2.HashTable* hash_table, const(void)* key) {
   return g_hash_table_remove(hash_table, key);
}


// 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>: a #GHashTable
static void hash_table_remove_all(GLib2.HashTable* hash_table) {
   g_hash_table_remove_all(hash_table);
}


// Inserts a new key and value into a #GHashTable similar to
// g_hash_table_insert(). The difference is that if the key already exists
// in the #GHashTable, it gets replaced by the new key. If you supplied a
// @value_destroy_func when creating the #GHashTable, the old value is freed
// using that function. If you supplied a @key_destroy_func when creating the
// #GHashTable, the old key is freed using that function.
// <hash_table>: a #GHashTable.
// <key>: a key to insert.
// <value>: the value to associate with the key.
static void hash_table_replace(GLib2.HashTable* hash_table, void* key, void* value) {
   g_hash_table_replace(hash_table, key, value);
}


// Returns the number of elements contained in the #GHashTable.
// RETURNS: the number of key/value pairs in the #GHashTable.
// <hash_table>: a #GHashTable.
static uint hash_table_size(GLib2.HashTable* hash_table) {
   return g_hash_table_size(hash_table);
}


// Removes a key and its associated value from a #GHashTable without
// calling the key and value destroy functions.
// RETURNS: %TRUE if the key was found and removed from the #GHashTable.
// <hash_table>: a #GHashTable.
// <key>: the key to remove.
static int hash_table_steal(GLib2.HashTable* hash_table, const(void)* key) {
   return g_hash_table_steal(hash_table, key);
}


// Removes all keys and their associated values from a #GHashTable
// without calling the key and value destroy functions.
// <hash_table>: a #GHashTable.
static void hash_table_steal_all(GLib2.HashTable* hash_table) {
   g_hash_table_steal_all(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>: a valid #GHashTable.
static void hash_table_unref(GLib2.HashTable* hash_table) {
   g_hash_table_unref(hash_table);
}

static int hook_destroy(HookList* hook_list, c_ulong hook_id) {
   return g_hook_destroy(hook_list, hook_id);
}

static void hook_destroy_link(HookList* hook_list, Hook* hook) {
   g_hook_destroy_link(hook_list, hook);
}

static void hook_free(HookList* hook_list, Hook* hook) {
   g_hook_free(hook_list, hook);
}

static void hook_insert_before(HookList* hook_list, Hook* sibling, Hook* hook) {
   g_hook_insert_before(hook_list, sibling, hook);
}

static void hook_prepend(HookList* hook_list, Hook* hook) {
   g_hook_prepend(hook_list, hook);
}

static void hook_unref(HookList* hook_list, Hook* hook) {
   g_hook_unref(hook_list, hook);
}


// 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.
// 
// segments.
// RETURNS: %TRUE if @hostname contains any ASCII-encoded
// <hostname>: a hostname
static int hostname_is_ascii_encoded(char* hostname) {
   return g_hostname_is_ascii_encoded(hostname);
}


// Tests if @hostname is the string form of an IPv4 or IPv6 address.
// (Eg, "192.168.0.1".)
// RETURNS: %TRUE if @hostname is an IP address
// <hostname>: a hostname (or IP address in string form)
static int hostname_is_ip_address(char* hostname) {
   return g_hostname_is_ip_address(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.
// RETURNS: %TRUE if @hostname contains any non-ASCII characters
// <hostname>: a hostname
static int hostname_is_non_ascii(char* hostname) {
   return g_hostname_is_non_ascii(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 in some way invalid.
// RETURNS: an ASCII hostname, which must be freed, or %NULL if
// <hostname>: a valid UTF-8 or ASCII hostname
static char* /*new*/ hostname_to_ascii(char* hostname) {
   return g_hostname_to_ascii(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 in some way invalid.
// RETURNS: a UTF-8 hostname, which must be freed, or %NULL if
// <hostname>: a valid UTF-8 or ASCII hostname
static char* /*new*/ hostname_to_unicode(char* hostname) {
   return g_hostname_to_unicode(hostname);
}


// Unintrospectable function: idle_add() / g_idle_add()
// Adds a function to be called whenever there are no higher priority
// events pending to the default main loop. The function is given the
// default idle priority, #G_PRIORITY_DEFAULT_IDLE.  If the function
// returns %FALSE it is automatically removed from the list of event
// sources and will not be called again.
// 
// This internally creates a main loop source using g_idle_source_new()
// and attaches it to the main loop context using g_source_attach().
// You can do these steps manually if you need greater control.
// RETURNS: the ID (greater than 0) of the event source.
// <function>: function to call
// <data>: data to pass to @function.
static uint idle_add(SourceFunc function_, void* data) {
   return g_idle_add(function_, data);
}


// Adds a function to be called whenever there are no higher priority
// events pending.  If the function returns %FALSE it is automatically
// removed from the list of event sources and will not be called again.
// 
// This internally creates a main loop source using g_idle_source_new()
// and attaches it to the main loop context using g_source_attach().
// You can do these steps manually if you need greater control.
// RETURNS: the ID (greater than 0) of the event source.
// <priority>: the priority of the idle source. Typically this will be in the range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
// <function>: function to call
// <data>: data to pass to @function
// <notify>: function to call when the idle is removed, or %NULL
static uint idle_add_full(int priority, SourceFunc function_, void* data, DestroyNotify notify) {
   return g_idle_add_full(priority, function_, data, notify);
}


// Removes the idle function with the given data.
// RETURNS: %TRUE if an idle source was found and removed.
// <data>: the data for the idle source's callback.
static int idle_remove_by_data(void* data) {
   return g_idle_remove_by_data(data);
}


// Creates a new idle source.
// 
// The source will not initially be associated with any #GMainContext
// and must be added to one with g_source_attach() before it will be
// executed. Note that the default priority for idle sources is
// %G_PRIORITY_DEFAULT_IDLE, as compared to other sources which
// have a default priority of %G_PRIORITY_DEFAULT.
// RETURNS: the newly-created idle source
static Source* /*new*/ idle_source_new() {
   return g_idle_source_new();
}


// Compares the two #gint64 values being pointed to and returns
// %TRUE if they are equal.
// It can be passed to g_hash_table_new() as the @key_equal_func
// parameter, when using pointers to 64-bit integers as keys in a #GHashTable.
// RETURNS: %TRUE if the two keys match.
// <v1>: a pointer to a #gint64 key.
// <v2>: a pointer to a #gint64 key to compare with @v1.
static int int64_equal(const(void)* v1, const(void)* v2) {
   return g_int64_equal(v1, v2);
}


// 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 pointers to 64-bit integers values as keys in a #GHashTable.
// RETURNS: a hash value corresponding to the key.
// <v>: a pointer to a #gint64 key
static uint int64_hash(const(void)* v) {
   return g_int64_hash(v);
}


// 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 pointers to integers as keys in a #GHashTable.
// RETURNS: %TRUE if the two keys match.
// <v1>: a pointer to a #gint key.
// <v2>: a pointer to a #gint key to compare with @v1.
static int int_equal(const(void)* v1, const(void)* v2) {
   return g_int_equal(v1, v2);
}


// 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 pointers to integers values as keys in a #GHashTable.
// RETURNS: a hash value corresponding to the key.
// <v>: a pointer to a #gint key
static uint int_hash(const(void)* v) {
   return g_int_hash(v);
}


// Returns a canonical representation for @string. Interned strings can
// be compared for equality by comparing the pointers, instead of using strcmp().
// g_intern_static_string() does not copy the string, therefore @string must
// not be freed or modified.
// RETURNS: a canonical representation for the string
// <string>: a static string
static char* intern_static_string(char* string_=null) {
   return g_intern_static_string(string_);
}


// Returns a canonical representation for @string. Interned strings can
// be compared for equality by comparing the pointers, instead of using strcmp().
// RETURNS: a canonical representation for the string
// <string>: a string
static char* intern_string(char* string_=null) {
   return g_intern_string(string_);
}


// Unintrospectable function: io_add_watch() / g_io_add_watch()
// Adds the #GIOChannel into the default main loop context
// with the default priority.
// RETURNS: the event source id
// <channel>: a #GIOChannel
// <condition>: the condition to watch for
// <func>: the function to call when the condition is satisfied
// <user_data>: user data to pass to @func
static uint io_add_watch(IOChannel* channel, IOCondition condition, IOFunc func, void* user_data) {
   return g_io_add_watch(channel, condition, func, user_data);
}


// 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.
// RETURNS: the event source id
// <channel>: a #GIOChannel
// <priority>: the priority of the #GIOChannel source
// <condition>: the condition to watch for
// <func>: the function to call when the condition is satisfied
// <user_data>: user data to pass to @func
// <notify>: the function to call when the source is removed
static uint io_add_watch_full(IOChannel* channel, int priority, IOCondition condition, IOFunc func, void* user_data, DestroyNotify notify) {
   return g_io_add_watch_full(channel, priority, condition, func, user_data, notify);
}


// Converts an <literal>errno</literal> error number to a #GIOChannelError.
// 
// %G_IO_CHANNEL_ERROR_INVAL.
// RETURNS: a #GIOChannelError error number, e.g.
// <en>: an <literal>errno</literal> error number, e.g. %EINVAL
static IOChannelError io_channel_error_from_errno(int en) {
   return g_io_channel_error_from_errno(en);
}

// RETURNS: the quark used as %G_IO_CHANNEL_ERROR
static Quark io_channel_error_quark() {
   return g_io_channel_error_quark();
}


// Creates a #GSource that's dispatched when @condition is met for the
// given @channel. For example, if condition is #G_IO_IN, the source will
// be dispatched when there's data available for reading.
// 
// 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.
// RETURNS: a new #GSource
// <channel>: a #GIOChannel to watch
// <condition>: conditions to watch for
static Source* /*new*/ io_create_watch(IOChannel* channel, IOCondition condition) {
   return g_io_create_watch(channel, condition);
}

static Quark key_file_error_quark() {
   return g_key_file_error_quark();
}


// Restores the previous #GAllocator, used when allocating #GList
// elements.
// 
// Note that this function is not available if GLib has been compiled
// with <option>--disable-mem-pools</option>
// 
// Deprecated:2.10: It does nothing, since #GList has been converted
// to the <link linkend="glib-Memory-Slices">slice
// allocator</link>
static void list_pop_allocator() {
   g_list_pop_allocator();
}


// Sets the allocator to use to allocate #GList elements. Use
// g_list_pop_allocator() to restore the previous allocator.
// 
// Note that this function is not available if GLib has been compiled
// with <option>--disable-mem-pools</option>
// 
// Deprecated:2.10: It does nothing, since #GList has been converted
// to the <link linkend="glib-Memory-Slices">slice
// allocator</link>
// <allocator>: the #GAllocator to use when allocating #GList elements.
static void list_push_allocator(void* allocator) {
   g_list_push_allocator(allocator);
}


// Gets the names of all variables set in the environment.
// 
// with g_strfreev().
// 
// 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.
// RETURNS: a %NULL-terminated list of strings which must be freed
static char** /*new*/ listenv() {
   return g_listenv();
}


// 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 <link linkend="setlocale">current locale</link>. On
// Windows this means the system codepage.
// RETURNS: The converted string, or %NULL on an error.
// <utf8string>: a UTF-8 encoded string
// <len>: the length of the string, or -1 if the string is nul-terminated<footnoteref linkend="nul-unsafe"/>.
// <bytes_read>: location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence.
// <bytes_written>: the number of bytes stored in the output buffer (not including the terminating nul).
static char* /*new*/ locale_from_utf8(char* utf8string, ssize_t len, size_t* bytes_read, size_t* bytes_written, GLib2.Error** error=null) {
   return g_locale_from_utf8(utf8string, len, bytes_read, bytes_written, error);
}


// 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 <link linkend="setlocale">current locale</link> into a
// UTF-8 string.
// RETURNS: The converted string, or %NULL on an error.
// <opsysstring>: a string in the encoding of the current locale. On Windows this means the system codepage.
// <len>: the length of the string, or -1 if the string is nul-terminated<footnoteref linkend="nul-unsafe"/>.
// <bytes_read>: location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence.
// <bytes_written>: the number of bytes stored in the output buffer (not including the terminating nul).
static char* /*new*/ locale_to_utf8(char* opsysstring, ssize_t len, size_t* bytes_read, size_t* bytes_written, GLib2.Error** error=null) {
   return g_locale_to_utf8(opsysstring, len, bytes_read, bytes_written, error);
}

// Unintrospectable function: log() / g_log()
alias g_log log; // Variadic

static void log_default_handler(char* log_domain, LogLevelFlags log_level, char* message, void* unused_data) {
   g_log_default_handler(log_domain, log_level, message, unused_data);
}

static void log_remove_handler(char* log_domain, uint handler_id) {
   g_log_remove_handler(log_domain, handler_id);
}

static LogLevelFlags log_set_always_fatal(LogLevelFlags fatal_mask) {
   return g_log_set_always_fatal(fatal_mask);
}

// Unintrospectable function: log_set_default_handler() / g_log_set_default_handler()
static LogFunc log_set_default_handler(LogFunc log_func, void* user_data) {
   return g_log_set_default_handler(log_func, user_data);
}

static LogLevelFlags log_set_fatal_mask(char* log_domain, LogLevelFlags fatal_mask) {
   return g_log_set_fatal_mask(log_domain, fatal_mask);
}

// Unintrospectable function: log_set_handler() / g_log_set_handler()
static uint log_set_handler(char* log_domain, LogLevelFlags log_levels, LogFunc log_func, void* user_data) {
   return g_log_set_handler(log_domain, log_levels, log_func, user_data);
}

// Unintrospectable function: logv() / g_logv()
static void logv(char* log_domain, LogLevelFlags log_level, char* format, va_list args) {
   g_logv(log_domain, log_level, format, args);
}


// Returns the global default main context. This is the main context
// used for main loop functions when a main loop is not explicitly
// specified, and corresponds to the "main" main loop. See also
// g_main_context_get_thread_default().
// RETURNS: the global default main context.
static MainContext* main_context_default() {
   return g_main_context_default();
}


// Gets the thread-default #GMainContext for this thread. Asynchronous
// operations that want to be able to be run in contexts other than
// the default one should call this method to get a #GMainContext to
// add their #GSource<!-- -->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 %NULL if threads are not initialized.)
// 
// %NULL if the thread-default context is the global default context.
// RETURNS: the thread-default #GMainContext, or
static MainContext* main_context_get_thread_default() {
   return g_main_context_get_thread_default();
}


// Returns the currently firing source for this thread.
// RETURNS: The currently firing source or %NULL.
static Source* main_current_source() {
   return g_main_current_source();
}


// Returns the depth of the stack of calls to
// g_main_context_dispatch() on any #GMainContext in the current thread.
// That is, when called from the toplevel, it gives 0. When
// called from within a callback from g_main_context_iteration()
// (or g_main_loop_run(), etc.) it returns 1. When called from within
// a callback to a recursive call to g_main_context_iteration(),
// it returns 2. And so forth.
// 
// This function is useful in a situation like the following:
// Imagine an extremely simple "garbage collected" system.
// 
// |[
// static GList *free_list;
// 
// gpointer
// allocate_memory (gsize size)
// {
// gpointer result = g_malloc (size);
// free_list = g_list_prepend (free_list, result);
// return result;
// }
// 
// void
// free_allocated_memory (void)
// {
// GList *l;
// for (l = free_list; l; l = l->next);
// g_free (l->data);
// g_list_free (free_list);
// free_list = NULL;
// }
// 
// [...]
// 
// while (TRUE);
// {
// g_main_context_iteration (NULL, TRUE);
// free_allocated_memory();
// }
// ]|
// 
// This works from an application, however, if you want to do the same
// thing from a library, it gets more difficult, since you no longer
// control the main loop. You might think you can simply use an idle
// function to make the call to free_allocated_memory(), but that
// doesn't work, since the idle function could be called from a
// recursive callback. This can be fixed by using g_main_depth()
// 
// |[
// gpointer
// allocate_memory (gsize size)
// {
// FreeListBlock *block = g_new (FreeListBlock, 1);
// block->mem = g_malloc (size);
// block->depth = g_main_depth ();
// free_list = g_list_prepend (free_list, block);
// return block->mem;
// }
// 
// void
// free_allocated_memory (void)
// {
// GList *l;
// 
// int depth = g_main_depth ();
// for (l = free_list; l; );
// {
// GList *next = l->next;
// FreeListBlock *block = l->data;
// if (block->depth > depth)
// {
// g_free (block->mem);
// g_free (block);
// free_list = g_list_delete_link (free_list, l);
// }
// 
// l = next;
// }
// }
// ]|
// 
// There is a temptation to use g_main_depth() to solve
// problems with reentrancy. For instance, while waiting for data
// to be received from the network in response to a menu item,
// the menu item might be selected again. It might seem that
// one could make the menu item's callback return immediately
// and do nothing if g_main_depth() returns a value greater than 1.
// However, this should be avoided since the user then sees selecting
// the menu item do nothing. Furthermore, you'll find yourself adding
// these checks all over your code, since there are doubtless many,
// many things that the user could do. Instead, you can use the
// following techniques:
// 
// <orderedlist>
// <listitem>
// <para>
// Use gtk_widget_set_sensitive() or modal dialogs to prevent
// the user from interacting with elements while the main
// loop is recursing.
// </para>
// </listitem>
// <listitem>
// <para>
// 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.
// </para>
// </listitem>
// </orderedlist>
// RETURNS: The main loop recursion level in the current thread
static int main_depth() {
   return g_main_depth();
}


// Unintrospectable function: malloc() / g_malloc()
// Allocates @n_bytes bytes of memory.
// If @n_bytes is 0 it returns %NULL.
// RETURNS: a pointer to the allocated memory
// <n_bytes>: the number of bytes to allocate
static void* malloc(size_t n_bytes) {
   return g_malloc(n_bytes);
}


// Unintrospectable function: malloc0() / g_malloc0()
// Allocates @n_bytes bytes of memory, initialized to 0's.
// If @n_bytes is 0 it returns %NULL.
// RETURNS: a pointer to the allocated memory
// <n_bytes>: the number of bytes to allocate
static void* malloc0(size_t n_bytes) {
   return g_malloc0(n_bytes);
}


// Unintrospectable function: malloc0_n() / g_malloc0_n()
// This function is similar to g_malloc0(), allocating (@n_blocks * @n_block_bytes) bytes,
// but care is taken to detect possible overflow during multiplication.
// RETURNS: a pointer to the allocated memory
// <n_blocks>: the number of blocks to allocate
// <n_block_bytes>: the size of each block in bytes
static void* malloc0_n(size_t n_blocks, size_t n_block_bytes) {
   return g_malloc0_n(n_blocks, n_block_bytes);
}


// Unintrospectable function: malloc_n() / g_malloc_n()
// This function is similar to g_malloc(), allocating (@n_blocks * @n_block_bytes) bytes,
// but care is taken to detect possible overflow during multiplication.
// RETURNS: a pointer to the allocated memory
// <n_blocks>: the number of blocks to allocate
// <n_block_bytes>: the size of each block in bytes
static void* malloc_n(size_t n_blocks, size_t n_block_bytes) {
   return g_malloc_n(n_blocks, n_block_bytes);
}


// Unintrospectable function: markup_collect_attributes() / g_markup_collect_attributes()
// 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 @element_name, @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.
// RETURNS: %TRUE if successful
// <element_name>: the current tag name
// <attribute_names>: the attribute names
// <attribute_values>: the attribute values
// <error>: a pointer to a #GError or %NULL
// <first_type>: the #GMarkupCollectType of the first attribute
// <first_attr>: the name of the first attribute
alias g_markup_collect_attributes markup_collect_attributes; // Variadic

static Quark markup_error_quark() {
   return g_markup_error_quark();
}


// 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 &amp;#x1; ... &amp;#x1f; for all control sequences
// except for tabstop, newline and carriage return.  The character
// references in this range are not valid XML 1.0, but they are
// valid XML 1.1 and will be accepted by the GMarkup parser.
// RETURNS: a newly allocated string with the escaped text
// <text>: some valid UTF-8 text
// <length>: length of @text in bytes, or -1 if the text is nul-terminated
static char* /*new*/ markup_escape_text(char* text, ssize_t length) {
   return g_markup_escape_text(text, length);
}


// Unintrospectable function: markup_printf_escaped() / g_markup_printf_escaped()
// 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 &amp; Mason";
// const char *item = "Tea";
// char *output;
// &nbsp;
// output = g_markup_printf_escaped ("&lt;purchase&gt;"
// "&lt;store&gt;&percnt;s&lt;/store&gt;"
// "&lt;item&gt;&percnt;s&lt;/item&gt;"
// "&lt;/purchase&gt;",
// store, item);
// ]|
// 
// operation. Free with g_free().
// RETURNS: newly allocated result from formatting
// <format>: printf() style format string
alias g_markup_printf_escaped markup_printf_escaped; // Variadic


// Unintrospectable function: markup_vprintf_escaped() / g_markup_vprintf_escaped()
// Formats the data in @args according to @format, escaping
// all string and character arguments in the fashion
// of g_markup_escape_text(). See g_markup_printf_escaped().
// 
// operation. Free with g_free().
// RETURNS: newly allocated result from formatting
// <format>: printf() style format string
// <args>: variable argument list, similar to vprintf()
static char* /*new*/ markup_vprintf_escaped(char* format, va_list args) {
   return g_markup_vprintf_escaped(format, args);
}


// Outputs debugging information for all #GMemChunk objects currently
// in use. It outputs the number of #GMemChunk objects currently
// allocated, and calls g_mem_chunk_print() to output information on
// each one.
// 
// Deprecated:2.10: Use the <link linkend="glib-Memory-Slices">slice
// allocator</link> instead
static void mem_chunk_info() {
   g_mem_chunk_info();
}


// 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 interchangeable 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.
// 
// A different allocator can be set using g_mem_set_vtable().
// RETURNS: if %TRUE, malloc() and g_malloc() can be mixed.
static int mem_is_system_malloc() {
   return g_mem_is_system_malloc();
}


// Outputs a summary of memory usage.
// 
// It outputs the frequency of allocations of different sizes,
// the total number of bytes which have been allocated,
// the total number of bytes which have been freed,
// and the difference between the previous two values, i.e. the number of bytes
// still in use.
// 
// Note that this function will not output anything unless you have
// previously installed the #glib_mem_profiler_table with g_mem_set_vtable().
static void mem_profile() {
   g_mem_profile();
}


// Sets the #GMemVTable to use for memory allocation. You can use this to provide
// custom memory allocation routines. <emphasis>This function must be called
// before using any other GLib functions.</emphasis> The @vtable only needs to
// provide malloc(), realloc(), and free() functions; GLib can provide default
// implementations of the others. The malloc() and realloc() implementations
// should return %NULL on failure, GLib will handle error-checking for you.
// @vtable is copied, so need not persist after this function has been called.
// <vtable>: table of memory allocation routines.
static void mem_set_vtable(MemVTable* vtable) {
   g_mem_set_vtable(vtable);
}


// Unintrospectable function: memdup() / g_memdup()
// Allocates @byte_size bytes of memory, and copies @byte_size bytes into it
// from @mem. If @mem is %NULL it returns %NULL.
// 
// is %NULL.
// RETURNS: a pointer to the newly-allocated copy of the memory, or %NULL if @mem
// <mem>: the memory to copy.
// <byte_size>: the number of bytes to copy.
static void* memdup(const(void)* mem, uint byte_size) {
   return g_memdup(mem, byte_size);
}


// Create a directory if it doesn't already exist. Create intermediate
// parent directories as needed, too.
// 
// created. Returns -1 if an error occurred, with errno set.
// RETURNS: 0 if the directory already exists, or was successfully
// <pathname>: a pathname in the GLib file name encoding
// <mode>: permissions to use for newly created directories
static int mkdir_with_parents(char* pathname, int mode) {
   return g_mkdir_with_parents(pathname, mode);
}


// Creates a temporary directory. See the mkdtemp() documentation
// on most UNIX-like systems.
// 
// The parameter is a string that should follow the rules for
// mkdtemp() templates, i.e. contain the string "XXXXXX".
// g_mkdtemp() 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 and additional @flags. 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.
// 
// to hold the directory name.  In case of errors, %NULL is
// returned and %errno will be set.
// RETURNS: A pointer to @tmpl, which has been modified
// <tmpl>: template directory name
static char* /*new*/ mkdtemp(char* tmpl) {
   return g_mkdtemp(tmpl);
}


// Creates a temporary directory. See the mkdtemp() documentation
// on most UNIX-like systems.
// 
// The parameter is a string that should follow the rules for
// mkdtemp() templates, i.e. contain the string "XXXXXX".
// g_mkdtemp() is slightly more flexible than mkdtemp() in that the
// sequence does not have to occur at the very end of the template
// 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.
// 
// to hold the directory name. In case of errors, %NULL is
// returned, and %errno will be set.
// RETURNS: A pointer to @tmpl, which has been modified
// <tmpl>: template directory name
// <mode>: permissions to create the temporary directory with
static char* /*new*/ mkdtemp_full(char* tmpl, int mode) {
   return g_mkdtemp_full(tmpl, mode);
}


// Opens a temporary file. See the mkstemp() documentation
// on most UNIX-like systems.
// 
// The parameter is a string that should follow the rules for
// mkstemp() templates, i.e. contain the string "XXXXXX".
// g_mkstemp() 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.
// 
// 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.
// RETURNS: A file handle (as from open()) to the file
// <tmpl>: template filename
static int mkstemp(char* tmpl) {
   return g_mkstemp(tmpl);
}


// Opens a temporary file. See the mkstemp() documentation
// on most UNIX-like systems.
// 
// The parameter is a string that should follow the rules for
// mkstemp() templates, i.e. contain the string "XXXXXX".
// g_mkstemp_full() is slightly more flexible than mkstemp()
// in that the sequence does not have to occur at the very end of the
// template and you can pass a @mode and additional @flags. The X
// string will be modified to form the name of a file that didn't exist.
// The string should be in the GLib file name encoding. Most importantly,
// on Windows it should be in UTF-8.
// 
// 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.
// RETURNS: A file handle (as from open()) to the file
// <tmpl>: template filename
// <flags>: flags to pass to an open() call in addition to O_EXCL and O_CREAT, which are passed automatically
// <mode>: permissions to create the temporary file with
static int mkstemp_full(char* tmpl, int flags, int mode) {
   return g_mkstemp_full(tmpl, flags, mode);
}


// Restores the previous #GAllocator, used when allocating #GNode
// elements.
// 
// Note that this function is not available if GLib has been compiled
// with <option>--disable-mem-pools</option>
// 
// Deprecated:2.10: It does nothing, since #GNode has been converted to
// the <link linkend="glib-Memory-Slices">slice
// allocator</link>
static void node_pop_allocator() {
   g_node_pop_allocator();
}


// Sets the allocator to use to allocate #GNode elements. Use
// g_node_pop_allocator() to restore the previous allocator.
// 
// Note that this function is not available if GLib has been compiled
// with <option>--disable-mem-pools</option>
// 
// Deprecated:2.10: It does nothing, since #GNode has been converted to
// the <link linkend="glib-Memory-Slices">slice
// allocator</link>
// <dummy>: the #GAllocator to use when allocating #GNode elements.
static void node_push_allocator(void* dummy) {
   g_node_push_allocator(dummy);
}


// Set the pointer at the specified location to %NULL.
// <nullify_location>: the memory address of the pointer.
static void nullify_pointer(void** nullify_location) {
   g_nullify_pointer(nullify_location);
}


// Prompts the user with
// <computeroutput>[E]xit, [H]alt, show [S]tack trace or [P]roceed</computeroutput>.
// 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.
// 
// |[
// &num;include &lt;glib.h&gt;
// 
// 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);
// /&ast; ... &ast;/
// ]|
// 
// If [E]xit is selected, the application terminates with a call
// to <literal>_exit(0)</literal>.
// 
// If [S]tack trace is selected, g_on_error_stack_trace() is called.
// This invokes <command>gdb</command>, 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.
// <prg_name>: the program name, needed by <command>gdb</command> 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)
static void on_error_query(char* prg_name) {
   g_on_error_query(prg_name);
}


// Invokes <command>gdb</command>, 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.
// 
// This function may cause different actions on non-UNIX platforms.
// <prg_name>: the program name, needed by <command>gdb</command> 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)
static void on_error_stack_trace(char* prg_name) {
   g_on_error_stack_trace(prg_name);
}


// Function to be called when starting a critical initialization
// section. The argument @value_location must point to a static
// 0-initialized variable that will be set to a value other than 0 at
// the end of the initialization section. In combination with
// g_once_init_leave() and the unique address @value_location, it can
// be ensured that an initialization section will be executed only once
// during a program's life time, and that concurrent threads are
// blocked until initialization completed. To be used in constructs
// like this:
// 
// <informalexample>
// <programlisting>
// static gsize initialization_value = 0;
// 
// if (g_once_init_enter (&amp;initialization_value))
// {
// gsize setup_value = 42; /<!-- -->* initialization code here *<!-- -->/
// 
// g_once_init_leave (&amp;initialization_value, setup_value);
// }
// 
// /<!-- -->* use initialization_value here *<!-- -->/
// </programlisting>
// </informalexample>
// <value_location>: location of a static initializable variable containing 0.
static int once_init_enter(size_t* value_location) {
   return g_once_init_enter(value_location);
}

static int once_init_enter_impl(size_t* value_location) {
   return g_once_init_enter_impl(value_location);
}


// 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.
// <value_location>: location of a static initializable variable containing 0.
// <initialization_value>: new non-0 value for *@value_location.
static void once_init_leave(size_t* value_location, size_t initialization_value) {
   g_once_init_leave(value_location, initialization_value);
}

static Quark option_error_quark() {
   return g_option_error_quark();
}


// 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.  If @string
// is equal to "help", all the available keys in @keys are printed
// out to standard error.
// RETURNS: the combined set of bit flags.
// <string>: a list of debug options separated by colons, spaces, or commas, or %NULL.
// <keys>: pointer to an array of #GDebugKey which associate strings with bit flags.
// <nkeys>: the number of #GDebugKey<!-- -->s in the array.
static uint parse_debug_string(char* string_, DebugKey* keys, uint nkeys) {
   return g_parse_debug_string(string_, keys, nkeys);
}


// Gets the last component of the filename. If @file_name ends with a
// directory separator it gets the component before the last slash. If
// @file_name consists only of directory separators (and on Windows,
// possibly a drive letter), a single separator is returned. If
// @file_name is empty, it gets ".".
// 
// the filename.
// RETURNS: a newly allocated string containing the last component of
// <file_name>: the name of the file.
static char* /*new*/ path_get_basename(char* file_name) {
   return g_path_get_basename(file_name);
}


// Gets the directory components of a file name.  If the file name has no
// directory components "." is returned.  The returned string should be
// freed when no longer needed.
// RETURNS: the directory components of the file.
// <file_name>: the name of the file.
static char* /*new*/ path_get_dirname(char* file_name) {
   return g_path_get_dirname(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.
// RETURNS: %TRUE if @file_name is absolute.
// <file_name>: a file name.
static int path_is_absolute(char* file_name) {
   return g_path_is_absolute(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.
// RETURNS: a pointer into @file_name after the root component.
// <file_name>: a file name.
static char* path_skip_root(char* file_name) {
   return g_path_skip_root(file_name);
}


// 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, as
// g_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 to g_pattern_match().
// 
// Note also that the reverse of a UTF-8 encoded string can in general
// <emphasis>not</emphasis> be obtained by g_strreverse(). This works
// only if the string doesn't contain any multibyte characters. GLib
// offers the g_utf8_strreverse() function to reverse UTF-8 encoded
// strings.
// <pspec>: a #GPatternSpec
// <string_length>: the length of @string (in bytes, i.e. strlen(), <emphasis>not</emphasis> g_utf8_strlen())
// <string>: the UTF-8 encoded string to match
// <string_reversed>: the reverse of @string or %NULL
static int pattern_match(PatternSpec* pspec, uint string_length, char* string_, char* string_reversed) {
   return g_pattern_match(pspec, string_length, string_, string_reversed);
}


// Matches a string against a pattern given as a string. If this
// function is to be called in a loop, it's more efficient to compile
// the pattern once with g_pattern_spec_new() and call
// g_pattern_match_string() repeatedly.
// <pattern>: the UTF-8 encoded pattern
// <string>: the UTF-8 encoded string to match
static int pattern_match_simple(char* pattern, char* string_) {
   return g_pattern_match_simple(pattern, string_);
}


// Matches a string against a compiled pattern. If the string is to be
// matched against more than one pattern, consider using
// g_pattern_match() instead while supplying the reversed string.
// <pspec>: a #GPatternSpec
// <string>: the UTF-8 encoded string to match
static int pattern_match_string(PatternSpec* pspec, char* string_) {
   return g_pattern_match_string(pspec, string_);
}


// 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>: a pointer to a #gpointer-sized value
// <lock_bit>: a bit value between 0 and 31
static void pointer_bit_lock(void* address, int lock_bit) {
   g_pointer_bit_lock(address, 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.
// RETURNS: %TRUE if the lock was acquired
// <address>: a pointer to a #gpointer-sized value
// <lock_bit>: a bit value between 0 and 31
static int pointer_bit_trylock(void* address, int lock_bit) {
   return g_pointer_bit_trylock(address, 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.
// <address>: a pointer to a #gpointer-sized value
// <lock_bit>: a bit value between 0 and 31
static void pointer_bit_unlock(void* address, int lock_bit) {
   g_pointer_bit_unlock(address, lock_bit);
}


// Polls @fds, as with the poll() system call, but portably. (On
// systems that don't have poll(), it is emulated using select().)
// This is used internally by #GMainContext, but it can be called
// directly if you need to block until a file descriptor is ready, but
// don't want to run the full main loop.
// 
// Each element of @fds is a #GPollFD describing a single file
// descriptor to poll. The %fd field indicates the file descriptor,
// and the %events field indicates the events to poll for. On return,
// the %revents fields will be filled with the events that actually
// occurred.
// 
// On POSIX systems, the file descriptors in @fds can be any sort of
// file descriptor, but the situation is much more complicated on
// Windows. If you need to use g_poll() in code that has to run on
// Windows, the easiest solution is to construct all of your
// #GPollFD<!-- -->s with g_io_channel_win32_make_pollfd().
// 
// were filled in, or 0 if the operation timed out, or -1 on error or
// if the call was interrupted.
// RETURNS: the number of entries in @fds whose %revents fields
// <fds>: file descriptors to poll
// <nfds>: the number of file descriptors in @fds
// <timeout>: amount of time to wait, in milliseconds, or -1 to wait forever
static int poll(PollFD* fds, uint nfds, int timeout) {
   return g_poll(fds, nfds, timeout);
}


// Unintrospectable function: prefix_error() / g_prefix_error()
// Formats a string according to @format and
// prefix it to an existing error message.  If
// nothing.
// 
// If *@err is %NULL (ie: an error variable is
// present but there is no error condition) then
// also do nothing.  Whether or not it makes
// sense to take advantage of this feature is up
// to you.
// <err>: a return location for a #GError, or %NULL
// <format>: printf()-style format string
alias g_prefix_error prefix_error; // Variadic


// Unintrospectable function: print() / g_print()
// Outputs a formatted message via the print handler.
// The default print handler simply outputs the message to stdout.
// 
// g_print() should not be used from within libraries for debugging
// messages, since it may be redirected by applications to special
// purpose message windows or even files. Instead, libraries should
// use g_log(), or the convenience functions g_message(), g_warning()
// and g_error().
// <format>: the message format. See the printf() documentation
alias g_print print; // Variadic


// Unintrospectable function: printerr() / g_printerr()
// Outputs a formatted message via the error message handler.
// The default handler simply outputs the message to stderr.
// 
// g_printerr() should not be used from within libraries.
// Instead g_log() should be used, or the convenience functions
// g_message(), g_warning() and g_error().
// <format>: the message format. See the printf() documentation
alias g_printerr printerr; // Variadic


// Unintrospectable function: printf() / g_printf()
// An implementation of the standard printf() function which supports
// positional parameters, as specified in the Single Unix Specification.
// RETURNS: the number of bytes printed.
// <format>: a standard printf() format string, but notice <link linkend="string-precision">string precision pitfalls</link>.
alias g_printf printf; // Variadic

// Unintrospectable function: printf_string_upper_bound() / g_printf_string_upper_bound()
static size_t printf_string_upper_bound(char* format, va_list args) {
   return g_printf_string_upper_bound(format, args);
}


// If @dest is %NULL, free @src; otherwise, moves @src into *@dest.
// The error variable @dest points to must be %NULL.
// <dest>: error return location
// <src>: error to move into the return location
static void propagate_error(Error** dest, Error* src) {
   g_propagate_error(dest, src);
}


// Unintrospectable function: propagate_prefixed_error() / g_propagate_prefixed_error()
// If @dest is %NULL, free @src; otherwise,
// moves @src into *@dest. *@dest must be %NULL.
// After the move, add a prefix as with
// g_prefix_error().
// <dest>: error return location
// <src>: error to move into the return location
// <format>: printf()-style format string
alias g_propagate_prefixed_error propagate_prefixed_error; // Variadic


// Adds a pointer to the end of the pointer array. The array will grow
// in size automatically if necessary.
// <array>: a #GPtrArray.
// <data>: the pointer to add.
static void ptr_array_add(PtrArray* array, void* data) {
   g_ptr_array_add(array, data);
}


// Removes the first occurrence of the given pointer from the pointer
// array. The following elements are moved down one place. If @array
// has a non-%NULL #GDestroyNotify function it is called for the
// removed element.
// 
// It returns %TRUE if the pointer was removed, or %FALSE if the
// pointer was not found.
// <array>: a #GPtrArray.
// <data>: the pointer to remove.
static int ptr_array_remove(PtrArray* array, void* data) {
   return g_ptr_array_remove(array, data);
}


// Removes the first occurrence of the given pointer from the pointer
// array. The last element in the array is used to fill in the space,
// so this function does not preserve the order of the array. But it is
// faster than g_ptr_array_remove(). If @array has a non-%NULL
// #GDestroyNotify function it is called for the removed element.
// 
// It returns %TRUE if the pointer was removed, or %FALSE if the
// pointer was not found.
// <array>: a #GPtrArray.
// <data>: the pointer to remove.
static int ptr_array_remove_fast(PtrArray* array, void* data) {
   return g_ptr_array_remove_fast(array, data);
}


// Removes the given number of pointers starting at the given index
// from a #GPtrArray.  The following elements are moved to close the
// gap. If @array has a non-%NULL #GDestroyNotify function it is called
// for the removed elements.
// <array>: a @GPtrArray.
// <index_>: the index of the first pointer to remove.
// <length>: the number of pointers to remove.
static void ptr_array_remove_range(PtrArray* array, uint index_, uint length) {
   g_ptr_array_remove_range(array, index_, length);
}


// Sets a function for freeing each element when @array is destroyed
// either via g_ptr_array_unref(), when g_ptr_array_free() is called
// with @free_segment set to %TRUE or when removing elements.
// <array>: A #GPtrArray.
// <element_free_func>: A function to free elements with destroy @array or %NULL.
static void ptr_array_set_free_func(PtrArray* array, DestroyNotify element_free_func) {
   g_ptr_array_set_free_func(array, element_free_func);
}


// Sets the size of the array. When making the array larger,
// newly-added elements will be set to %NULL. When making it smaller,
// if @array has a non-%NULL #GDestroyNotify function then it will be
// called for the removed elements.
// <array>: a #GPtrArray.
// <length>: the new length of the pointer array.
static void ptr_array_set_size(PtrArray* array, int length) {
   g_ptr_array_set_size(array, length);
}


// Atomically decrements the reference count of @array by one. If the
// reference count drops to 0, the effect is the same as calling
// g_ptr_array_free() with @free_segment set to %TRUE. This function
// is MT-safe and may be called from any thread.
// <array>: A #GPtrArray.
static void ptr_array_unref(PtrArray* array) {
   g_ptr_array_unref(array);
}


// Unintrospectable function: qsort_with_data() / g_qsort_with_data()
// This is just like the standard C qsort() function, but
// the comparison routine accepts a user data argument.
// <pbase>: start of array to sort
// <total_elems>: elements in the array
// <size>: size of each element
// <compare_func>: function to compare elements
// <user_data>: data to pass to @compare_func
static void qsort_with_data(const(void)* pbase, int total_elems, size_t size, CompareDataFunc compare_func, void* user_data) {
   g_qsort_with_data(pbase, total_elems, size, compare_func, user_data);
}


// Gets the #GQuark identifying the given (static) string. If the
// string does not currently have an associated #GQuark, a new #GQuark
// is created, linked to the given string.
// 
// Note that this function is identical to g_quark_from_string() except
// that if a new #GQuark is created the string itself is used rather
// than a copy. This saves memory, but can only be used if the string
// will <emphasis>always</emphasis> exist. It can be used with
// statically allocated strings in the main program, but not with
// statically allocated memory in dynamically loaded modules, if you
// expect to ever unload the module again (e.g. do not use this
// function in GTK+ theme engines).
// <string>: a string.
static Quark quark_from_static_string(char* string_=null) {
   return g_quark_from_static_string(string_);
}


// Gets the #GQuark identifying the given string. If the string does
// not currently have an associated #GQuark, a new #GQuark is created,
// using a copy of the string.
// <string>: a string.
static Quark quark_from_string(char* string_=null) {
   return g_quark_from_string(string_);
}


// Gets the string associated with the given #GQuark.
// <quark>: a #GQuark.
static char* quark_to_string(Quark quark) {
   return g_quark_to_string(quark);
}


// Gets the #GQuark associated with the given string, or 0 if string is
// %NULL or it has no associated #GQuark.
// 
// If you want the GQuark to be created if it doesn't already exist,
// use g_quark_from_string() or g_quark_from_static_string().
// <string>: a string.
static Quark quark_try_string(char* string_=null) {
   return g_quark_try_string(string_);
}


// Returns a random #gdouble equally distributed over the range [0..1).
// RETURNS: A random number.
static double random_double() {
   return g_random_double();
}


// Returns a random #gdouble equally distributed over the range [@begin..@end).
// RETURNS: A random number.
// <begin>: lower closed bound of the interval.
// <end>: upper open bound of the interval.
static double random_double_range(double begin, double end) {
   return g_random_double_range(begin, end);
}


// Return a random #guint32 equally distributed over the range
// [0..2^32-1].
// RETURNS: A random number.
static uint random_int() {
   return g_random_int();
}


// Returns a random #gint32 equally distributed over the range
// [@begin..@end-1].
// RETURNS: A random number.
// <begin>: lower closed bound of the interval.
// <end>: upper open bound of the interval.
static int random_int_range(int begin, int end) {
   return g_random_int_range(begin, end);
}


// Sets the seed for the global random number generator, which is used
// by the <function>g_random_*</function> functions, to @seed.
// <seed>: a value to reinitialize the global random number generator.
static void random_set_seed(uint seed) {
   g_random_set_seed(seed);
}


// Unintrospectable function: realloc() / g_realloc()
// Reallocates the memory pointed to by @mem, so that it now has space for
// @n_bytes bytes of memory. It returns the new address of the memory, which may
// have been moved. @mem may be %NULL, in which case it's considered to
// have zero-length. @n_bytes may be 0, in which case %NULL will be returned
// and @mem will be freed unless it is %NULL.
// RETURNS: the new address of the allocated memory
// <mem>: the memory to reallocate
// <n_bytes>: new size of the memory in bytes
static void* realloc(void* mem, size_t n_bytes) {
   return g_realloc(mem, n_bytes);
}


// Unintrospectable function: realloc_n() / g_realloc_n()
// This function is similar to g_realloc(), allocating (@n_blocks * @n_block_bytes) bytes,
// but care is taken to detect possible overflow during multiplication.
// RETURNS: the new address of the allocated memory
// <mem>: the memory to reallocate
// <n_blocks>: the number of blocks to allocate
// <n_block_bytes>: the size of each block in bytes
static void* realloc_n(void* mem, size_t n_blocks, size_t n_block_bytes) {
   return g_realloc_n(mem, n_blocks, n_block_bytes);
}


// Checks whether @replacement is a valid replacement string
// (see g_regex_replace()), i.e. that all escape sequences in
// it are valid.
// 
// If @has_references is not %NULL then @replacement is checked
// for pattern references. For instance, replacement text 'foo\n'
// does not contain references and may be evaluated without information
// about actual match, but '\0\1' (whole match followed by first
// subpattern) requires valid #GMatchInfo object.
// RETURNS: whether @replacement is a valid replacement string
// <replacement>: the replacement string
// <has_references>: location to store information about references in @replacement or %NULL
static int regex_check_replacement(char* replacement, /*out*/ int* has_references, GLib2.Error** error=null) {
   return g_regex_check_replacement(replacement, has_references, error);
}

static Quark regex_error_quark() {
   return g_regex_error_quark();
}


// 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.
// RETURNS: a newly-allocated escaped string
// <string>: the string to escape
// <length>: the length of @string
static char* /*new*/ regex_escape_nul(char* string_, int length) {
   return g_regex_escape_nul(string_, 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.
// RETURNS: a newly-allocated escaped string
// <string>: the string to escape
// <length>: the length of @string, or -1 if @string is nul-terminated
static char* /*new*/ regex_escape_string(char* string_, int length) {
   return g_regex_escape_string(string_, length);
}


// 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().
// RETURNS: %TRUE if the string matched, %FALSE otherwise
// <pattern>: the regular expression
// <string>: the string to scan for matches
// <compile_options>: compile options for the regular expression, or 0
// <match_options>: match options, or 0
static int regex_match_simple(char* pattern, char* string_, RegexCompileFlags compile_options, RegexMatchFlags match_options) {
   return g_regex_match_simple(pattern, string_, compile_options, match_options);
}


// 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 threadsafety 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.
static void reload_user_special_dirs_cache() {
   g_reload_user_special_dirs_cache();
}

static void return_if_fail_warning(char* log_domain, char* pretty_function, char* expression) {
   g_return_if_fail_warning(log_domain, pretty_function, expression);
}


// 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.
// 
// occurred
// RETURNS: 0 if the directory was successfully removed, -1 if an error
// <filename>: a pathname in the GLib file name encoding (UTF-8 on Windows)
static int rmdir(char* filename) {
   return g_rmdir(filename);
}


// 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>: a #GSequenceIter pointing to the item to move
// <dest>: a #GSequenceIter pointing to the position to which the item is moved.
static void sequence_move(SequenceIter* src, SequenceIter* dest) {
   g_sequence_move(src, dest);
}


// Inserts the (@begin, @end) range at the destination pointed to by ptr.
// 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 iter points to a place within
// the (@begin, @end) range, the range does not move.
// <dest>: a #GSequenceIter
// <begin>: a #GSequenceIter
// <end>: a #GSequenceIter
static void sequence_move_range(SequenceIter* dest, SequenceIter* begin, SequenceIter* end) {
   g_sequence_move_range(dest, begin, end);
}


// Removes the item pointed to by @iter. It is an error to pass the
// end iterator to this function.
// 
// If the sequnce has a data destroy function associated with it, this
// function is called on the data for the removed item.
// <iter>: a #GSequenceIter
static void sequence_remove(SequenceIter* iter) {
   g_sequence_remove(iter);
}


// 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>: a #GSequenceIter
// <end>: a #GSequenceIter
static void sequence_remove_range(SequenceIter* begin, SequenceIter* end) {
   g_sequence_remove_range(begin, end);
}


// 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>: a #GSequenceIter
// <data>: new data for the item
static void sequence_set(SequenceIter* iter, void* data) {
   g_sequence_set(iter, data);
}


// Swaps the items pointed to by @a and @b. It is allowed for @a and @b
// to point into difference sequences.
// <a>: a #GSequenceIter
// <b>: a #GSequenceIter
static void sequence_swap(SequenceIter* a, SequenceIter* b) {
   g_sequence_swap(a, b);
}


// 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>: localized name of the application
static void set_application_name(char* application_name) {
   g_set_application_name(application_name);
}


// Unintrospectable function: set_error() / g_set_error()
// Does nothing if @err is %NULL; if @err is non-%NULL, then *@err
// must be %NULL. A new #GError is created and assigned to *@err.
// <err>: a return location for a #GError, or %NULL
// <domain>: error domain
// <code>: error code
// <format>: printf()-style format
alias g_set_error set_error; // Variadic


// Does nothing if @err is %NULL; if @err is non-%NULL, then *@err
// must be %NULL. A new #GError is created and assigned to *@err.
// Unlike g_set_error(), @message is not a printf()-style format string.
// Use this function if @message contains text you don't have control over,
// that could include printf() escape sequences.
// <err>: a return location for a #GError, or %NULL
// <domain>: error domain
// <code>: error code
// <message>: error message
static void set_error_literal(Error** err, Quark domain, int code, char* message) {
   g_set_error_literal(err, domain, code, message);
}


// Sets the name of the program. This name should <emphasis>not</emphasis>
// be localized, contrast with g_set_application_name(). Note that for
// thread-safety reasons this function can only be called once.
// <prgname>: the name of the program.
static void set_prgname(char* prgname) {
   g_set_prgname(prgname);
}


// Unintrospectable function: set_print_handler() / g_set_print_handler()
// Sets the print handler.
// 
// Any messages passed to g_print() will be output via
// the new handler. The default handler simply outputs
// the message to stdout. By providing your own handler
// you can redirect the output, to a GTK+ widget or a
// log file for example.
// RETURNS: the old print handler
// <func>: the new print handler
static PrintFunc set_print_handler(PrintFunc func) {
   return g_set_print_handler(func);
}


// Unintrospectable function: set_printerr_handler() / g_set_printerr_handler()
// Sets the handler for printing error messages.
// 
// Any messages passed to g_printerr() will be output via
// the new handler. The default handler simply outputs the
// message to stderr. By providing your own handler you can
// redirect the output, to a GTK+ widget or a log file for
// example.
// RETURNS: the old error message handler
// <func>: the new error message handler
static PrintFunc set_printerr_handler(PrintFunc func) {
   return g_set_printerr_handler(func);
}


// Sets an environment variable. Both the variable's name and value
// should be in the GLib file name encoding. On UNIX, this means that
// they can be any sequence of bytes. 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.
// RETURNS: %FALSE if the environment variable couldn't be set.
// <variable>: the environment variable to set, must not contain '='.
// <value>: the value for to set the variable to.
// <overwrite>: whether to change the variable if it already exists.
static int setenv(char* variable, char* value, int overwrite) {
   return g_setenv(variable, value, overwrite);
}

static Quark shell_error_quark() {
   return g_shell_error_quark();
}


// 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. Free the returned vector with g_strfreev().
// RETURNS: %TRUE on success, %FALSE if error set
// <command_line>: command line to parse
// <argcp>: return location for number of args
// <argvp>: return location for array of args
static int shell_parse_argv(char* command_line, /*out*/ int* argcp, /*out*/ char*** argvp, GLib2.Error** error=null) {
   return g_shell_parse_argv(command_line, argcp, argvp, error);
}


// 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).
// RETURNS: quoted string
// <unquoted_string>: a literal string
static char* /*new*/ shell_quote(char* unquoted_string) {
   return g_shell_quote(unquoted_string);
}


// Unquotes a string as the shell (/bin/sh) would. 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.
// RETURNS: an unquoted string
// <quoted_string>: shell-quoted string
static char* /*new*/ shell_unquote(char* quoted_string, GLib2.Error** error=null) {
   return g_shell_unquote(quoted_string, error);
}

// Unintrospectable function: slice_alloc() / g_slice_alloc()
static void* slice_alloc(size_t block_size) {
   return g_slice_alloc(block_size);
}

// Unintrospectable function: slice_alloc0() / g_slice_alloc0()
static void* slice_alloc0(size_t block_size) {
   return g_slice_alloc0(block_size);
}

// Unintrospectable function: slice_copy() / g_slice_copy()
static void* slice_copy(size_t block_size, const(void)* mem_block) {
   return g_slice_copy(block_size, mem_block);
}

static void slice_free1(size_t block_size, void* mem_block) {
   g_slice_free1(block_size, mem_block);
}

static void slice_free_chain_with_offset(size_t block_size, void* mem_chain, size_t next_offset) {
   g_slice_free_chain_with_offset(block_size, mem_chain, next_offset);
}

static long slice_get_config(SliceConfig ckey) {
   return g_slice_get_config(ckey);
}

static long* slice_get_config_state(SliceConfig ckey, long address, uint* n_values) {
   return g_slice_get_config_state(ckey, address, n_values);
}

static void slice_set_config(SliceConfig ckey, long value) {
   g_slice_set_config(ckey, value);
}


// Restores the previous #GAllocator, used when allocating #GSList
// elements.
// 
// Note that this function is not available if GLib has been compiled
// with <option>--disable-mem-pools</option>
// 
// to the <link linkend="glib-Memory-Slices">slice
// allocator</link>
static void slist_pop_allocator() {
   g_slist_pop_allocator();
}


// Sets the allocator to use to allocate #GSList elements. Use
// g_slist_pop_allocator() to restore the previous allocator.
// 
// Note that this function is not available if GLib has been compiled
// with <option>--disable-mem-pools</option>
// 
// to the <link linkend="glib-Memory-Slices">slice
// allocator</link>
// <dummy>: the #GAllocator to use when allocating #GSList elements.
static void slist_push_allocator(void* dummy) {
   g_slist_push_allocator(dummy);
}


// Unintrospectable function: snprintf() / g_snprintf()
// A safer form of the standard sprintf() function. The output is guaranteed
// to not exceed @n characters (including the terminating nul character), so
// it is easy to ensure that a buffer overflow cannot occur.
// 
// See also g_strdup_printf().
// 
// In versions of GLib prior to 1.2.3, this function may return -1 if the
// output was truncated, and the truncated string may not be nul-terminated.
// In versions prior to 1.3.12, this function returns the length of the output
// string.
// 
// The return value of g_snprintf() conforms to the snprintf()
// function as standardized in ISO C99. Note that this is different from
// traditional snprintf(), which returns the length of the output string.
// 
// The format string may contain positional parameters, as specified in
// the Single Unix Specification.
// 
// was large enough.
// RETURNS: the number of bytes which would be produced if the buffer
// <string>: the buffer to hold the output.
// <n>: the maximum number of bytes to produce (including the terminating nul character).
// <format>: a standard printf() format string, but notice <link linkend="string-precision">string precision pitfalls</link>.
alias g_snprintf snprintf; // Variadic


// Removes the source with the given id from the default main context.
// The id of
// a #GSource is given by g_source_get_id(), or will be returned by the
// functions g_source_attach(), g_idle_add(), g_idle_add_full(),
// g_timeout_add(), g_timeout_add_full(), g_child_watch_add(),
// g_child_watch_add_full(), g_io_add_watch(), and g_io_add_watch_full().
// 
// See also g_source_destroy(). You must use g_source_destroy() for sources
// added to a non-default main context.
// RETURNS: %TRUE if the source was found and removed.
// <tag>: the ID of the source to remove.
static int source_remove(uint tag) {
   return g_source_remove(tag);
}


// 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.
// RETURNS: %TRUE if a source was found and removed.
// <funcs>: The @source_funcs passed to g_source_new()
// <user_data>: the user data for the callback
static int source_remove_by_funcs_user_data(SourceFuncs* funcs, void* user_data) {
   return g_source_remove_by_funcs_user_data(funcs, 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.
// RETURNS: %TRUE if a source was found and removed.
// <user_data>: the user_data for the callback.
static int source_remove_by_user_data(void* user_data) {
   return g_source_remove_by_user_data(user_data);
}


// Sets the name of a source using its ID.
// 
// This is a convenience utility to set source names from the return
// value of g_idle_add(), g_timeout_add(), etc.
// <tag>: a #GSource ID
// <name>: debug name for the source
static void source_set_name_by_id(uint tag, char* name) {
   g_source_set_name_by_id(tag, name);
}


// 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.
// 
// which is larger than @num
// RETURNS: the smallest prime number from a built-in array of primes
// <num>: a #guint
static uint spaced_primes_closest(uint num) {
   return g_spaced_primes_closest(num);
}


// See g_spawn_async_with_pipes() for a full description; this function
// simply calls the g_spawn_async_with_pipes() without any pipes.
// 
// You should call g_spawn_close_pid() on the returned child process
// reference when you don't need it any more.
// 
// <note><para>
// If you are writing a GTK+ application, and the program you
// are spawning is a graphical application, too, then you may
// want to use gdk_spawn_on_screen() instead to ensure that
// the spawned program opens its windows on the right screen.
// </para></note>
// 
// <note><para> 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.
// </para></note>
// RETURNS: %TRUE on success, %FALSE if error is set
// <working_directory>: child's current working directory, or %NULL to inherit parent's
// <argv>: child's argument vector
// <envp>: child's environment, or %NULL to inherit parent's
// <flags>: flags from #GSpawnFlags
// <child_setup>: function to run in the child just before exec()
// <user_data>: user data for @child_setup
// <child_pid>: return location for child process reference, or %NULL
static int spawn_async(char* working_directory, char** argv, char** envp, SpawnFlags flags, SpawnChildSetupFunc child_setup, void* user_data, /*out*/ Pid* child_pid, GLib2.Error** error=null) {
   return g_spawn_async(working_directory, argv, envp, flags, child_setup, user_data, child_pid, error);
}


// 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; the <envar>PATH</envar> shell variable
// will only be searched if you pass the %G_SPAWN_SEARCH_PATH flag.
// 
// On Windows, note that all the string or string vector arguments to
// this function and the other g_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 a wmain() instead of
// main(). wmain() has a wide character argument vector as parameter.
// 
// At least currently, mingw doesn't support wmain(), so if you use
// mingw to develop the spawned program, it will have to call the
// undocumented function __wgetmainargs() to get the wide character
// argument vector and environment. See gspawn-win32-helper.c in the
// GLib sources or init.c in the mingw runtime sources for a prototype
// for that function. Alternatively, you can retrieve the Win32 system
// level wide character command line passed to the spawned program
// using the GetCommandLineW() function.
// 
// On Windows the low-level child process creation API
// <function>CreateProcess()</function> doesn't use argument vectors,
// but a command line. The C runtime library's
// <function>spawn*()</function> 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 to main(). Complications arise when you have
// argument vector elements that contain spaces of double quotes. The
// <function>spawn*()</function> 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 runtime
// spawn() 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 form <literal>KEY=VALUE</literal>. 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
// #GChildWatch source to be notified about the death of the child
// process. 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 #GChildWatch source is
// equivalent to calling waitpid() or handling the %SIGCHLD signal
// manually. On Windows, calling g_spawn_close_pid() is equivalent
// to calling CloseHandle() on the process handle returned in
// @child_pid).
// 
// %G_SPAWN_LEAVE_DESCRIPTORS_OPEN means that the parent's open file
// descriptors will be inherited by the child; otherwise all
// descriptors except stdin/stdout/stderr will be closed before
// calling exec() in the child. %G_SPAWN_SEARCH_PATH
// means that <literal>argv[0]</literal> need not be an absolute path, it
// will be looked for in the user's <envar>PATH</envar>.
// %G_SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output will
// be discarded, instead of going to the same location as the parent's
// standard output. If you use this flag, @standard_output must be %NULL.
// %G_SPAWN_STDERR_TO_DEV_NULL means that the child's standard error
// will be discarded, instead of going to the same location as the parent's
// standard error. If you use this flag, @standard_error must be %NULL.
// %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). If you use this flag, @standard_input must be %NULL.
// %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() uses @argv[0] as the file to execute, and
// passes all of @argv to the child.
// 
// @child_setup 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 <function>WaitFor*()</function> 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 @standard_input, @standard_output, @standard_error
// 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 @standard_input is NULL, the child's standard input is attached to
// /dev/null unless %G_SPAWN_CHILD_INHERITS_STDIN is set.
// 
// If @standard_error 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 @standard_output 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 <literal>argv[0]</literal> is not found). Typically
// the <literal>message</literal> 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, @standard_input, @standard_output,
// and @standard_error will 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().
// 
// <note><para>
// If you are writing a GTK+ application, and the program you
// are spawning is a graphical application, too, then you may
// want to use gdk_spawn_on_screen_with_pipes() instead to ensure that
// the spawned program opens its windows on the right screen.
// </para></note>
// RETURNS: %TRUE on success, %FALSE if an error was set
// <working_directory>: child's current working directory, or %NULL to inherit parent's, in the GLib file name encoding
// <argv>: child's argument vector, in the GLib file name encoding
// <envp>: child's environment, or %NULL to inherit parent's, in the GLib file name encoding
// <flags>: flags from #GSpawnFlags
// <child_setup>: function to run in the child just before exec()
// <user_data>: user data for @child_setup
// <child_pid>: return location for child process ID, or %NULL
// <standard_input>: return location for file descriptor to write to child's stdin, or %NULL
// <standard_output>: return location for file descriptor to read child's stdout, or %NULL
// <standard_error>: return location for file descriptor to read child's stderr, or %NULL
static int spawn_async_with_pipes(char* working_directory, char** argv, char** envp, SpawnFlags flags, SpawnChildSetupFunc child_setup, void* user_data, /*out*/ Pid* child_pid, /*out*/ int* standard_input, /*out*/ int* standard_output, /*out*/ int* standard_error, GLib2.Error** error=null) {
   return g_spawn_async_with_pipes(working_directory, argv, envp, flags, child_setup, user_data, child_pid, standard_input, standard_output, standard_error, error);
}


// On some platforms, notably Windows, the #GPid type represents a resource
// which must be closed to prevent resource leaking. g_spawn_close_pid()
// is provided for this purpose. It should be used on all platforms, even
// though it doesn't do anything under UNIX.
// <pid>: The process reference to close
static void spawn_close_pid(Pid pid) {
   g_spawn_close_pid(pid);
}


// 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().
// RETURNS: %TRUE on success, %FALSE if error is set.
// <command_line>: a command line
static int spawn_command_line_async(char* command_line, GLib2.Error** error=null) {
   return g_spawn_command_line_async(command_line, error);
}


// A simple version of g_spawn_sync() with little-used parameters
// removed, taking a command line instead of an argument vector.  See
// g_spawn_sync() for full details. @command_line will be parsed by
// g_shell_parse_argv(). Unlike g_spawn_sync(), the %G_SPAWN_SEARCH_PATH flag
// is enabled. Note that %G_SPAWN_SEARCH_PATH can have security
// implications, so consider using g_spawn_sync() directly if
// appropriate. Possible errors are those from g_spawn_sync() and those
// from g_shell_parse_argv().
// 
// If @exit_status is non-%NULL, the exit status of the child is stored there as
// it would be returned by waitpid(); standard UNIX macros such as WIFEXITED()
// and WEXITSTATUS() must be used to evaluate the exit status.
// 
// On Windows, please note the implications of g_shell_parse_argv()
// parsing @command_line. Parsing is done according to Unix shell rules, not
// Windows command interpreter rules.
// Space is a separator, and backslashes are
// special. Thus you cannot simply pass a @command_line containing
// canonical Windows paths, like "c:\\program files\\app\\app.exe", as
// the backslashes will be eaten, and the space will act as a
// separator. You need to enclose such paths with single quotes, like
// "'c:\\program files\\app\\app.exe' 'e:\\folder\\argument.txt'".
// RETURNS: %TRUE on success, %FALSE if an error was set
// <command_line>: a command line
// <standard_output>: return location for child output
// <standard_error>: return location for child errors
// <exit_status>: return location for child exit status, as returned by waitpid()
static int spawn_command_line_sync(char* command_line, /*out*/ ubyte** standard_output, /*out*/ ubyte** standard_error, /*out*/ int* exit_status, GLib2.Error** error=null) {
   return g_spawn_command_line_sync(command_line, standard_output, standard_error, exit_status, error);
}

static Quark spawn_error_quark() {
   return g_spawn_error_quark();
}


// Executes a child synchronously (waits for the child to exit before returning).
// All output from the child is stored in @standard_output and @standard_error,
// if those parameters are non-%NULL. Note that you must set the
// %G_SPAWN_STDOUT_TO_DEV_NULL and %G_SPAWN_STDERR_TO_DEV_NULL flags when
// passing %NULL for @standard_output and @standard_error.
// If @exit_status is non-%NULL, the exit status of the child is stored
// there as it would be returned by waitpid(); standard UNIX macros such
// as WIFEXITED() and WEXITSTATUS() must be used to evaluate the exit status.
// Note that this function call waitpid() even if @exit_status is %NULL, and
// does not accept the %G_SPAWN_DO_NOT_REAP_CHILD flag.
// If an error occurs, no data is returned in @standard_output,
// @standard_error, or @exit_status.
// 
// This function calls g_spawn_async_with_pipes() internally; see that
// function for full details on the other parameters and details on
// how these functions work on Windows.
// RETURNS: %TRUE on success, %FALSE if an error was set.
// <working_directory>: child's current working directory, or %NULL to inherit parent's
// <argv>: child's argument vector
// <envp>: child's environment, or %NULL to inherit parent's
// <flags>: flags from #GSpawnFlags
// <child_setup>: function to run in the child just before exec()
// <user_data>: user data for @child_setup
// <standard_output>: return location for child output, or %NULL
// <standard_error>: return location for child error messages, or %NULL
// <exit_status>: return location for child exit status, as returned by waitpid(), or %NULL
static int spawn_sync(char* working_directory, char** argv, char** envp, SpawnFlags flags, SpawnChildSetupFunc child_setup, void* user_data, /*out*/ ubyte** standard_output, /*out*/ ubyte** standard_error, /*out*/ int* exit_status, GLib2.Error** error=null) {
   return g_spawn_sync(working_directory, argv, envp, flags, child_setup, user_data, standard_output, standard_error, exit_status, error);
}


// Unintrospectable function: sprintf() / g_sprintf()
// An implementation of the standard sprintf() function which supports
// positional parameters, as specified in the Single Unix Specification.
// 
// Note that it is usually better to use g_snprintf(), to avoid the
// risk of buffer overflow.
// 
// See also g_strdup_printf().
// RETURNS: the number of bytes printed.
// <string>: A pointer to a memory buffer to contain the resulting string. It is up to the caller to ensure that the allocated buffer is large enough to hold the formatted result
// <format>: a standard printf() format string, but notice <link linkend="string-precision">string precision pitfalls</link>.
alias g_sprintf sprintf; // Variadic


// Copies a nul-terminated string into the dest buffer, include the
// trailing nul, and return a pointer to the trailing nul byte.
// This is useful for concatenating multiple strings together
// without having to repeatedly scan for the end.
// RETURNS: a pointer to trailing nul byte.
// <dest>: destination buffer.
// <src>: source string.
static char* /*new*/ stpcpy(char* dest, char* src) {
   return g_stpcpy(dest, src);
}


// 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 strings as keys in a #GHashTable.
// 
// Note that this function is primarily meant as a hash table comparison
// function. For a general-purpose, %NULL-safe string comparison function,
// see g_strcmp0().
// RETURNS: %TRUE if the two keys match
// <v1>: a key
// <v2>: a key to compare with @v1
static int str_equal(const(void)* v1, const(void)* v2) {
   return g_str_equal(v1, v2);
}


// Looks whether the string @str begins with @prefix.
// RETURNS: %TRUE if @str begins with @prefix, %FALSE otherwise.
// <str>: a nul-terminated string.
// <prefix>: the nul-terminated prefix to look for.
static int str_has_prefix(char* str, char* prefix) {
   return g_str_has_prefix(str, prefix);
}


// Looks whether the string @str ends with @suffix.
// RETURNS: %TRUE if @str end with @suffix, %FALSE otherwise.
// <str>: a nul-terminated string.
// <suffix>: the nul-terminated suffix to look for.
static int str_has_suffix(char* str, char* suffix) {
   return g_str_has_suffix(str, suffix);
}


// 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: <literal>hash = hash * 33 + c</literal>.  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 strings as keys in a #GHashTable.
// RETURNS: a hash value corresponding to the key
// <v>: a string key
static uint str_hash(const(void)* v) {
   return g_str_hash(v);
}

static char* /*new*/ strcanon(char* string_, char* valid_chars, char substitutor) {
   return g_strcanon(string_, valid_chars, substitutor);
}


// A case-insensitive string comparison, corresponding to the standard
// strcasecmp() function on platforms which support it.
// 
// or a positive value if @s1 &gt; @s2.
// 
// Deprecated:2.2: See g_strncasecmp() for a discussion of why this function
// is deprecated and how to replace it.
// RETURNS: 0 if the strings match, a negative value if @s1 &lt; @s2,
// <s1>: a string.
// <s2>: a string to compare with @s1.
static int strcasecmp(char* s1, char* s2) {
   return g_strcasecmp(s1, s2);
}

static char* /*new*/ strchomp(char* string_) {
   return g_strchomp(string_);
}

static char* /*new*/ strchug(char* string_) {
   return g_strchug(string_);
}


// Compares @str1 and @str2 like strcmp(). Handles %NULL
// gracefully by sorting it before non-%NULL strings.
// Comparing two %NULL pointers returns 0.
// RETURNS: -1, 0 or 1, if @str1 is <, == or > than @str2.
// <str1>: a C string or %NULL
// <str2>: another C string or %NULL
static int strcmp0(char* str1, char* str2) {
   return g_strcmp0(str1, str2);
}

static char* /*new*/ strcompress(char* source) {
   return g_strcompress(source);
}


// Unintrospectable function: strconcat() / g_strconcat()
// Concatenates all of the given strings into one long string.
// The returned string should be freed with g_free() when no longer needed.
// 
// 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.
// 
// <warning><para>The variable argument list <emphasis>must</emphasis> end
// with %NULL. If you forget the %NULL, g_strconcat() will start appending
// random memory junk to your string.</para></warning>
// RETURNS: a newly-allocated string containing all the string arguments
// <string1>: the first string to add, which must not be %NULL
alias g_strconcat strconcat; // Variadic

static char* /*new*/ strdelimit(char* string_, char* delimiters, char new_delimiter) {
   return g_strdelimit(string_, delimiters, new_delimiter);
}


// Converts a string to lower case.
// 
// 
// Deprecated:2.2: This function is totally broken for the reasons discussed
// in the g_strncasecmp() docs - use g_ascii_strdown() or g_utf8_strdown()
// instead.
// RETURNS: the string
// <string>: the string to convert.
static char* /*new*/ strdown(char* string_) {
   return g_strdown(string_);
}


// Duplicates a string. If @str is %NULL it returns %NULL.
// The returned string should be freed with g_free()
// when no longer needed.
// RETURNS: a newly-allocated copy of @str
// <str>: the string to duplicate
static char* /*new*/ strdup(char* str) {
   return g_strdup(str);
}


// Unintrospectable function: strdup_printf() / g_strdup_printf()
// Similar to the standard C sprintf() function but safer, since it
// calculates the maximum space required and allocates memory to hold
// the result. The returned string should be freed with g_free() when no
// longer needed.
// RETURNS: a newly-allocated string holding the result
// <format>: a standard printf() format string, but notice <link linkend="string-precision">string precision pitfalls</link>
alias g_strdup_printf strdup_printf; // Variadic


// Unintrospectable function: strdup_vprintf() / g_strdup_vprintf()
// Similar to the standard C vsprintf() function but safer, since it
// calculates the maximum space required and allocates memory to hold
// the result. The returned string should be freed with g_free() when
// no longer needed.
// 
// See also g_vasprintf(), which offers the same functionality, but
// additionally returns the length of the allocated string.
// RETURNS: a newly-allocated string holding the result
// <format>: a standard printf() format string, but notice <link linkend="string-precision">string precision pitfalls</link>
// <args>: the list of parameters to insert into the format string
static char* /*new*/ strdup_vprintf(char* format, va_list args) {
   return g_strdup_vprintf(format, args);
}


// Unintrospectable function: strdupv() / g_strdupv()
// Copies %NULL-terminated array of strings. The copy is a deep copy;
// the new array should be freed by first freeing each string, then
// the array itself. g_strfreev() does this for you. If called
// on a %NULL value, g_strdupv() simply returns %NULL.
// RETURNS: a new %NULL-terminated array of strings.
// <str_array>: %NULL-terminated array of strings.
static char** strdupv(char** str_array) {
   return g_strdupv(str_array);
}


// Returns a string corresponding to the given error code, e.g.
// "no such process". You should use this function in preference to
// strerror(), because it returns a string in UTF-8 encoding, and since
// not all platforms support the strerror() function.
// 
// is unknown, it returns "unknown error (&lt;code&gt;)". The string
// can only be used until the next call to g_strerror()
// RETURNS: a UTF-8 string describing the error code. If the error code
// <errnum>: the system error number. See the standard C %errno documentation
static char* strerror(int errnum) {
   return g_strerror(errnum);
}

static char* /*new*/ strescape(char* source, char* exceptions) {
   return g_strescape(source, exceptions);
}

// <str_array>: a %NULL-terminated array of strings to free. Frees a %NULL-terminated array of strings, and the array itself. If called on a %NULL value, g_strfreev() simply returns.
static void strfreev(char** str_array) {
   g_strfreev(str_array);
}


// Creates a new #GString, initialized with the given string.
// RETURNS: the new #GString
// <init>: the initial text to copy into the string
static String* /*new*/ string_new(char* init) {
   return g_string_new(init);
}


// Creates a new #GString with @len bytes of the @init buffer.
// Because a length is provided, @init need not be nul-terminated,
// and can contain embedded nul bytes.
// 
// Since this function does not stop at nul bytes, it is the caller's
// responsibility to ensure that @init has at least @len addressable
// bytes.
// RETURNS: a new #GString
// <init>: initial contents of the string
// <len>: length of @init to use
static String* /*new*/ string_new_len(char* init, ssize_t len) {
   return g_string_new_len(init, len);
}


// Creates a new #GString, with enough space for @dfl_size
// bytes. This is useful if you are going to add a lot of
// text to the string and don't want it to be reallocated
// too often.
// RETURNS: the new #GString
// <dfl_size>: the default size of the space allocated to hold the string
static String* /*new*/ string_sized_new(size_t dfl_size) {
   return g_string_sized_new(dfl_size);
}


// An auxiliary function for gettext() support (see Q_()).
// 
// a '|' character, in which case a pointer to the substring of msgid after
// the first '|' character is returned.
// RETURNS: @msgval, unless @msgval is identical to @msgid and contains
// <msgid>: a string
// <msgval>: another string
static char* strip_context(char* msgid, char* msgval) {
   return g_strip_context(msgid, msgval);
}


// Unintrospectable function: strjoin() / g_strjoin()
// Joins a number of strings together to form one long string, with the
// optional @separator inserted between each of them. The returned string
// should be freed with g_free().
// 
// together, with @separator between them
// RETURNS: a newly-allocated string containing all of the strings joined
// <separator>: a string to insert between each of the strings, or %NULL
alias g_strjoin strjoin; // Variadic


// Joins a number of strings together to form one long string, with the
// optional @separator inserted between each of them. The returned string
// should be freed with g_free().
// 
// together, with @separator between them
// RETURNS: a newly-allocated string containing all of the strings joined
// <separator>: a string to insert between each of the strings, or %NULL
// <str_array>: a %NULL-terminated array of strings to join
static char* /*new*/ strjoinv(char* separator, char** str_array) {
   return g_strjoinv(separator, str_array);
}


// Portability wrapper that calls strlcat() on systems which have it,
// and emulates it otherwise. Appends nul-terminated @src string to @dest,
// guaranteeing nul-termination for @dest. The total size of @dest won't
// exceed @dest_size.
// 
// At most dest_size - 1 characters will be copied.
// Unlike strncat, dest_size is the full size of dest, not the space left over.
// This function does NOT allocate memory.
// This always NUL terminates (unless siz == 0 or there were no NUL characters
// in the dest_size characters of dest to start with).
// 
// <note><para>Caveat: this is supposedly a more secure alternative to
// strcat() or strncat(), but for real security g_strconcat() is harder
// to mess up.</para></note>
// 
// (original dest)) + strlen (src), so if retval >= dest_size,
// truncation occurred.
// RETURNS: size of attempted result, which is MIN (dest_size, strlen
// <dest>: destination buffer, already containing one nul-terminated string
// <src>: source buffer
// <dest_size>: length of @dest buffer in bytes (not length of existing string inside @dest)
static size_t strlcat(char* dest, char* src, size_t dest_size) {
   return g_strlcat(dest, src, dest_size);
}


// Portability wrapper that calls strlcpy() on systems which have it,
// and emulates strlcpy() otherwise. Copies @src to @dest; @dest is
// guaranteed to be nul-terminated; @src must be nul-terminated;
// @dest_size is the buffer size, not the number of chars to copy.
// 
// At most dest_size - 1 characters will be copied. Always nul-terminates
// (unless dest_size == 0). This function does <emphasis>not</emphasis>
// allocate memory. Unlike strncpy(), this function doesn't pad dest (so
// it's often faster). It returns the size of the attempted result,
// strlen (src), so if @retval >= @dest_size, truncation occurred.
// 
// <note><para>Caveat: strlcpy() is supposedly more secure than
// strcpy() or strncpy(), but if you really want to avoid screwups,
// g_strdup() is an even better idea.</para></note>
// RETURNS: length of @src
// <dest>: destination buffer
// <src>: source buffer
// <dest_size>: length of @dest in bytes
static size_t strlcpy(char* dest, char* src, size_t dest_size) {
   return g_strlcpy(dest, src, dest_size);
}


// A case-insensitive string comparison, corresponding to the standard
// strncasecmp() function on platforms which support it.
// It is similar to g_strcasecmp() except it only compares the first @n
// characters of the strings.
// 
// or a positive value if @s1 &gt; @s2.
// 
// Deprecated:2.2: The problem with g_strncasecmp() is that it does the
// comparison by calling toupper()/tolower(). These functions are
// locale-specific and operate on single bytes. However, it is impossible
// to handle things correctly from an I18N standpoint by operating on
// bytes, since characters may be multibyte. Thus g_strncasecmp() is
// broken if your string is guaranteed to be ASCII, since it's
// locale-sensitive, and it's broken if your string is localized, since
// it doesn't work on many encodings at all, including UTF-8, EUC-JP,
// etc.
// 
// There are therefore two replacement functions: g_ascii_strncasecmp(),
// which only works on ASCII and is not locale-sensitive, and
// g_utf8_casefold(), which is good for case-insensitive sorting of UTF-8.
// RETURNS: 0 if the strings match, a negative value if @s1 &lt; @s2,
// <s1>: a string.
// <s2>: a string to compare with @s1.
// <n>: the maximum number of characters to compare.
static int strncasecmp(char* s1, char* s2, uint n) {
   return g_strncasecmp(s1, s2, n);
}


// Duplicates the first @n bytes of a string, returning a newly-allocated
// buffer @n + 1 bytes long which will always be nul-terminated.
// If @str is less than @n bytes long the buffer is padded with nuls.
// If @str is %NULL it returns %NULL.
// The returned value should be freed when no longer needed.
// 
// <note><para>
// To copy a number of characters from a UTF-8 encoded string, use
// g_utf8_strncpy() instead.
// </para></note>
// 
// of @str, nul-terminated
// RETURNS: a newly-allocated buffer containing the first @n bytes
// <str>: the string to duplicate
// <n>: the maximum number of bytes to copy from @str
static char* /*new*/ strndup(char* str, size_t n) {
   return g_strndup(str, n);
}


// Creates a new string @length bytes long filled with @fill_char.
// The returned string should be freed when no longer needed.
// RETURNS: a newly-allocated string filled the @fill_char
// <length>: the length of the new string
// <fill_char>: the byte to fill the string with
static char* /*new*/ strnfill(size_t length, char fill_char) {
   return g_strnfill(length, fill_char);
}


// Reverses all of the bytes in a string. For example,
// <literal>g_strreverse ("abcdef")</literal> will result
// in "fedcba".
// 
// Note that g_strreverse() doesn't work on UTF-8 strings
// containing multibyte characters. For that purpose, use
// g_utf8_strreverse().
// RETURNS: the same pointer passed in as @string
// <string>: the string to reverse
static char* /*new*/ strreverse(char* string_) {
   return g_strreverse(string_);
}


// Searches the string @haystack for the last occurrence
// of the string @needle.
// 
// %NULL if not found.
// RETURNS: a pointer to the found occurrence, or
// <haystack>: a nul-terminated string.
// <needle>: the nul-terminated string to search for.
static char* /*new*/ strrstr(char* haystack, char* needle) {
   return g_strrstr(haystack, needle);
}


// Searches the string @haystack for the last occurrence
// of the string @needle, limiting the length of the search
// to @haystack_len.
// 
// %NULL if not found.
// RETURNS: a pointer to the found occurrence, or
// <haystack>: a nul-terminated string.
// <haystack_len>: the maximum length of @haystack.
// <needle>: the nul-terminated string to search for.
static char* /*new*/ strrstr_len(char* haystack, ssize_t haystack_len, char* needle) {
   return g_strrstr_len(haystack, haystack_len, needle);
}


// Returns a string describing the given signal, e.g. "Segmentation fault".
// You should use this function in preference to strsignal(), because it
// returns a string in UTF-8 encoding, and since not all platforms support
// the strsignal() function.
// 
// it returns "unknown signal (&lt;signum&gt;)". The string can only be
// used until the next call to g_strsignal()
// RETURNS: a UTF-8 string describing the signal. If the signal is unknown,
// <signum>: the signal number. See the <literal>signal</literal> documentation
static char* strsignal(int signum) {
   return g_strsignal(signum);
}


// Unintrospectable function: strsplit() / g_strsplit()
// Splits a string into a maximum of @max_tokens pieces, using the given
// @delimiter. If @max_tokens is reached, the remainder of @string is appended
// to the last token.
// 
// 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 a 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 g_strsplit().
// 
// g_strfreev() to free it.
// RETURNS: a newly-allocated %NULL-terminated array of strings. Use
// <string>: a string to split.
// <delimiter>: 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>: the maximum number of pieces to split @string into. If this is less than 1, the string is split completely.
static char** strsplit(char* string_, char* delimiter, int max_tokens) {
   return g_strsplit(string_, delimiter, max_tokens);
}


// Unintrospectable function: strsplit_set() / g_strsplit_set()
// Splits @string into a number of tokens not containing any of the characters
// in @delimiter. A token is the (possibly empty) longest string that does not
// contain any of the characters in @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 a
// %NULL-terminated vector containing the three strings "abc", "def",
// and "ghi".
// 
// The result if g_strsplit_set (":def/ghi:", ":/", -1) is a %NULL-terminated
// vector containing the four strings "", "def", "ghi", and "".
// 
// 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 a 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 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.
// 
// g_strfreev() to free it.
// RETURNS: a newly-allocated %NULL-terminated array of strings. Use
// <string>: The string to be tokenized
// <delimiters>: A nul-terminated string containing bytes that are used to split the string.
// <max_tokens>: The maximum number of tokens to split @string into. If this is less than 1, the string is split completely
static char** strsplit_set(char* string_, char* delimiters, int max_tokens) {
   return g_strsplit_set(string_, delimiters, max_tokens);
}


// Searches the string @haystack for the first occurrence
// of the string @needle, limiting the length of the search
// to @haystack_len.
// 
// %NULL if not found.
// RETURNS: a pointer to the found occurrence, or
// <haystack>: a string.
// <haystack_len>: the maximum length of @haystack. Note that -1 is a valid length, if @haystack is nul-terminated, meaning it will search through the whole string.
// <needle>: the string to search for.
static char* /*new*/ strstr_len(char* haystack, ssize_t haystack_len, char* needle) {
   return g_strstr_len(haystack, haystack_len, needle);
}


// Converts a string to a #gdouble 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 g_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 g_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.
// RETURNS: the #gdouble value.
// <nptr>: the string to convert to a numeric value.
// <endptr>: if non-%NULL, it returns the character after the last character used in the conversion.
static double strtod(char* nptr, char** endptr) {
   return g_strtod(nptr, endptr);
}


// Converts a string to upper case.
// 
// 
// Deprecated:2.2: This function is totally broken for the reasons discussed
// in the g_strncasecmp() docs - use g_ascii_strup() or g_utf8_strup() instead.
// RETURNS: the string
// <string>: the string to convert.
static char* /*new*/ strup(char* string_) {
   return g_strup(string_);
}

static Type strv_get_type() {
   return g_strv_get_type();
}


// Returns the length of the given %NULL-terminated
// string array @str_array.
// RETURNS: length of @str_array.
// <str_array>: a %NULL-terminated array of strings.
static uint strv_length(char** str_array) {
   return g_strv_length(str_array);
}


// Unintrospectable function: test_add_data_func() / g_test_add_data_func()
// Create a new test case, similar to g_test_create_case(). However
// the test is assumed to use no fixture, and test suites are automatically
// created on the fly and added to the root fixture, based on the
// slash-separated portions of @testpath. The @test_data argument
// will be passed as first argument to @test_func.
// <testpath>: Slash-separated test case path name for the test.
// <test_data>: Test data argument for the test function.
// <test_func>: The test function to invoke for this test.
static void test_add_data_func(char* testpath, const(void)* test_data, TestDataFunc test_func) {
   g_test_add_data_func(testpath, test_data, test_func);
}


// Unintrospectable function: test_add_func() / g_test_add_func()
// Create a new test case, similar to g_test_create_case(). However
// the test is assumed to use no fixture, and test suites are automatically
// created on the fly and added to the root fixture, based on the
// slash-separated portions of @testpath.
// <testpath>: Slash-separated test case path name for the test.
// <test_func>: The test function to invoke for this test.
static void test_add_func(char* testpath, TestFunc test_func) {
   g_test_add_func(testpath, test_func);
}

// Unintrospectable function: test_add_vtable() / g_test_add_vtable()
static void test_add_vtable(char* testpath, size_t data_size, const(void)* test_data, TestFixtureFunc data_setup, TestFixtureFunc data_test, TestFixtureFunc data_teardown) {
   g_test_add_vtable(testpath, data_size, test_data, data_setup, data_test, data_teardown);
}


// This function adds a message to test reports that
// associates a bug URI with a test case.
// Bug URIs are constructed from a base URI set with g_test_bug_base()
// and @bug_uri_snippet.
// <bug_uri_snippet>: Bug specific bug tracker URI portion.
static void test_bug(char* bug_uri_snippet) {
   g_test_bug(bug_uri_snippet);
}


// Specify the base URI for bug reports.
// 
// The base URI is used to construct bug report messages for
// g_test_message() when g_test_bug() is called.
// Calling this function outside of a test case sets the
// default base URI for all test cases. Calling it from within
// a test case changes the base URI for the scope of the test
// case only.
// Bug URIs are constructed by appending a bug specific URI
// portion to @uri_pattern, or by replacing the special string
// '%s' within @uri_pattern if that is present.
// <uri_pattern>: the base pattern for bug URIs
static void test_bug_base(char* uri_pattern) {
   g_test_bug_base(uri_pattern);
}


// Unintrospectable function: test_create_case() / g_test_create_case()
// Create a new #GTestCase, named @test_name, this API is fairly
// low level, calling g_test_add() or g_test_add_func() is preferable.
// When this test is executed, a fixture structure of size @data_size
// will be allocated and filled with 0s. Then data_setup() is called
// to initialize the fixture. After fixture setup, the actual test
// function data_test() is called. Once the test run completed, the
// fixture structure is torn down  by calling data_teardown() and
// after that the memory is released.
// 
// Splitting up a test run into fixture setup, test function and
// fixture teardown is most usful if the same fixture is used for
// multiple tests. In this cases, g_test_create_case() will be
// called with the same fixture, but varying @test_name and
// @data_test arguments.
// RETURNS: a newly allocated #GTestCase.
// <test_name>: the name for the test case
// <data_size>: the size of the fixture data structure
// <test_data>: test data argument for the test functions
// <data_setup>: the function to set up the fixture data
// <data_test>: the actual test function
// <data_teardown>: the function to teardown the fixture data
static TestCase* test_create_case(char* test_name, size_t data_size, const(void)* test_data, TestFixtureFunc data_setup, TestFixtureFunc data_test, TestFixtureFunc data_teardown) {
   return g_test_create_case(test_name, data_size, test_data, data_setup, data_test, data_teardown);
}


// Unintrospectable function: test_create_suite() / g_test_create_suite()
// Create a new test suite with the name @suite_name.
// RETURNS: A newly allocated #GTestSuite instance.
// <suite_name>: a name for the suite
static TestSuite* test_create_suite(char* suite_name) {
   return g_test_create_suite(suite_name);
}


// 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.
static void test_fail() {
   g_test_fail();
}


// Unintrospectable function: test_get_root() / g_test_get_root()
// Get the toplevel test suite for the test path API.
// RETURNS: the toplevel #GTestSuite
static TestSuite* test_get_root() {
   return g_test_get_root();
}


// Unintrospectable function: test_init() / g_test_init()
// Initialize the GLib testing framework, e.g. by seeding the
// test random number generator, the name for g_get_prgname()
// and parsing test related command line args.
// So far, the following arguments are understood:
// <variablelist>
// <varlistentry>
// <term><option>-l</option></term>
// <listitem><para>
// list test cases available in a test executable.
// </para></listitem>
// </varlistentry>
// <varlistentry>
// <term><option>--seed=<replaceable>RANDOMSEED</replaceable></option></term>
// <listitem><para>
// provide a random seed to reproduce test runs using random numbers.
// </para></listitem>
// </varlistentry>
// <varlistentry>
// <term><option>--verbose</option></term>
// <listitem><para>run tests verbosely.</para></listitem>
// </varlistentry>
// <varlistentry>
// <term><option>-q</option>, <option>--quiet</option></term>
// <listitem><para>run tests quietly.</para></listitem>
// </varlistentry>
// <varlistentry>
// <term><option>-p <replaceable>TESTPATH</replaceable></option></term>
// <listitem><para>
// execute all tests matching <replaceable>TESTPATH</replaceable>.
// </para></listitem>
// </varlistentry>
// <varlistentry>
// <term><option>-m {perf|slow|thorough|quick}</option></term>
// <listitem><para>
// execute tests according to these test modes:
// <variablelist>
// <varlistentry>
// <term>perf</term>
// <listitem><para>
// performance tests, may take long and report results.
// </para></listitem>
// </varlistentry>
// <varlistentry>
// <term>slow, thorough</term>
// <listitem><para>
// slow and thorough tests, may take quite long and
// maximize coverage.
// </para></listitem>
// </varlistentry>
// <varlistentry>
// <term>quick</term>
// <listitem><para>
// quick tests, should run really quickly and give good coverage.
// </para></listitem>
// </varlistentry>
// </variablelist>
// </para></listitem>
// </varlistentry>
// <varlistentry>
// <term><option>--debug-log</option></term>
// <listitem><para>debug test logging output.</para></listitem>
// </varlistentry>
// <varlistentry>
// <term><option>-k</option>, <option>--keep-going</option></term>
// <listitem><para>gtester-specific argument.</para></listitem>
// </varlistentry>
// <varlistentry>
// <term><option>--GTestLogFD <replaceable>N</replaceable></option></term>
// <listitem><para>gtester-specific argument.</para></listitem>
// </varlistentry>
// <varlistentry>
// <term><option>--GTestSkipCount <replaceable>N</replaceable></option></term>
// <listitem><para>gtester-specific argument.</para></listitem>
// </varlistentry>
// </variablelist>
// <argc>: Address of the @argc parameter of the main() function. Changed if any arguments were handled.
// <argv>: Address of the @argv parameter of main(). Any parameters understood by g_test_init() stripped before return.
alias g_test_init test_init; // Variadic


// Unintrospectable function: test_log_set_fatal_handler() / g_test_log_set_fatal_handler()
// 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.
// <log_func>: the log handler function.
// <user_data>: data passed to the log handler.
static void test_log_set_fatal_handler(TestLogFatalFunc log_func, void* user_data) {
   g_test_log_set_fatal_handler(log_func, user_data);
}

static char* test_log_type_name(TestLogType log_type) {
   return g_test_log_type_name(log_type);
}


// Unintrospectable function: test_maximized_result() / g_test_maximized_result()
// Report the result of a performance or measurement test.
// The test should generally strive to maximize the reported
// quantities (larger values are better than smaller ones),
// this and @maximized_quantity can determine sorting
// order for test result reports.
// <maximized_quantity>: the reported value
// <format>: the format string of the report message
alias g_test_maximized_result test_maximized_result; // Variadic


// Unintrospectable function: test_message() / g_test_message()
// Add a message to the test report.
// <format>: the format string
alias g_test_message test_message; // Variadic


// Unintrospectable function: test_minimized_result() / g_test_minimized_result()
// Report the result of a performance or measurement test.
// The test should generally strive to minimize the reported
// quantities (smaller values are better than larger ones),
// this and @minimized_quantity can determine sorting
// order for test result reports.
// <minimized_quantity>: the reported value
// <format>: the format string of the report message
alias g_test_minimized_result test_minimized_result; // Variadic


// This function enqueus a callback @destroy_func() to be executed
// during the next test case teardown phase. This is most useful
// to auto destruct allocted test resources at the end of a test run.
// Resources are released in reverse queue order, that means enqueueing
// callback A before callback B will cause B() to be called before
// A() during teardown.
// <destroy_func>: Destroy callback for teardown phase.
// <destroy_data>: Destroy callback data.
static void test_queue_destroy(DestroyNotify destroy_func, void* destroy_data) {
   g_test_queue_destroy(destroy_func, destroy_data);
}


// Enqueue a pointer to be released with g_free() during the next
// teardown phase. This is equivalent to calling g_test_queue_destroy()
// with a destroy callback of g_free().
// <gfree_pointer>: the pointer to be stored.
static void test_queue_free(void* gfree_pointer) {
   g_test_queue_free(gfree_pointer);
}


// Get a reproducible random floating point number,
// see g_test_rand_int() for details on test case random numbers.
// RETURNS: a random number from the seeded random number generator.
static double test_rand_double() {
   return g_test_rand_double();
}


// Get a reproducible random floating pointer number out of a specified range,
// see g_test_rand_int() for details on test case random numbers.
// RETURNS: a number with @range_start <= number < @range_end.
// <range_start>: the minimum value returned by this function
// <range_end>: the minimum value not returned by this function
static double test_rand_double_range(double range_start, double range_end) {
   return g_test_rand_double_range(range_start, range_end);
}


// Get a reproducible random integer number.
// 
// The random numbers generated by the g_test_rand_*() family of functions
// change with every new test program start, unless the --seed option is
// given when starting test programs.
// 
// For individual test cases however, the random number generator is
// reseeded, to avoid dependencies between tests and to make --seed
// effective for all test cases.
// RETURNS: a random number from the seeded random number generator.
static int test_rand_int() {
   return g_test_rand_int();
}


// Get a reproducible random integer number out of a specified range,
// see g_test_rand_int() for details on test case random numbers.
// RETURNS: a number with @begin <= number < @end.
// <begin>: the minimum value returned by this function
// <end>: the smallest value not to be returned by this function
static int test_rand_int_range(int begin, int end) {
   return g_test_rand_int_range(begin, end);
}


// Runs all tests under the toplevel suite which can be retrieved
// with g_test_get_root(). Similar to g_test_run_suite(), the test
// cases to be run are filtered according to
// test path arguments (-p <replaceable>testpath</replaceable>) as
// parsed by g_test_init().
// g_test_run_suite() or g_test_run() may only be called once
// in a program.
// RETURNS: 0 on success
static int test_run() {
   return g_test_run();
}


// Execute the tests within @suite and all nested #GTestSuites.
// The test suites to be executed are filtered according to
// test path arguments (-p <replaceable>testpath</replaceable>)
// as parsed by g_test_init().
// g_test_run_suite() or g_test_run() may only be called once
// in a program.
// RETURNS: 0 on success
// <suite>: a #GTestSuite
static int test_run_suite(TestSuite* suite) {
   return g_test_run_suite(suite);
}


// Get the time since the last start of the timer with g_test_timer_start().
// RETURNS: the time since the last start of the timer, as a double
static double test_timer_elapsed() {
   return g_test_timer_elapsed();
}


// Report the last result of g_test_timer_elapsed().
// RETURNS: the last result of g_test_timer_elapsed(), as a double
static double test_timer_last() {
   return g_test_timer_last();
}


// Start a timing test. Call g_test_timer_elapsed() when the task is supposed
// to be done. Call this function again to restart the timer.
static void test_timer_start() {
   g_test_timer_start();
}

static void test_trap_assertions(char* domain, char* file, int line, char* func, ulong assertion_flags, char* pattern) {
   g_test_trap_assertions(domain, file, line, func, assertion_flags, pattern);
}


// Fork the current test program to execute a test case that might
// not return or that might abort. The forked test case is aborted
// and considered failing if its run time exceeds @usec_timeout.
// 
// The forking behavior can be configured with the #GTestTrapFlags 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.
// 
// |[
// 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\n");
// g_printerr ("some stderr text: semagic43\n");
// exit (0); /&ast; successful test run &ast;/
// }
// g_test_trap_assert_passed();
// g_test_trap_assert_stdout ("*somagic17*");
// g_test_trap_assert_stderr ("*semagic43*");
// }
// ]|
// 
// This function is implemented only on Unix platforms.
// RETURNS: %TRUE for the forked child and %FALSE for the executing parent process.
// <usec_timeout>: Timeout for the forked test in micro seconds.
// <test_trap_flags>: Flags to modify forking behaviour.
static int test_trap_fork(ulong usec_timeout, TestTrapFlags test_trap_flags) {
   return g_test_trap_fork(usec_timeout, test_trap_flags);
}


// Check the result of the last g_test_trap_fork() call.
// RETURNS: %TRUE if the last forked child terminated successfully.
static int test_trap_has_passed() {
   return g_test_trap_has_passed();
}


// Check the result of the last g_test_trap_fork() call.
// RETURNS: %TRUE if the last forked child got killed due to a fork timeout.
static int test_trap_reached_timeout() {
   return g_test_trap_reached_timeout();
}

static Quark thread_error_quark() {
   return g_thread_error_quark();
}


// Exits the current thread. If another thread is waiting for that
// thread using g_thread_join() and the current thread is joinable, the
// waiting thread will be woken up and get @retval as the return value
// of g_thread_join(). If the current thread is not joinable, @retval
// is ignored. Calling
// 
// <informalexample>
// <programlisting>
// g_thread_exit (retval);
// </programlisting>
// </informalexample>
// 
// is equivalent to returning @retval from the function @func, as given
// to g_thread_create().
// 
// <note><para>Never call g_thread_exit() from within a thread of a
// #GThreadPool, as that will mess up the bookkeeping and lead to funny
// and unwanted results.</para></note>
// <retval>: the return value of this thread.
static void thread_exit(void* retval) {
   g_thread_exit(retval);
}


// Indicates if g_thread_init() has been called.
// RETURNS: %TRUE if threads have been initialized.
static int thread_get_initialized() {
   return g_thread_get_initialized();
}


// If you use GLib from more than one thread, you must initialize the
// thread system by calling g_thread_init(). Most of the time you will
// only have to call <literal>g_thread_init (NULL)</literal>.
// 
// <note><para>Do not call g_thread_init() with a non-%NULL parameter unless
// you really know what you are doing.</para></note>
// 
// <note><para>g_thread_init() must not be called directly or indirectly as a
// callback from GLib. Also no mutexes may be currently locked while
// calling g_thread_init().</para></note>
// 
// <note><para>g_thread_init() changes the way in which #GTimer measures
// elapsed time. As a consequence, timers that are running while
// g_thread_init() is called may report unreliable times.</para></note>
// 
// Calling g_thread_init() multiple times is allowed (since version
// 2.24), but nothing happens except for the first call. If the
// argument is non-%NULL on such a call a warning will be printed, but
// otherwise the argument is ignored.
// 
// If no thread system is available and @vtable is %NULL or if not all
// elements of @vtable are non-%NULL, then g_thread_init() will abort.
// 
// <note><para>To use g_thread_init() in your program, you have to link with
// the libraries that the command <command>pkg-config --libs
// gthread-2.0</command> outputs. 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.</para></note>
// <vtable>: a function table of type #GThreadFunctions, that provides the entry points to the thread system to be used.
static void thread_init(ThreadFunctions* vtable) {
   g_thread_init(vtable);
}

static void thread_init_with_errorcheck_mutexes(ThreadFunctions* vtable) {
   g_thread_init_with_errorcheck_mutexes(vtable);
}


// 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.
// 
// thread pool before stopping the thread (1/1000ths of a second).
// RETURNS: the maximum @interval to wait for new tasks in the
static uint thread_pool_get_max_idle_time() {
   return g_thread_pool_get_max_idle_time();
}


// Returns the maximal allowed number of unused threads.
// RETURNS: the maximal number of unused threads
static int thread_pool_get_max_unused_threads() {
   return g_thread_pool_get_max_unused_threads();
}


// Returns the number of currently unused threads.
// RETURNS: the number of currently unused threads
static uint thread_pool_get_num_unused_threads() {
   return g_thread_pool_get_num_unused_threads();
}


// 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.
// 
// This function makes use of g_async_queue_timed_pop () using
// @interval.
// <interval>: the maximum @interval (1/1000ths of a second) a thread can be idle.
static void thread_pool_set_max_idle_time(uint interval) {
   g_thread_pool_set_max_idle_time(interval);
}


// Sets the maximal number of unused threads to @max_threads. If
// @max_threads is -1, no limit is imposed on the number of unused
// threads.
// <max_threads>: maximal number of unused threads
static void thread_pool_set_max_unused_threads(int max_threads) {
   g_thread_pool_set_max_unused_threads(max_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().
static void thread_pool_stop_unused_threads() {
   g_thread_pool_stop_unused_threads();
}


// Converts a string containing an ISO 8601 encoded date and time
// to a #GTimeVal and puts it into @time_.
// RETURNS: %TRUE if the conversion was successful.
// <iso_date>: an ISO 8601 encoded date string
// <time_>: a #GTimeVal
static int time_val_from_iso8601(char* iso_date, TimeVal* time_) {
   return g_time_val_from_iso8601(iso_date, time_);
}


// Unintrospectable function: timeout_add() / g_timeout_add()
// Sets a function to be called at regular intervals, with the default
// priority, #G_PRIORITY_DEFAULT.  The function is called repeatedly
// until it returns %FALSE, at which point the timeout is automatically
// destroyed and the function will not be called again.  The 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).
// 
// If you want to have a timer in the "seconds" range and do not care
// about the exact time of the first call of the timer, use the
// g_timeout_add_seconds() function; this function allows for more
// optimizations and more efficient system power usage.
// 
// This internally creates a main loop source using g_timeout_source_new()
// and attaches it to the main loop context using g_source_attach(). You can
// do these steps manually if you need greater control.
// 
// The interval given is in terms of monotonic time, not wall clock
// time.  See g_get_monotonic_time().
// RETURNS: the ID (greater than 0) of the event source.
// <interval>: the time between calls to the function, in milliseconds (1/1000ths of a second)
// <function>: function to call
// <data>: data to pass to @function
static uint timeout_add(uint interval, SourceFunc function_, void* data) {
   return g_timeout_add(interval, function_, data);
}


// Sets a function to be called at regular intervals, with the given
// priority.  The function is called repeatedly until it returns
// %FALSE, at which point the timeout is automatically destroyed and
// the function will not be called again.  The @notify function is
// called when the timeout is destroyed.  The first call to the
// function will be at the end of the first @interval.
// 
// Note that timeout functions may be delayed, due to the processing of other
// event sources. Thus they should not be relied on for precise timing.
// After each call to the timeout function, the time of the next
// timeout is recalculated based on the current time and the given interval
// (it does not try to 'catch up' time lost in delays).
// 
// This internally creates a main loop source using g_timeout_source_new()
// and attaches it to the main loop context using g_source_attach(). You can
// do these steps manually if you need greater control.
// 
// The interval given in terms of monotonic time, not wall clock time.
// See g_get_monotonic_time().
// RETURNS: the ID (greater than 0) of the event source.
// <priority>: the priority of the timeout source. Typically this will be in the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH.
// <interval>: the time between calls to the function, in milliseconds (1/1000ths of a second)
// <function>: function to call
// <data>: data to pass to @function
// <notify>: function to call when the timeout is removed, or %NULL
static uint timeout_add_full(int priority, uint interval, SourceFunc function_, void* data, DestroyNotify notify) {
   return g_timeout_add_full(priority, interval, function_, data, notify);
}


// Unintrospectable function: timeout_add_seconds() / g_timeout_add_seconds()
// Sets a function to be called at regular intervals with the default
// priority, #G_PRIORITY_DEFAULT. The function is called repeatedly until
// it returns %FALSE, at which point the timeout is automatically destroyed
// and the function will not be called again.
// 
// This internally creates a main loop source using
// g_timeout_source_new_seconds() and attaches it to the main loop context
// using g_source_attach(). You can do these steps manually if you need
// greater control. Also see g_timeout_add_seconds_full().
// 
// Note that the first call of the timer may not be precise for timeouts
// of one second. If you need finer precision and have such a timeout,
// you may want to use g_timeout_add() instead.
// 
// The interval given is in terms of monotonic time, not wall clock
// time.  See g_get_monotonic_time().
// RETURNS: the ID (greater than 0) of the event source.
// <interval>: the time between calls to the function, in seconds
// <function>: function to call
// <data>: data to pass to @function
static uint timeout_add_seconds(uint interval, SourceFunc function_, void* data) {
   return g_timeout_add_seconds(interval, function_, data);
}


// Sets a function to be called at regular intervals, with @priority.
// The function is called repeatedly until it returns %FALSE, at which
// point the timeout is automatically destroyed and the function will
// not be called again.
// 
// Unlike g_timeout_add(), this function operates at whole second granularity.
// The initial starting point of the timer is determined by the implementation
// and the implementation is expected to group multiple timers together so that
// they fire all at the same time.
// To allow this grouping, the @interval to the first timer is rounded
// and can deviate up to one second from the specified interval.
// Subsequent timer iterations will generally run at the specified interval.
// 
// Note that timeout functions may be delayed, due to the processing of other
// event sources. Thus they should not be relied on for precise timing.
// After each call to the timeout function, the time of the next
// timeout is recalculated based on the current time and the given @interval
// 
// If you want timing more precise than whole seconds, use g_timeout_add()
// instead.
// 
// The grouping of timers to fire at the same time results in a more power
// and CPU efficient behavior so if your timer is in multiples of seconds
// and you don't require the first timer exactly one second from now, the
// use of g_timeout_add_seconds() is preferred over g_timeout_add().
// 
// This internally creates a main loop source using
// g_timeout_source_new_seconds() and attaches it to the main loop context
// using g_source_attach(). You can do these steps manually if you need
// greater control.
// 
// The interval given is in terms of monotonic time, not wall clock
// time.  See g_get_monotonic_time().
// RETURNS: the ID (greater than 0) of the event source.
// <priority>: the priority of the timeout source. Typically this will be in the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH.
// <interval>: the time between calls to the function, in seconds
// <function>: function to call
// <data>: data to pass to @function
// <notify>: function to call when the timeout is removed, or %NULL
static uint timeout_add_seconds_full(int priority, uint interval, SourceFunc function_, void* data, DestroyNotify notify) {
   return g_timeout_add_seconds_full(priority, interval, function_, data, notify);
}


// Creates a new timeout source.
// 
// The source will not initially be associated with any #GMainContext
// and must be added to one with g_source_attach() before it will be
// executed.
// 
// The interval given is in terms of monotonic time, not wall clock
// time.  See g_get_monotonic_time().
// RETURNS: the newly-created timeout source
// <interval>: the timeout interval in milliseconds.
static Source* /*new*/ timeout_source_new(uint interval) {
   return g_timeout_source_new(interval);
}


// Creates a new timeout source.
// 
// The source will not initially be associated with any #GMainContext
// and must be added to one with g_source_attach() before it will be
// executed.
// 
// The scheduling granularity/accuracy of this timeout source will be
// in seconds.
// 
// The interval given in terms of monotonic time, not wall clock time.
// See g_get_monotonic_time().
// RETURNS: the newly-created timeout source
// <interval>: the timeout interval in seconds
static Source* /*new*/ timeout_source_new_seconds(uint interval) {
   return g_timeout_source_new_seconds(interval);
}

static uint trash_stack_height(TrashStack** stack_p) {
   return g_trash_stack_height(stack_p);
}

static void trash_stack_push(TrashStack** stack_p, void* data_p) {
   g_trash_stack_push(stack_p, data_p);
}


// Unintrospectable function: try_malloc() / g_try_malloc()
// Attempts to allocate @n_bytes, and returns %NULL on failure.
// Contrast with g_malloc(), which aborts the program on failure.
// RETURNS: the allocated memory, or %NULL.
// <n_bytes>: number of bytes to allocate.
static void* try_malloc(size_t n_bytes) {
   return g_try_malloc(n_bytes);
}


// Unintrospectable function: try_malloc0() / g_try_malloc0()
// Attempts to allocate @n_bytes, initialized to 0's, and returns %NULL on
// failure. Contrast with g_malloc0(), which aborts the program on failure.
// RETURNS: the allocated memory, or %NULL
// <n_bytes>: number of bytes to allocate
static void* try_malloc0(size_t n_bytes) {
   return g_try_malloc0(n_bytes);
}


// Unintrospectable function: try_malloc0_n() / g_try_malloc0_n()
// This function is similar to g_try_malloc0(), allocating (@n_blocks * @n_block_bytes) bytes,
// but care is taken to detect possible overflow during multiplication.
// RETURNS: the allocated memory, or %NULL
// <n_blocks>: the number of blocks to allocate
// <n_block_bytes>: the size of each block in bytes
static void* try_malloc0_n(size_t n_blocks, size_t n_block_bytes) {
   return g_try_malloc0_n(n_blocks, n_block_bytes);
}


// Unintrospectable function: try_malloc_n() / g_try_malloc_n()
// This function is similar to g_try_malloc(), allocating (@n_blocks * @n_block_bytes) bytes,
// but care is taken to detect possible overflow during multiplication.
// RETURNS: the allocated memory, or %NULL.
// <n_blocks>: the number of blocks to allocate
// <n_block_bytes>: the size of each block in bytes
static void* try_malloc_n(size_t n_blocks, size_t n_block_bytes) {
   return g_try_malloc_n(n_blocks, n_block_bytes);
}


// Unintrospectable function: try_realloc() / g_try_realloc()
// 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().
// RETURNS: the allocated memory, or %NULL.
// <mem>: previously-allocated memory, or %NULL.
// <n_bytes>: number of bytes to allocate.
static void* try_realloc(void* mem, size_t n_bytes) {
   return g_try_realloc(mem, n_bytes);
}


// Unintrospectable function: try_realloc_n() / g_try_realloc_n()
// This function is similar to g_try_realloc(), allocating (@n_blocks * @n_block_bytes) bytes,
// but care is taken to detect possible overflow during multiplication.
// RETURNS: the allocated memory, or %NULL.
// <mem>: previously-allocated memory, or %NULL.
// <n_blocks>: the number of blocks to allocate
// <n_block_bytes>: the size of each block in bytes
static void* try_realloc_n(void* mem, size_t n_blocks, size_t n_block_bytes) {
   return g_try_realloc_n(mem, n_blocks, n_block_bytes);
}


// Convert a string from UCS-4 to UTF-16. A 0 character will be
// added to the result after the converted text.
// 
// This value must be freed with g_free(). If an
// error occurs, %NULL will be returned and
// @error set.
// RETURNS: a pointer to a newly allocated UTF-16 string.
// <str>: a UCS-4 encoded string
// <len>: the maximum length (number of characters) of @str to use. If @len < 0, then the string is nul-terminated.
// <items_read>: location to store number of bytes read, or %NULL. If an error occurs then the index of the invalid input is stored here.
// <items_written>: location to store number of <type>gunichar2</type> written, or %NULL. The value stored here does not include the trailing 0.
static wchar* ucs4_to_utf16(dchar* str, c_long len, c_long* items_read, c_long* items_written, GLib2.Error** error=null) {
   return g_ucs4_to_utf16(str, len, items_read, items_written, error);
}


// Convert a string from a 32-bit fixed width representation as UCS-4.
// to UTF-8. The result will be terminated with a 0 byte.
// 
// This value must be freed with g_free(). If an
// error occurs, %NULL will be returned and
// @error set. In that case, @items_read will be
// set to the position of the first invalid input
// character.
// RETURNS: a pointer to a newly allocated UTF-8 string.
// <str>: a UCS-4 encoded string
// <len>: the maximum length (number of characters) of @str to use. If @len < 0, then the string is nul-terminated.
// <items_read>: location to store number of characters read, or %NULL.
// <items_written>: location to store number of bytes written or %NULL. The value here stored does not include the trailing 0 byte.
static char* /*new*/ ucs4_to_utf8(dchar* str, c_long len, c_long* items_read, c_long* items_written, GLib2.Error** error=null) {
   return g_ucs4_to_utf8(str, len, items_read, items_written, error);
}


// 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.
// RETURNS: the break type of @c
// <c>: a Unicode character
static UnicodeBreakType unichar_break_type(dchar c) {
   return g_unichar_break_type(c);
}


// Determines the canonical combining class of a Unicode character.
// RETURNS: the combining class of the character
// <uc>: a Unicode character
static int unichar_combining_class(dchar uc) {
   return g_unichar_combining_class(uc);
}


// Performs a single composition step of the
// Unicode canonical composition algorithm.
// 
// This function does not perform algorithmic composition
// for Hangul characters, and does not include compatibility
// compositions. It does, however, include 'singleton'
// compositions which replace a character by a single
// other character. To obtain these, pass zero for @b.
// 
// This function includes algorithmic Hangul Jamo composition.
// 
// If @a and @b do not compose a new character, @ch is set to zero.
// 
// See <ulink url="http://unicode.org/reports/tr15/">UAX#15</ulink>
// for details.
// RETURNS: %TRUE if the characters could be composed
// <a>: a Unicode character
// <b>: a Unicode character
// <ch>: return location for the composed character
static int unichar_compose(dchar a, dchar b, dchar* ch) {
   return g_unichar_compose(a, b, 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 *@b will
// be set to zero.
// 
// If @ch is not decomposable, *@a is set to @ch and *@b
// is 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 <ulink url="http://unicode.org/reports/tr15/">UAX#15</ulink>
// for details.
// RETURNS: %TRUE if the character could be decomposed
// <ch>: a Unicode character
// <a>: return location for the first component of @ch
// <b>: return location for the second component of @ch
static int unichar_decompose(dchar ch, dchar* a, dchar* b) {
   return g_unichar_decompose(ch, a, b);
}


// Determines the numeric value of a character as a decimal
// digit.
// 
// g_unichar_isdigit()), its numeric value. Otherwise, -1.
// RETURNS: If @c is a decimal digit (according to
// <c>: a Unicode character
static int unichar_digit_value(dchar c) {
   return g_unichar_digit_value(c);
}


// 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 @result.  The length
// of the full decomposition (irrespective of @result_len) is
// 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.
// 
// See <ulink url="http://unicode.org/reports/tr15/">UAX#15</ulink>
// for details.
// RETURNS: the length of the full decomposition.
// <ch>: a Unicode character.
// <compat>: whether perform canonical or compatibility decomposition
// <result>: location to store decomposed result, or %NULL
// <result_len>: length of @result
static size_t unichar_fully_decompose(dchar ch, int compat, dchar* result, size_t result_len) {
   return g_unichar_fully_decompose(ch, compat, result, result_len);
}


// In Unicode, some characters are <firstterm>mirrored</firstterm>. 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 @ch's
// glyph and @mirrored_ch is set, it puts that character in the address
// pointed to by @mirrored_ch.  Otherwise the original character is put.
// RETURNS: %TRUE if @ch has a mirrored character, %FALSE otherwise
// <ch>: a Unicode character
// <mirrored_ch>: location to store the mirrored character
static int unichar_get_mirror_char(dchar ch, dchar* mirrored_ch) {
   return g_unichar_get_mirror_char(ch, mirrored_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.
// RETURNS: the #GUnicodeScript for the character.
// <ch>: a Unicode character
static UnicodeScript unichar_get_script(dchar ch) {
   return g_unichar_get_script(ch);
}


// Determines whether a character is alphanumeric.
// Given some UTF-8 text, obtain a character value
// with g_utf8_get_char().
// RETURNS: %TRUE if @c is an alphanumeric character
// <c>: a Unicode character
static int unichar_isalnum(dchar c) {
   return g_unichar_isalnum(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().
// RETURNS: %TRUE if @c is an alphabetic character
// <c>: a Unicode character
static int unichar_isalpha(dchar c) {
   return g_unichar_isalpha(c);
}


// Determines whether a character is a control character.
// Given some UTF-8 text, obtain a character value with
// g_utf8_get_char().
// RETURNS: %TRUE if @c is a control character
// <c>: a Unicode character
static int unichar_iscntrl(dchar c) {
   return g_unichar_iscntrl(c);
}


// Determines if a given character is assigned in the Unicode
// standard.
// RETURNS: %TRUE if the character has an assigned value
// <c>: a Unicode character
static int unichar_isdefined(dchar c) {
   return g_unichar_isdefined(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().
// RETURNS: %TRUE if @c is a digit
// <c>: a Unicode character
static int unichar_isdigit(dchar c) {
   return g_unichar_isdigit(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().
// RETURNS: %TRUE if @c is printable unless it's a space
// <c>: a Unicode character
static int unichar_isgraph(dchar c) {
   return g_unichar_isgraph(c);
}


// Determines whether a character is a lowercase letter.
// Given some UTF-8 text, obtain a character value with
// g_utf8_get_char().
// RETURNS: %TRUE if @c is a lowercase letter
// <c>: a Unicode character
static int unichar_islower(dchar c) {
   return g_unichar_islower(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.
// RETURNS: %TRUE if @c is a mark character
// <c>: a Unicode character
static int unichar_ismark(dchar c) {
   return g_unichar_ismark(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().
// RETURNS: %TRUE if @c is printable
// <c>: a Unicode character
static int unichar_isprint(dchar c) {
   return g_unichar_isprint(c);
}


// Determines whether a character is punctuation or a symbol.
// Given some UTF-8 text, obtain a character value with
// g_utf8_get_char().
// RETURNS: %TRUE if @c is a punctuation or symbol character
// <c>: a Unicode character
static int unichar_ispunct(dchar c) {
   return g_unichar_ispunct(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.)
// RETURNS: %TRUE if @c is a space character
// <c>: a Unicode character
static int unichar_isspace(dchar c) {
   return g_unichar_isspace(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.
// RETURNS: %TRUE if the character is titlecase
// <c>: a Unicode character
static int unichar_istitle(dchar c) {
   return g_unichar_istitle(c);
}


// Determines if a character is uppercase.
// RETURNS: %TRUE if @c is an uppercase character
// <c>: a Unicode character
static int unichar_isupper(dchar c) {
   return g_unichar_isupper(c);
}


// Determines if a character is typically rendered in a double-width
// cell.
// RETURNS: %TRUE if the character is wide
// <c>: a Unicode character
static int unichar_iswide(dchar c) {
   return g_unichar_iswide(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
// <ulink url="http://www.unicode.org/reports/tr11/">Unicode Standard
// Annex #11</ulink> 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
// pas both this test and g_unichar_iszerowidth().
// RETURNS: %TRUE if the character is wide in legacy East Asian locales
// <c>: a Unicode character
static int unichar_iswide_cjk(dchar c) {
   return g_unichar_iswide_cjk(c);
}


// Determines if a character is a hexidecimal digit.
// RETURNS: %TRUE if the character is a hexadecimal digit
// <c>: a Unicode character.
static int unichar_isxdigit(dchar c) {
   return g_unichar_isxdigit(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.
// RETURNS: %TRUE if the character has zero width
// <c>: a Unicode character
static int unichar_iszerowidth(dchar c) {
   return g_unichar_iszerowidth(c);
}


// Converts a single character to UTF-8.
// RETURNS: number of bytes written
// <c>: a Unicode character code
// <outbuf>: output buffer, must have at least 6 bytes of space. If %NULL, the length will be computed and returned and nothing will be written to @outbuf.
static int unichar_to_utf8(dchar c, char* outbuf) {
   return g_unichar_to_utf8(c, outbuf);
}


// Converts a character to lower case.
// 
// If @c is not an upperlower or titlecase character,
// or has no lowercase equivalent @c is returned unchanged.
// RETURNS: the result of converting @c to lower case.
// <c>: a Unicode character.
static dchar unichar_tolower(dchar c) {
   return g_unichar_tolower(c);
}


// Converts a character to the titlecase.
// 
// If @c is not an uppercase or lowercase character,
// @c is returned unchanged.
// RETURNS: the result of converting @c to titlecase.
// <c>: a Unicode character
static dchar unichar_totitle(dchar c) {
   return g_unichar_totitle(c);
}


// Converts a character to uppercase.
// 
// If @c is not an lowercase or titlecase character,
// or has no upper case equivalent @c is returned unchanged.
// RETURNS: the result of converting @c to uppercase.
// <c>: a Unicode character
static dchar unichar_toupper(dchar c) {
   return g_unichar_toupper(c);
}


// Classifies a Unicode character by type.
// RETURNS: the type of the character.
// <c>: a Unicode character
static UnicodeType unichar_type(dchar c) {
   return g_unichar_type(c);
}


// Checks whether @ch is a valid Unicode character. Some possible
// integer values of @ch will not be valid. 0 is considered a valid
// character, though it's normally a string terminator.
// RETURNS: %TRUE if @ch is a valid Unicode character
// <ch>: a Unicode character
static int unichar_validate(dchar ch) {
   return g_unichar_validate(ch);
}


// Determines the numeric value of a character as a hexidecimal
// digit.
// 
// g_unichar_isxdigit()), its numeric value. Otherwise, -1.
// RETURNS: If @c is a hex digit (according to
// <c>: a Unicode character
static int unichar_xdigit_value(dchar c) {
   return g_unichar_xdigit_value(c);
}


// Computes the canonical decomposition of a Unicode character.
// 
// @result_len is set to the resulting length of the string.
// 
// instead.
// RETURNS: a newly allocated string of Unicode characters.
// <ch>: a Unicode character.
// <result_len>: location to store the length of the return value.
static dchar* unicode_canonical_decomposition(dchar ch, size_t* result_len) {
   return g_unicode_canonical_decomposition(ch, result_len);
}


// 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>: a UCS-4 encoded string.
// <len>: the maximum length of @string to use.
static void unicode_canonical_ordering(dchar* string_, size_t len) {
   g_unicode_canonical_ordering(string_, len);
}


// 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 <ulink url="http://unicode.org/iso15924/codelists.html">Codes for the
// representation of names of scripts</ulink> for details.
// 
// of %G_UNICODE_SCRIPT_INVALID_CODE if @iso15924 is zero and
// %G_UNICODE_SCRIPT_UNKNOWN if @iso15924 is unknown.
// RETURNS: the Unicode script for @iso15924, or
// <iso15924>: a Unicode script
static UnicodeScript unicode_script_from_iso15924(uint iso15924) {
   return g_unicode_script_from_iso15924(iso15924);
}


// 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 <ulink url="http://unicode.org/iso15924/codelists.html">Codes for the
// representation of names of scripts</ulink> for details.
// 
// of zero if @script is %G_UNICODE_SCRIPT_INVALID_CODE or
// ISO 15924 code 'Zzzz' (script code for UNKNOWN) if @script is not understood.
// RETURNS: the ISO 15924 code for @script, encoded as an integer,
// <script>: a Unicode script
static uint unicode_script_to_iso15924(UnicodeScript script) {
   return g_unicode_script_to_iso15924(script);
}


// 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.
// 
// occurred
// RETURNS: 0 if the name was successfully deleted, -1 if an error
// <filename>: a pathname in the GLib file name encoding (UTF-8 on Windows)
static int unlink(char* filename) {
   return g_unlink(filename);
}


// 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.
// Furthermore, this function can't be guaranteed to operate in a
// threadsafe way.
// <variable>: the environment variable to remove, must not contain '='.
static void unsetenv(char* variable) {
   g_unsetenv(variable);
}


// Escapes a string for use in a URI.
// 
// Normally all characters that are not "unreserved" (i.e. ASCII alphanumerical
// characters plus dash, dot, underscore and tilde) are escaped.
// But if you specify characters in @reserved_chars_allowed they are not
// escaped. This is useful for the "reserved" characters in the URI
// specification, since those are allowed unescaped in some portions of
// a URI.
// 
// freed when no longer needed.
// RETURNS: an escaped version of @unescaped. The returned string should be
// <unescaped>: the unescaped input string.
// <reserved_chars_allowed>: a string of reserved characters that are allowed to be used, or %NULL.
// <allow_utf8>: %TRUE if the result can include UTF-8 characters.
static char* /*new*/ uri_escape_string(char* unescaped, char* reserved_chars_allowed, int allow_utf8) {
   return g_uri_escape_string(unescaped, reserved_chars_allowed, allow_utf8);
}


// Unintrospectable function: uri_list_extract_uris() / g_uri_list_extract_uris()
// 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.
// 
// strings holding the individual URIs. The array should
// be freed with g_strfreev().
// RETURNS: a newly allocated %NULL-terminated list of
// <uri_list>: an URI list
static char** uri_list_extract_uris(char* uri_list) {
   return g_uri_list_extract_uris(uri_list);
}


// Gets the scheme portion of a URI string. RFC 3986 decodes the scheme as:
// <programlisting>
// URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
// </programlisting>
// Common schemes include "file", "http", "svn+ssh", etc.
// 
// The returned string should be freed when no longer needed.
// RETURNS: The "Scheme" component of the URI, or %NULL on error.
// <uri>: a valid URI.
static char* /*new*/ uri_parse_scheme(char* uri) {
   return g_uri_parse_scheme(uri);
}


// Unescapes a segment of an escaped string.
// 
// If any of the characters in @illegal_characters or the character zero appears
// as an escaped character in @escaped_string then that is an error and %NULL
// will be returned. This is useful it you want to avoid for instance having a
// slash being expanded in an escaped path element, which might confuse pathname
// handling.
// 
// The returned string should be freed when no longer needed.
// RETURNS: an unescaped version of @escaped_string or %NULL on error.
// <escaped_string>: a string.
// <escaped_string_end>: a string.
// <illegal_characters>: an optional string of illegal characters not to be allowed.
static char* /*new*/ uri_unescape_segment(char* escaped_string, char* escaped_string_end, char* illegal_characters) {
   return g_uri_unescape_segment(escaped_string, escaped_string_end, illegal_characters);
}


// Unescapes a whole escaped string.
// 
// If any of the characters in @illegal_characters or the character zero appears
// as an escaped character in @escaped_string then that is an error and %NULL
// will be returned. This is useful it you want to avoid for instance having a
// slash being expanded in an escaped path element, which might confuse pathname
// handling.
// 
// should be freed when no longer needed.
// RETURNS: an unescaped version of @escaped_string. The returned string
// <escaped_string>: an escaped string to be unescaped.
// <illegal_characters>: an optional string of illegal characters not to be allowed.
static char* /*new*/ uri_unescape_string(char* escaped_string, char* illegal_characters) {
   return g_uri_unescape_string(escaped_string, illegal_characters);
}

static void usleep(c_ulong microseconds) {
   g_usleep(microseconds);
}


// Convert a string from UTF-16 to UCS-4. The result will be
// nul-terminated.
// 
// This value must be freed with g_free(). If an
// error occurs, %NULL will be returned and
// @error set.
// RETURNS: a pointer to a newly allocated UCS-4 string.
// <str>: a UTF-16 encoded string
// <len>: the maximum length (number of <type>gunichar2</type>) of @str to use. If @len < 0, then the string is nul-terminated.
// <items_read>: location to store number of words read, or %NULL. If %NULL, then %G_CONVERT_ERROR_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.
// <items_written>: location to store number of characters written, or %NULL. The value stored here does not include the trailing 0 character.
static dchar* utf16_to_ucs4(wchar* str, c_long len, c_long* items_read, c_long* items_written, GLib2.Error** error=null) {
   return g_utf16_to_ucs4(str, len, items_read, items_written, error);
}


// Convert a string from UTF-16 to UTF-8. The result will be
// terminated with a 0 byte.
// 
// Note that the input is expected to be already in native endianness,
// an initial byte-order-mark character is not handled specially.
// g_convert() can be used to convert a byte buffer of UTF-16 data of
// ambiguous endianess.
// 
// Further note that this function does not validate the result
// string; it may e.g. 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
// things unpaired surrogates.
// 
// This value must be freed with g_free(). If an
// error occurs, %NULL will be returned and
// @error set.
// RETURNS: a pointer to a newly allocated UTF-8 string.
// <str>: a UTF-16 encoded string
// <len>: the maximum length (number of <type>gunichar2</type>) of @str to use. If @len < 0, then the string is nul-terminated.
// <items_read>: location to store number of words read, or %NULL. If %NULL, then %G_CONVERT_ERROR_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.
// <items_written>: location to store number of bytes written, or %NULL. The value stored here does not include the trailing 0 byte.
static char* /*new*/ utf16_to_utf8(wchar* str, c_long len, c_long* items_read, c_long* items_written, GLib2.Error** error=null) {
   return g_utf16_to_utf8(str, len, items_read, items_written, error);
}


// 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.
// 
// case independent form of @str.
// RETURNS: a newly allocated string, that is a
// <str>: a UTF-8 encoded string
// <len>: length of @str, in bytes, or -1 if @str is nul-terminated.
static char* /*new*/ utf8_casefold(char* str, ssize_t len) {
   return g_utf8_casefold(str, len);
}


// Compares two strings for ordering using the linguistically
// correct rules for the <link linkend="setlocale">current locale</link>.
// 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.
// 
// 0 if they compare equal, &gt; 0 if @str1 compares after @str2.
// RETURNS: &lt; 0 if @str1 compares before @str2,
// <str1>: a UTF-8 encoded string
// <str2>: a UTF-8 encoded string
static int utf8_collate(char* str1, char* str2) {
   return g_utf8_collate(str1, str2);
}


// 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
// <link linkend="setlocale">current locale</link>.
// 
// be freed with g_free() when you are done with it.
// RETURNS: a newly allocated string. This string should
// <str>: a UTF-8 encoded string.
// <len>: length of @str, in bytes, or -1 if @str is nul-terminated.
static char* /*new*/ utf8_collate_key(char* str, ssize_t len) {
   return g_utf8_collate_key(str, 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
// <link linkend="setlocale">current locale</link>.
// 
// be freed with g_free() when you are done with it.
// RETURNS: a newly allocated string. This string should
// <str>: a UTF-8 encoded string.
// <len>: length of @str, in bytes, or -1 if @str is nul-terminated.
static char* /*new*/ utf8_collate_key_for_filename(char* str, ssize_t len) {
   return g_utf8_collate_key_for_filename(str, len);
}


// 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.
// RETURNS: a pointer to the found character or %NULL
// <p>: a pointer to a position within a UTF-8 encoded string
// <end>: a pointer to the byte following the end of the string, or %NULL to indicate that the string is nul-terminated.
static char* /*new*/ utf8_find_next_char(char* p, char* end) {
   return g_utf8_find_next_char(p, end);
}


// Given a position @p with a UTF-8 encoded string @str, find the start
// of the previous UTF-8 character starting before @p. Returns %NULL if no
// UTF-8 characters are present in @str before @p.
// 
// @p does not have to be at the beginning of a UTF-8 character. No check
// is made to see if the character found is actually valid other than
// it starts with an appropriate byte.
// RETURNS: a pointer to the found character or %NULL.
// <str>: pointer to the beginning of a UTF-8 encoded string
// <p>: pointer to some position within @str
static char* /*new*/ utf8_find_prev_char(char* str, char* p) {
   return g_utf8_find_prev_char(str, p);
}


// Converts a sequence of bytes encoded as UTF-8 to a Unicode character.
// If @p does not point to a valid UTF-8 encoded character, results are
// undefined. If you are not sure that the bytes are complete
// valid Unicode characters, you should use g_utf8_get_char_validated()
// instead.
// RETURNS: the resulting character
// <p>: a pointer to Unicode character encoded as UTF-8
static dchar utf8_get_char(char* p) {
   return g_utf8_get_char(p);
}


// 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.
// 
// 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.
// RETURNS: the resulting character. If @p points to a partial
// <p>: a pointer to Unicode character encoded as UTF-8
// <max_len>: the maximum number of bytes to read, or -1, for no maximum or if @p is nul-terminated
static dchar utf8_get_char_validated(char* p, ssize_t max_len) {
   return g_utf8_get_char_validated(p, max_len);
}


// 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.
// 
// normalized form of @str, or %NULL if @str is not
// valid UTF-8.
// RETURNS: a newly allocated string, that is the
// <str>: a UTF-8 encoded string.
// <len>: length of @str, in bytes, or -1 if @str is nul-terminated.
// <mode>: the type of normalization to perform.
static char* /*new*/ utf8_normalize(char* str, ssize_t len, NormalizeMode mode) {
   return g_utf8_normalize(str, len, mode);
}


// Converts from an integer character offset to a pointer to a position
// within the string.
// 
// Since 2.10, this function allows to pass a negative @offset to
// step backwards. It is usually worth stepping backwards from the end
// instead of forwards if @offset is in the last fourth of the string,
// since moving forward is about 3 times faster than moving backward.
// 
// <note><para>
// This function doesn't abort when reaching the end of @str. Therefore
// you should be sure that @offset is within string boundaries before
// calling that function. Call g_utf8_strlen() when unsure.
// 
// This limitation exists as this function is called frequently during
// text rendering and therefore has to be as fast as possible.
// </para></note>
// RETURNS: the resulting pointer
// <str>: a UTF-8 encoded string
// <offset>: a character offset within @str
static char* /*new*/ utf8_offset_to_pointer(char* str, c_long offset) {
   return g_utf8_offset_to_pointer(str, offset);
}


// Converts from a pointer to position within a string to a integer
// character offset.
// 
// Since 2.10, this function allows @pos to be before @str, and returns
// a negative offset in this case.
// RETURNS: the resulting character offset
// <str>: a UTF-8 encoded string
// <pos>: a pointer to a position within @str
static c_long utf8_pointer_to_offset(char* str, char* pos) {
   return g_utf8_pointer_to_offset(str, pos);
}


// Finds the previous UTF-8 character in the string before @p.
// 
// @p does not have to be at the beginning of a UTF-8 character. No check
// is made to see if the character found is actually valid other than
// it starts with an appropriate byte. If @p might be the first
// character of the string, you must use g_utf8_find_prev_char() instead.
// RETURNS: a pointer to the found character.
// <p>: a pointer to a position within a UTF-8 encoded string
static char* /*new*/ utf8_prev_char(char* p) {
   return g_utf8_prev_char(p);
}


// 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.
// 
// otherwise, a pointer to the start of the leftmost occurrence of
// the character in the string.
// RETURNS: %NULL if the string does not contain the character,
// <p>: a nul-terminated UTF-8 encoded string
// <len>: the maximum length of @p
// <c>: a Unicode character
static char* /*new*/ utf8_strchr(char* p, ssize_t len, dchar c) {
   return g_utf8_strchr(p, len, c);
}


// 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.
// 
// converted to lowercase.
// RETURNS: a newly allocated string, with all characters
// <str>: a UTF-8 encoded string
// <len>: length of @str, in bytes, or -1 if @str is nul-terminated.
static char* /*new*/ utf8_strdown(char* str, ssize_t len) {
   return g_utf8_strdown(str, len);
}


// Computes the length of the string in characters, not including
// the terminating nul character.
// RETURNS: the length of the string in characters
// <p>: pointer to the start of a UTF-8 encoded string
// <max>: the maximum number of bytes to examine. If @max is less than 0, then the string is assumed to be nul-terminated. If @max is 0, @p will not be examined and may be %NULL.
static c_long utf8_strlen(char* p, ssize_t max) {
   return g_utf8_strlen(p, max);
}


// Like the standard C strncpy() function, but
// copies a given number of characters instead of a given number of
// bytes. The @src string must be valid UTF-8 encoded text.
// (Use g_utf8_validate() on all text before trying to use UTF-8
// utility functions with it.)
// RETURNS: @dest
// <dest>: buffer to fill with characters from @src
// <src>: UTF-8 encoded string
// <n>: character count
static char* /*new*/ utf8_strncpy(char* dest, char* src, size_t n) {
   return g_utf8_strncpy(dest, src, n);
}


// 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.
// 
// otherwise, a pointer to the start of the rightmost occurrence of the
// character in the string.
// RETURNS: %NULL if the string does not contain the character,
// <p>: a nul-terminated UTF-8 encoded string
// <len>: the maximum length of @p
// <c>: a Unicode character
static char* /*new*/ utf8_strrchr(char* p, ssize_t len, dchar c) {
   return g_utf8_strrchr(p, len, c);
}


// Reverses a UTF-8 string. @str must be valid UTF-8 encoded text.
// (Use g_utf8_validate() on all text before trying to use UTF-8
// utility functions with it.)
// 
// This function is intended for programmatic uses of reversed strings.
// It pays no attention to decomposed characters, combining marks, byte
// order marks, directional indicators (LRM, LRO, etc) and similar
// characters which might need special handling when reversing a string
// for display purposes.
// 
// Note that unlike g_strreverse(), this function returns
// newly-allocated memory, which should be freed with g_free() when
// no longer needed.
// RETURNS: a newly-allocated string which is the reverse of @str.
// <str>: a UTF-8 encoded string
// <len>: the maximum length of @str to use, in bytes. If @len < 0, then the string is nul-terminated.
static char* /*new*/ utf8_strreverse(char* str, ssize_t len) {
   return g_utf8_strreverse(str, 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.)
// 
// converted to uppercase.
// RETURNS: a newly allocated string, with all characters
// <str>: a UTF-8 encoded string
// <len>: length of @str, in bytes, or -1 if @str is nul-terminated.
static char* /*new*/ utf8_strup(char* str, ssize_t len) {
   return g_utf8_strup(str, len);
}


// Copies a substring out of a UTF-8 encoded string.
// The substring will contain @end_pos - @start_pos
// characters.
// 
// substring. Free with g_free() when no longer needed.
// RETURNS: a newly allocated copy of the requested
// <str>: a UTF-8 encoded string
// <start_pos>: a character offset within @str
// <end_pos>: another character offset within @str
static char* /*new*/ utf8_substring(char* str, c_long start_pos, c_long end_pos) {
   return g_utf8_substring(str, start_pos, end_pos);
}


// Convert a string from UTF-8 to a 32-bit fixed width
// representation as UCS-4. A trailing 0 character will be added to the
// string after the converted text.
// 
// This value must be freed with g_free(). If an
// error occurs, %NULL will be returned and
// @error set.
// RETURNS: a pointer to a newly allocated UCS-4 string.
// <str>: a UTF-8 encoded string
// <len>: the maximum length of @str to use, in bytes. If @len < 0, then the string is nul-terminated.
// <items_read>: location to store number of bytes read, or %NULL. If %NULL, then %G_CONVERT_ERROR_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.
// <items_written>: location to store number of characters written or %NULL. The value here stored does not include the trailing 0 character.
static dchar* utf8_to_ucs4(char* str, c_long len, c_long* items_read, c_long* items_written, GLib2.Error** error=null) {
   return g_utf8_to_ucs4(str, len, items_read, items_written, error);
}


// 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 g_utf8_to_ucs4()
// but does no error checking on the input. A trailing 0 character
// will be added to the string after the converted text.
// 
// This value must be freed with g_free().
// RETURNS: a pointer to a newly allocated UCS-4 string.
// <str>: a UTF-8 encoded string
// <len>: the maximum length of @str to use, in bytes. If @len < 0, then the string is nul-terminated.
// <items_written>: location to store the number of characters in the result, or %NULL.
static dchar* utf8_to_ucs4_fast(char* str, c_long len, c_long* items_written) {
   return g_utf8_to_ucs4_fast(str, len, items_written);
}


// Convert a string from UTF-8 to UTF-16. A 0 character will be
// added to the result after the converted text.
// 
// This value must be freed with g_free(). If an
// error occurs, %NULL will be returned and
// @error set.
// RETURNS: a pointer to a newly allocated UTF-16 string.
// <str>: a UTF-8 encoded string
// <len>: the maximum length (number of bytes) of @str to use. If @len < 0, then the string is nul-terminated.
// <items_read>: location to store number of bytes read, or %NULL. If %NULL, then %G_CONVERT_ERROR_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.
// <items_written>: location to store number of <type>gunichar2</type> written, or %NULL. The value stored here does not include the trailing 0.
static wchar* utf8_to_utf16(char* str, c_long len, c_long* items_read, c_long* items_written, GLib2.Error** error=null) {
   return g_utf8_to_utf16(str, len, items_read, items_written, error);
}


// Validates UTF-8 encoded text. @str is the text to validate;
// if @str is nul-terminated, then @max_len can be -1, otherwise
// @max_len should be the number of bytes to validate.
// If @end is non-%NULL, then the end of the valid range
// will be stored there (i.e. the start of the first invalid
// character if some bytes were invalid, or the end of the text
// being validated otherwise).
// 
// Note that g_utf8_validate() returns %FALSE if @max_len is
// positive and NUL is met before @max_len bytes have been read.
// 
// Returns %TRUE if all of @str was valid. Many GLib and GTK+
// routines <emphasis>require</emphasis> valid UTF-8 as input;
// so data read from a file or the network should be checked
// with g_utf8_validate() before doing anything else with it.
// RETURNS: %TRUE if the text was valid UTF-8
// <str>: a pointer to character data
// <max_len>: max bytes to validate, or -1 to go until NUL
// <end>: return location for end of valid data
static int utf8_validate(char* str, ssize_t max_len, /*out*/ char** end=null) {
   return g_utf8_validate(str, max_len, end);
}

static Type variant_get_gtype() {
   return g_variant_get_gtype();
}


// Determines the type of @value.
// 
// The return value is valid for the lifetime of @value and must not
// be freed.
// RETURNS: a #GVariantType
// <value>: a #GVariant
static VariantType* variant_get_type(Variant* value) {
   return g_variant_get_type(value);
}


// 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.
// RETURNS: %TRUE if @string is a D-Bus object path
// <string>: a normal C nul-terminated string
static int variant_is_object_path(char* string_) {
   return g_variant_is_object_path(string_);
}


// Determines if a given string is a valid D-Bus type signature.  You
// should ensure that a string is a valid D-Bus type signature before
// passing it to g_variant_new_signature().
// 
// D-Bus type signatures consist of zero or more definite #GVariantType
// strings in sequence.
// RETURNS: %TRUE if @string is a D-Bus type signature
// <string>: a normal C nul-terminated string
static int variant_is_signature(char* string_) {
   return g_variant_is_signature(string_);
}


// Parses a #GVariant from a text representation.
// 
// A single #GVariant is parsed from the content of @text.
// 
// The format is described <link linkend='gvariant-text'>here</link>.
// 
// 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 @endptr is %NULL and there is extra data
// then an error is returned.
// 
// If @type is 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.
// 
// 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 g_variant_print()".
// <type>: a #GVariantType, or %NULL
// <text>: a string containing a GVariant in text form
// <limit>: a pointer to the end of @text, or %NULL
// <endptr>: a location to store the end pointer, or %NULL
static Variant* /*new*/ variant_parse(VariantType* type, char* text, char* limit, char** endptr, GLib2.Error** error=null) {
   return g_variant_parse(type, text, limit, endptr, error);
}

static Quark variant_parser_get_error_quark() {
   return g_variant_parser_get_error_quark();
}

static VariantType* variant_type_checked_(char* arg_a) {
   return g_variant_type_checked_(arg_a);
}


// Checks if @type_string is a valid GVariant type string.  This call is
// equivalent to calling g_variant_type_string_scan() and confirming
// that the following character is a nul terminator.
// 
// Since 2.24
// RETURNS: %TRUE if @type_string is exactly one valid type string
// <type_string>: a pointer to any string
static int variant_type_string_is_valid(char* type_string) {
   return g_variant_type_string_is_valid(type_string);
}


// 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 g_variant_type_string_is_valid().
// RETURNS: %TRUE if a valid type string was found
// <string>: a pointer to any string
// <limit>: the end of @string, or %NULL
// <endptr>: location to store the end pointer, or %NULL
static int variant_type_string_scan(char* string_, char* limit=null, /*out*/ char** endptr=null) {
   return g_variant_type_string_scan(string_, limit, endptr);
}


// Unintrospectable function: vasprintf() / g_vasprintf()
// An implementation of the GNU vasprintf() function which supports
// positional parameters, as specified in the Single Unix Specification.
// This function is similar to g_vsprintf(), except that it allocates a
// string to hold the output, instead of putting the output in a buffer
// you allocate in advance.
// RETURNS: the number of bytes printed.
// <string>: the return location for the newly-allocated string.
// <format>: a standard printf() format string, but notice <link linkend="string-precision">string precision pitfalls</link>.
// <args>: the list of arguments to insert in the output.
static int vasprintf(char** string_, char* format, va_list args) {
   return g_vasprintf(string_, format, args);
}


// Unintrospectable function: vfprintf() / g_vfprintf()
// An implementation of the standard fprintf() function which supports
// positional parameters, as specified in the Single Unix Specification.
// RETURNS: the number of bytes printed.
// <file>: the stream to write to.
// <format>: a standard printf() format string, but notice <link linkend="string-precision">string precision pitfalls</link>.
// <args>: the list of arguments to insert in the output.
static int vfprintf(FILE* file, char* format, va_list args) {
   return g_vfprintf(file, format, args);
}


// Unintrospectable function: vprintf() / g_vprintf()
// An implementation of the standard vprintf() function which supports
// positional parameters, as specified in the Single Unix Specification.
// RETURNS: the number of bytes printed.
// <format>: a standard printf() format string, but notice <link linkend="string-precision">string precision pitfalls</link>.
// <args>: the list of arguments to insert in the output.
static int vprintf(char* format, va_list args) {
   return g_vprintf(format, args);
}


// Unintrospectable function: vsnprintf() / g_vsnprintf()
// A safer form of the standard vsprintf() function. The output is guaranteed
// to not exceed @n characters (including the terminating nul character), so
// it is easy to ensure that a buffer overflow cannot occur.
// 
// See also g_strdup_vprintf().
// 
// 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_vsnprintf() conforms to the vsnprintf() function
// as standardized in ISO C99. Note that this is different from traditional
// vsnprintf(), which returns the length of the output string.
// 
// The format string may contain positional parameters, as specified in
// the Single Unix Specification.
// 
// was large enough.
// RETURNS: the number of bytes which would be produced if the buffer
// <string>: the buffer to hold the output.
// <n>: the maximum number of bytes to produce (including the terminating nul character).
// <format>: a standard printf() format string, but notice <link linkend="string-precision">string precision pitfalls</link>.
// <args>: the list of arguments to insert in the output.
static int vsnprintf(char* string_, c_ulong n, char* format, va_list args) {
   return g_vsnprintf(string_, n, format, args);
}


// Unintrospectable function: vsprintf() / g_vsprintf()
// An implementation of the standard vsprintf() function which supports
// positional parameters, as specified in the Single Unix Specification.
// RETURNS: the number of bytes printed.
// <string>: the buffer to hold the output.
// <format>: a standard printf() format string, but notice <link linkend="string-precision">string precision pitfalls</link>.
// <args>: the list of arguments to insert in the output.
static int vsprintf(char* string_, char* format, va_list args) {
   return g_vsprintf(string_, format, args);
}

static void warn_message(char* domain, char* file, int line, char* func, char* warnexpr) {
   g_warn_message(domain, file, line, func, warnexpr);
}


// C prototypes:

extern (C) {
void g_allocator_free(Allocator* this_);
Allocator* g_allocator_new(char* name, uint n_preallocs);
Array* g_array_append_vals(Array* array, const(void)* data, uint len);
char* /*new*/ g_array_free(Array* array, int free_segment);
uint g_array_get_element_size(Array* array);
Array* g_array_insert_vals(Array* array, uint index_, const(void)* data, uint len);
Array* g_array_new(int zero_terminated, int clear_, uint element_size);
Array* g_array_prepend_vals(Array* array, const(void)* data, uint len);
Array* g_array_ref(Array* array);
Array* g_array_remove_index(Array* array, uint index_);
Array* g_array_remove_index_fast(Array* array, uint index_);
Array* g_array_remove_range(Array* array, uint index_, uint length);
Array* g_array_set_size(Array* array, uint length);
Array* g_array_sized_new(int zero_terminated, int clear_, uint element_size, uint reserved_size);
void g_array_sort(Array* array, CompareFunc compare_func);
void g_array_sort_with_data(Array* array, CompareDataFunc compare_func, void* user_data);
void g_array_unref(Array* array);
int g_async_queue_length(AsyncQueue* this_);
int g_async_queue_length_unlocked(AsyncQueue* this_);
void g_async_queue_lock(AsyncQueue* this_);
void* g_async_queue_pop(AsyncQueue* this_);
void* g_async_queue_pop_unlocked(AsyncQueue* this_);
void g_async_queue_push(AsyncQueue* this_, void* data);
void g_async_queue_push_sorted(AsyncQueue* this_, void* data, CompareDataFunc func, void* user_data);
void g_async_queue_push_sorted_unlocked(AsyncQueue* this_, void* data, CompareDataFunc func, void* user_data);
void g_async_queue_push_unlocked(AsyncQueue* this_, void* data);
AsyncQueue* g_async_queue_ref(AsyncQueue* this_);
void g_async_queue_ref_unlocked(AsyncQueue* this_);
void g_async_queue_sort(AsyncQueue* this_, CompareDataFunc func, void* user_data);
void g_async_queue_sort_unlocked(AsyncQueue* this_, CompareDataFunc func, void* user_data);
void* g_async_queue_timed_pop(AsyncQueue* this_, TimeVal* end_time);
void* g_async_queue_timed_pop_unlocked(AsyncQueue* this_, TimeVal* end_time);
void* g_async_queue_try_pop(AsyncQueue* this_);
void* g_async_queue_try_pop_unlocked(AsyncQueue* this_);
void g_async_queue_unlock(AsyncQueue* this_);
void g_async_queue_unref(AsyncQueue* this_);
void g_async_queue_unref_and_unlock(AsyncQueue* this_);
AsyncQueue* g_async_queue_new();
AsyncQueue* g_async_queue_new_full(DestroyNotify item_free_func);
void g_bookmark_file_add_application(BookmarkFile* this_, char* uri, char* name, char* exec);
void g_bookmark_file_add_group(BookmarkFile* this_, char* uri, char* group);
void g_bookmark_file_free(BookmarkFile* this_);
time_t g_bookmark_file_get_added(BookmarkFile* this_, char* uri, GLib2.Error** error);
int g_bookmark_file_get_app_info(BookmarkFile* this_, char* uri, char* name, char** exec, uint* count, time_t* stamp, GLib2.Error** error);
char** g_bookmark_file_get_applications(BookmarkFile* this_, char* uri, size_t* length, GLib2.Error** error);
char* /*new*/ g_bookmark_file_get_description(BookmarkFile* this_, char* uri, GLib2.Error** error);
char** g_bookmark_file_get_groups(BookmarkFile* this_, char* uri, size_t* length, GLib2.Error** error);
int g_bookmark_file_get_icon(BookmarkFile* this_, char* uri, char** href, char** mime_type, GLib2.Error** error);
int g_bookmark_file_get_is_private(BookmarkFile* this_, char* uri, GLib2.Error** error);
char* /*new*/ g_bookmark_file_get_mime_type(BookmarkFile* this_, char* uri, GLib2.Error** error);
time_t g_bookmark_file_get_modified(BookmarkFile* this_, char* uri, GLib2.Error** error);
int g_bookmark_file_get_size(BookmarkFile* this_);
char* /*new*/ g_bookmark_file_get_title(BookmarkFile* this_, char* uri, GLib2.Error** error);
char** g_bookmark_file_get_uris(BookmarkFile* this_, size_t* length);
time_t g_bookmark_file_get_visited(BookmarkFile* this_, char* uri, GLib2.Error** error);
int g_bookmark_file_has_application(BookmarkFile* this_, char* uri, char* name, GLib2.Error** error);
int g_bookmark_file_has_group(BookmarkFile* this_, char* uri, char* group, GLib2.Error** error);
int g_bookmark_file_has_item(BookmarkFile* this_, char* uri);
int g_bookmark_file_load_from_data(BookmarkFile* this_, char* data, size_t length, GLib2.Error** error);
int g_bookmark_file_load_from_data_dirs(BookmarkFile* this_, char* file, char** full_path, GLib2.Error** error);
int g_bookmark_file_load_from_file(BookmarkFile* this_, char* filename, GLib2.Error** error);
int g_bookmark_file_move_item(BookmarkFile* this_, char* old_uri, char* new_uri, GLib2.Error** error);
int g_bookmark_file_remove_application(BookmarkFile* this_, char* uri, char* name, GLib2.Error** error);
int g_bookmark_file_remove_group(BookmarkFile* this_, char* uri, char* group, GLib2.Error** error);
int g_bookmark_file_remove_item(BookmarkFile* this_, char* uri, GLib2.Error** error);
void g_bookmark_file_set_added(BookmarkFile* this_, char* uri, time_t added);
int g_bookmark_file_set_app_info(BookmarkFile* this_, char* uri, char* name, char* exec, int count, time_t stamp, GLib2.Error** error);
void g_bookmark_file_set_description(BookmarkFile* this_, char* uri, char* description);
void g_bookmark_file_set_groups(BookmarkFile* this_, char* uri, char** groups, size_t length);
void g_bookmark_file_set_icon(BookmarkFile* this_, char* uri, char* href, char* mime_type);
void g_bookmark_file_set_is_private(BookmarkFile* this_, char* uri, int is_private);
void g_bookmark_file_set_mime_type(BookmarkFile* this_, char* uri, char* mime_type);
void g_bookmark_file_set_modified(BookmarkFile* this_, char* uri, time_t modified);
void g_bookmark_file_set_title(BookmarkFile* this_, char* uri, char* title);
void g_bookmark_file_set_visited(BookmarkFile* this_, char* uri, time_t visited);
char* /*new*/ g_bookmark_file_to_data(BookmarkFile* this_, size_t* length, GLib2.Error** error);
int g_bookmark_file_to_file(BookmarkFile* this_, char* filename, GLib2.Error** error);
Quark g_bookmark_file_error_quark();
BookmarkFile* g_bookmark_file_new();
ByteArray* g_byte_array_append(ByteArray* array, ubyte* data, uint len);
ubyte* g_byte_array_free(ByteArray* array, int free_segment);
ByteArray* g_byte_array_new();
ByteArray* g_byte_array_prepend(ByteArray* array, ubyte* data, uint len);
ByteArray* g_byte_array_ref(ByteArray* array);
ByteArray* g_byte_array_remove_index(ByteArray* array, uint index_);
ByteArray* g_byte_array_remove_index_fast(ByteArray* array, uint index_);
ByteArray* g_byte_array_remove_range(ByteArray* array, uint index_, uint length);
ByteArray* g_byte_array_set_size(ByteArray* array, uint length);
ByteArray* g_byte_array_sized_new(uint reserved_size);
void g_byte_array_sort(ByteArray* array, CompareFunc compare_func);
void g_byte_array_sort_with_data(ByteArray* array, CompareDataFunc compare_func, void* user_data);
void g_byte_array_unref(ByteArray* array);
void g_cache_destroy(Cache* this_);
void* g_cache_insert(Cache* this_, void* key);
void g_cache_key_foreach(Cache* this_, HFunc func, void* user_data);
void g_cache_remove(Cache* this_, const(void)* value);
void g_cache_value_foreach(Cache* this_, HFunc func, void* user_data);
Cache* g_cache_new(CacheNewFunc value_new_func, CacheDestroyFunc value_destroy_func, CacheDupFunc key_dup_func, CacheDestroyFunc key_destroy_func, HashFunc hash_key_func, HashFunc hash_value_func, EqualFunc key_equal_func);
Checksum* g_checksum_copy(Checksum* this_);
void g_checksum_free(Checksum* this_);
void g_checksum_get_digest(Checksum* this_, ubyte* buffer, size_t* digest_len);
char* g_checksum_get_string(Checksum* this_);
void g_checksum_reset(Checksum* this_);
void g_checksum_update(Checksum* this_, ubyte* data, ssize_t length);
Checksum* g_checksum_new(ChecksumType checksum_type);
ssize_t g_checksum_type_get_length(ChecksumType checksum_type);
void g_completion_add_items(Completion* this_, GLib2.List* items);
void g_completion_clear_items(Completion* this_);
GLib2.List* g_completion_complete(Completion* this_, char* prefix, char** new_prefix);
GLib2.List* g_completion_complete_utf8(Completion* this_, char* prefix, char** new_prefix);
void g_completion_free(Completion* this_);
void g_completion_remove_items(Completion* this_, GLib2.List* items);
void g_completion_set_compare(Completion* this_, CompletionStrncmpFunc strncmp_func);
Completion* g_completion_new(CompletionFunc func);
Date* /*new*/ g_date_new();
Date* /*new*/ g_date_new_dmy(DateDay day, DateMonth month, DateYear year);
Date* /*new*/ g_date_new_julian(uint julian_day);
void g_date_add_days(Date* this_, uint n_days);
void g_date_add_months(Date* this_, uint n_months);
void g_date_add_years(Date* this_, uint n_years);
void g_date_clamp(Date* this_, Date* min_date, Date* max_date);
void g_date_clear(Date* this_, uint n_dates);
int g_date_compare(Date* this_, Date* rhs);
int g_date_days_between(Date* this_, Date* date2);
void g_date_free(Date* this_);
DateDay g_date_get_day(Date* this_);
uint g_date_get_day_of_year(Date* this_);
uint g_date_get_iso8601_week_of_year(Date* this_);
uint g_date_get_julian(Date* this_);
uint g_date_get_monday_week_of_year(Date* this_);
DateMonth g_date_get_month(Date* this_);
uint g_date_get_sunday_week_of_year(Date* this_);
DateWeekday g_date_get_weekday(Date* this_);
DateYear g_date_get_year(Date* this_);
int g_date_is_first_of_month(Date* this_);
int g_date_is_last_of_month(Date* this_);
void g_date_order(Date* this_, Date* date2);
void g_date_set_day(Date* this_, DateDay day);
void g_date_set_dmy(Date* this_, DateDay day, DateMonth month, DateYear y);
void g_date_set_julian(Date* this_, uint julian_date);
void g_date_set_month(Date* this_, DateMonth month);
void g_date_set_parse(Date* this_, char* str);
void g_date_set_time(Date* this_, Time time_);
void g_date_set_time_t(Date* this_, time_t timet);
void g_date_set_time_val(Date* this_, TimeVal* timeval);
void g_date_set_year(Date* this_, DateYear year);
void g_date_subtract_days(Date* this_, uint n_days);
void g_date_subtract_months(Date* this_, uint n_months);
void g_date_subtract_years(Date* this_, uint n_years);
void g_date_to_struct_tm(Date* this_, void** tm);
int g_date_valid(Date* this_);
ubyte g_date_get_days_in_month(DateMonth month, DateYear year);
ubyte g_date_get_monday_weeks_in_year(DateYear year);
ubyte g_date_get_sunday_weeks_in_year(DateYear year);
int g_date_is_leap_year(DateYear year);
size_t g_date_strftime(char* s, size_t slen, char* format, Date* date);
int g_date_valid_day(DateDay day);
int g_date_valid_dmy(DateDay day, DateMonth month, DateYear year);
int g_date_valid_julian(uint julian_date);
int g_date_valid_month(DateMonth month);
int g_date_valid_weekday(DateWeekday weekday);
int g_date_valid_year(DateYear year);
DateTime* /*new*/ g_date_time_new(TimeZone* tz, int year, int month, int day, int hour, int minute, double seconds);
DateTime* /*new*/ g_date_time_new_from_timeval_local(TimeVal* tv);
DateTime* /*new*/ g_date_time_new_from_timeval_utc(TimeVal* tv);
DateTime* /*new*/ g_date_time_new_from_unix_local(long t);
DateTime* /*new*/ g_date_time_new_from_unix_utc(long t);
DateTime* /*new*/ g_date_time_new_local(int year, int month, int day, int hour, int minute, double seconds);
DateTime* /*new*/ g_date_time_new_now(TimeZone* tz);
DateTime* /*new*/ g_date_time_new_now_local();
DateTime* /*new*/ g_date_time_new_now_utc();
DateTime* /*new*/ g_date_time_new_utc(int year, int month, int day, int hour, int minute, double seconds);
DateTime* /*new*/ g_date_time_add(DateTime* this_, TimeSpan timespan);
DateTime* /*new*/ g_date_time_add_days(DateTime* this_, int days);
DateTime* /*new*/ g_date_time_add_full(DateTime* this_, int years, int months, int days, int hours, int minutes, double seconds);
DateTime* /*new*/ g_date_time_add_hours(DateTime* this_, int hours);
DateTime* /*new*/ g_date_time_add_minutes(DateTime* this_, int minutes);
DateTime* /*new*/ g_date_time_add_months(DateTime* this_, int months);
DateTime* /*new*/ g_date_time_add_seconds(DateTime* this_, double seconds);
DateTime* /*new*/ g_date_time_add_weeks(DateTime* this_, int weeks);
DateTime* /*new*/ g_date_time_add_years(DateTime* this_, int years);
TimeSpan g_date_time_difference(DateTime* this_, DateTime* begin);
char* /*new*/ g_date_time_format(DateTime* this_, char* format);
int g_date_time_get_day_of_month(DateTime* this_);
int g_date_time_get_day_of_week(DateTime* this_);
int g_date_time_get_day_of_year(DateTime* this_);
int g_date_time_get_hour(DateTime* this_);
int g_date_time_get_microsecond(DateTime* this_);
int g_date_time_get_minute(DateTime* this_);
int g_date_time_get_month(DateTime* this_);
int g_date_time_get_second(DateTime* this_);
double g_date_time_get_seconds(DateTime* this_);
char* g_date_time_get_timezone_abbreviation(DateTime* this_);
TimeSpan g_date_time_get_utc_offset(DateTime* this_);
int g_date_time_get_week_numbering_year(DateTime* this_);
int g_date_time_get_week_of_year(DateTime* this_);
int g_date_time_get_year(DateTime* this_);
void g_date_time_get_ymd(DateTime* this_, /*out*/ int* year, /*out*/ int* month, /*out*/ int* day);
int g_date_time_is_daylight_savings(DateTime* this_);
DateTime* /*new*/ g_date_time_ref(DateTime* this_);
DateTime* /*new*/ g_date_time_to_local(DateTime* this_);
int g_date_time_to_timeval(DateTime* this_, TimeVal* tv);
DateTime* /*new*/ g_date_time_to_timezone(DateTime* this_, TimeZone* tz);
long g_date_time_to_unix(DateTime* this_);
DateTime* /*new*/ g_date_time_to_utc(DateTime* this_);
void g_date_time_unref(DateTime* this_);
int g_date_time_compare(const(void)* dt1, const(void)* dt2);
int g_date_time_equal(const(void)* dt1, const(void)* dt2);
uint g_date_time_hash(const(void)* datetime);
void g_dir_close(Dir* this_);
char* g_dir_read_name(Dir* this_);
void g_dir_rewind(Dir* this_);
char* /*new*/ g_dir_make_tmp(char* tmpl, GLib2.Error** error);
Dir* g_dir_open(char* path, uint flags, GLib2.Error** error);
Error* /*new*/ g_error_new(Quark domain, int code, char* format, ...);
Error* /*new*/ g_error_new_literal(Quark domain, int code, char* message);
Error* /*new*/ g_error_new_valist(Quark domain, int code, char* format, va_list args);
Error* /*new*/ g_error_copy(Error* this_);
void g_error_free(Error* this_);
int g_error_matches(Error* this_, Quark domain, int code);
void g_hash_table_destroy(GLib2.HashTable* hash_table);
void* g_hash_table_find(GLib2.HashTable* hash_table, HRFunc predicate, void* user_data);
void g_hash_table_foreach(GLib2.HashTable* hash_table, HFunc func, void* user_data);
uint g_hash_table_foreach_remove(GLib2.HashTable* hash_table, HRFunc func, void* user_data);
uint g_hash_table_foreach_steal(GLib2.HashTable* hash_table, HRFunc func, void* user_data);
GLib2.List* g_hash_table_get_keys(GLib2.HashTable* hash_table);
GLib2.List* g_hash_table_get_values(GLib2.HashTable* hash_table);
void g_hash_table_insert(GLib2.HashTable* hash_table, void* key, void* value);
void* g_hash_table_lookup(GLib2.HashTable* hash_table, const(void)* key);
int g_hash_table_lookup_extended(GLib2.HashTable* hash_table, const(void)* lookup_key, void** orig_key, void** value);
GLib2.HashTable* g_hash_table_new(HashFunc hash_func, EqualFunc key_equal_func);
GLib2.HashTable* g_hash_table_new_full(HashFunc hash_func, EqualFunc key_equal_func, DestroyNotify key_destroy_func, DestroyNotify value_destroy_func);
GLib2.HashTable* g_hash_table_ref(GLib2.HashTable* hash_table);
int g_hash_table_remove(GLib2.HashTable* hash_table, const(void)* key);
void g_hash_table_remove_all(GLib2.HashTable* hash_table);
void g_hash_table_replace(GLib2.HashTable* hash_table, void* key, void* value);
uint g_hash_table_size(GLib2.HashTable* hash_table);
int g_hash_table_steal(GLib2.HashTable* hash_table, const(void)* key);
void g_hash_table_steal_all(GLib2.HashTable* hash_table);
void g_hash_table_unref(GLib2.HashTable* hash_table);
GLib2.HashTable* g_hash_table_iter_get_hash_table(HashTableIter* this_);
void g_hash_table_iter_init(HashTableIter* this_, GLib2.HashTable* hash_table);
int g_hash_table_iter_next(HashTableIter* this_, void** key, void** value);
void g_hash_table_iter_remove(HashTableIter* this_);
void g_hash_table_iter_replace(HashTableIter* this_, void* value);
void g_hash_table_iter_steal(HashTableIter* this_);
Hmac* g_hmac_copy(Hmac* this_);
void g_hmac_get_digest(Hmac* this_, ubyte* buffer, size_t* digest_len);
char* g_hmac_get_string(Hmac* this_);
Hmac* g_hmac_ref(Hmac* this_);
void g_hmac_unref(Hmac* this_);
void g_hmac_update(Hmac* this_, ubyte* data, ssize_t length);
Hmac* g_hmac_new(ChecksumType digest_type, ubyte* key, size_t key_len);
int g_hook_compare_ids(Hook* this_, Hook* sibling);
Hook* g_hook_alloc(HookList* hook_list);
int g_hook_destroy(HookList* hook_list, c_ulong hook_id);
void g_hook_destroy_link(HookList* hook_list, Hook* hook);
Hook* g_hook_find(HookList* hook_list, int need_valids, HookFindFunc func, void* data);
Hook* g_hook_find_data(HookList* hook_list, int need_valids, void* data);
Hook* g_hook_find_func(HookList* hook_list, int need_valids, void* func);
Hook* g_hook_find_func_data(HookList* hook_list, int need_valids, void* func, void* data);
Hook* g_hook_first_valid(HookList* hook_list, int may_be_in_call);
void g_hook_free(HookList* hook_list, Hook* hook);
Hook* g_hook_get(HookList* hook_list, c_ulong hook_id);
void g_hook_insert_before(HookList* hook_list, Hook* sibling, Hook* hook);
void g_hook_insert_sorted(HookList* hook_list, Hook* hook, HookCompareFunc func);
Hook* g_hook_next_valid(HookList* hook_list, Hook* hook, int may_be_in_call);
void g_hook_prepend(HookList* hook_list, Hook* hook);
Hook* g_hook_ref(HookList* hook_list, Hook* hook);
void g_hook_unref(HookList* hook_list, Hook* hook);
void g_hook_list_clear(HookList* this_);
void g_hook_list_init(HookList* this_, uint hook_size);
void g_hook_list_invoke(HookList* this_, int may_recurse);
void g_hook_list_invoke_check(HookList* this_, int may_recurse);
void g_hook_list_marshal(HookList* this_, int may_recurse, HookMarshaller marshaller, void* marshal_data);
void g_hook_list_marshal_check(HookList* this_, int may_recurse, HookCheckMarshaller marshaller, void* marshal_data);
size_t g_iconv(IConv* this_, char** inbuf, size_t* inbytes_left, char** outbuf, size_t* outbytes_left);
int g_iconv_close(IConv* this_);
IConv g_iconv_open(char* to_codeset, char* from_codeset);
IOChannel* /*new*/ g_io_channel_new_file(char* filename, char* mode, GLib2.Error** error);
IOChannel* /*new*/ g_io_channel_unix_new(int fd);
void g_io_channel_close(IOChannel* this_);
IOStatus g_io_channel_flush(IOChannel* this_, GLib2.Error** error);
IOCondition g_io_channel_get_buffer_condition(IOChannel* this_);
size_t g_io_channel_get_buffer_size(IOChannel* this_);
int g_io_channel_get_buffered(IOChannel* this_);
int g_io_channel_get_close_on_unref(IOChannel* this_);
char* g_io_channel_get_encoding(IOChannel* this_);
IOFlags g_io_channel_get_flags(IOChannel* this_);
char* g_io_channel_get_line_term(IOChannel* this_, int* length);
void g_io_channel_init(IOChannel* this_);
IOError g_io_channel_read(IOChannel* this_, char* buf, size_t count, size_t* bytes_read);
IOStatus g_io_channel_read_chars(IOChannel* this_, char* buf, size_t count, size_t* bytes_read, GLib2.Error** error);
IOStatus g_io_channel_read_line(IOChannel* this_, char** str_return, size_t* length, size_t* terminator_pos, GLib2.Error** error);
IOStatus g_io_channel_read_line_string(IOChannel* this_, String* buffer, size_t* terminator_pos, GLib2.Error** error);
IOStatus g_io_channel_read_to_end(IOChannel* this_, char** str_return, size_t* length, GLib2.Error** error);
IOStatus g_io_channel_read_unichar(IOChannel* this_, dchar* thechar, GLib2.Error** error);
IOChannel* /*new*/ g_io_channel_ref(IOChannel* this_);
IOError g_io_channel_seek(IOChannel* this_, long offset, SeekType type);
IOStatus g_io_channel_seek_position(IOChannel* this_, long offset, SeekType type, GLib2.Error** error);
void g_io_channel_set_buffer_size(IOChannel* this_, size_t size);
void g_io_channel_set_buffered(IOChannel* this_, int buffered);
void g_io_channel_set_close_on_unref(IOChannel* this_, int do_close);
IOStatus g_io_channel_set_encoding(IOChannel* this_, char* encoding, GLib2.Error** error);
IOStatus g_io_channel_set_flags(IOChannel* this_, IOFlags flags, GLib2.Error** error);
void g_io_channel_set_line_term(IOChannel* this_, char* line_term, int length);
IOStatus g_io_channel_shutdown(IOChannel* this_, int flush, GLib2.Error** error);
int g_io_channel_unix_get_fd(IOChannel* this_);
void g_io_channel_unref(IOChannel* this_);
IOError g_io_channel_write(IOChannel* this_, char* buf, size_t count, size_t* bytes_written);
IOStatus g_io_channel_write_chars(IOChannel* this_, char* buf, ssize_t count, size_t* bytes_written, GLib2.Error** error);
IOStatus g_io_channel_write_unichar(IOChannel* this_, dchar thechar, GLib2.Error** error);
IOChannelError g_io_channel_error_from_errno(int en);
Quark g_io_channel_error_quark();
void g_key_file_free(KeyFile* this_);
int g_key_file_get_boolean(KeyFile* this_, char* group_name, char* key, GLib2.Error** error);
int* /*new container*/ g_key_file_get_boolean_list(KeyFile* this_, char* group_name, char* key, /*out*/ size_t* length, GLib2.Error** error);
char* /*new*/ g_key_file_get_comment(KeyFile* this_, char* group_name, char* key, GLib2.Error** error);
double g_key_file_get_double(KeyFile* this_, char* group_name, char* key, GLib2.Error** error);
double* /*new container*/ g_key_file_get_double_list(KeyFile* this_, char* group_name, char* key, /*out*/ size_t* length, GLib2.Error** error);
char** g_key_file_get_groups(KeyFile* this_, size_t* length);
long g_key_file_get_int64(KeyFile* this_, char* group_name, char* key, GLib2.Error** error);
int g_key_file_get_integer(KeyFile* this_, char* group_name, char* key, GLib2.Error** error);
int* /*new container*/ g_key_file_get_integer_list(KeyFile* this_, char* group_name, char* key, /*out*/ size_t* length, GLib2.Error** error);
char** g_key_file_get_keys(KeyFile* this_, char* group_name, size_t* length, GLib2.Error** error);
char* /*new*/ g_key_file_get_locale_string(KeyFile* this_, char* group_name, char* key, char* locale, GLib2.Error** error);
char** /*new*/ g_key_file_get_locale_string_list(KeyFile* this_, char* group_name, char* key, char* locale, /*out*/ size_t* length, GLib2.Error** error);
char* /*new*/ g_key_file_get_start_group(KeyFile* this_);
char* /*new*/ g_key_file_get_string(KeyFile* this_, char* group_name, char* key, GLib2.Error** error);
char** /*new*/ g_key_file_get_string_list(KeyFile* this_, char* group_name, char* key, /*out*/ size_t* length, GLib2.Error** error);
ulong g_key_file_get_uint64(KeyFile* this_, char* group_name, char* key, GLib2.Error** error);
char* /*new*/ g_key_file_get_value(KeyFile* this_, char* group_name, char* key, GLib2.Error** error);
int g_key_file_has_group(KeyFile* this_, char* group_name);
int g_key_file_has_key(KeyFile* this_, char* group_name, char* key, GLib2.Error** error);
int g_key_file_load_from_data(KeyFile* this_, char* data, size_t length, KeyFileFlags flags, GLib2.Error** error);
int g_key_file_load_from_data_dirs(KeyFile* this_, char* file, char** full_path, KeyFileFlags flags, GLib2.Error** error);
int g_key_file_load_from_dirs(KeyFile* this_, char* file, char** search_dirs, char** full_path, KeyFileFlags flags, GLib2.Error** error);
int g_key_file_load_from_file(KeyFile* this_, char* file, KeyFileFlags flags, GLib2.Error** error);
int g_key_file_remove_comment(KeyFile* this_, char* group_name, char* key, GLib2.Error** error);
int g_key_file_remove_group(KeyFile* this_, char* group_name, GLib2.Error** error);
int g_key_file_remove_key(KeyFile* this_, char* group_name, char* key, GLib2.Error** error);
void g_key_file_set_boolean(KeyFile* this_, char* group_name, char* key, int value);
void g_key_file_set_boolean_list(KeyFile* this_, char* group_name, char* key, int list, size_t length);
int g_key_file_set_comment(KeyFile* this_, char* group_name, char* key, char* comment, GLib2.Error** error);
void g_key_file_set_double(KeyFile* this_, char* group_name, char* key, double value);
void g_key_file_set_double_list(KeyFile* this_, char* group_name, char* key, double list, size_t length);
void g_key_file_set_int64(KeyFile* this_, char* group_name, char* key, long value);
void g_key_file_set_integer(KeyFile* this_, char* group_name, char* key, int value);
void g_key_file_set_integer_list(KeyFile* this_, char* group_name, char* key, int list, size_t length);
void g_key_file_set_list_separator(KeyFile* this_, char separator);
void g_key_file_set_locale_string(KeyFile* this_, char* group_name, char* key, char* locale, char* string_);
void g_key_file_set_locale_string_list(KeyFile* this_, char* group_name, char* key, char* locale, char* list, size_t length);
void g_key_file_set_string(KeyFile* this_, char* group_name, char* key, char* string_);
void g_key_file_set_string_list(KeyFile* this_, char* group_name, char* key, char* list, size_t length);
void g_key_file_set_uint64(KeyFile* this_, char* group_name, char* key, ulong value);
void g_key_file_set_value(KeyFile* this_, char* group_name, char* key, char* value);
char* /*new*/ g_key_file_to_data(KeyFile* this_, size_t* length, GLib2.Error** error);
Quark g_key_file_error_quark();
KeyFile* g_key_file_new();
GLib2.List* g_list_alloc();
GLib2.List* g_list_append(GLib2.List* list, void* data);
GLib2.List* g_list_concat(GLib2.List* list1, GLib2.List* list2);
GLib2.List* g_list_copy(GLib2.List* list);
GLib2.List* g_list_delete_link(GLib2.List* list, GLib2.List* link_);
GLib2.List* g_list_find(GLib2.List* list, const(void)* data);
GLib2.List* g_list_find_custom(GLib2.List* list, const(void)* data, CompareFunc func);
GLib2.List* g_list_first(GLib2.List* list);
void g_list_foreach(GLib2.List* list, Func func, void* user_data);
void g_list_free(GLib2.List* list);
void g_list_free_1(GLib2.List* list);
void g_list_free_full(GLib2.List* list, DestroyNotify free_func);
int g_list_index(GLib2.List* list, const(void)* data);
GLib2.List* g_list_insert(GLib2.List* list, void* data, int position);
GLib2.List* g_list_insert_before(GLib2.List* list, GLib2.List* sibling, void* data);
GLib2.List* g_list_insert_sorted(GLib2.List* list, void* data, CompareFunc func);
GLib2.List* g_list_insert_sorted_with_data(GLib2.List* list, void* data, CompareDataFunc func, void* user_data);
GLib2.List* g_list_last(GLib2.List* list);
uint g_list_length(GLib2.List* list);
GLib2.List* g_list_nth(GLib2.List* list, uint n);
void* g_list_nth_data(GLib2.List* list, uint n);
GLib2.List* g_list_nth_prev(GLib2.List* list, uint n);
void g_list_pop_allocator();
int g_list_position(GLib2.List* list, GLib2.List* llink);
GLib2.List* g_list_prepend(GLib2.List* list, void* data);
void g_list_push_allocator(void* allocator);
GLib2.List* g_list_remove(GLib2.List* list, const(void)* data);
GLib2.List* g_list_remove_all(GLib2.List* list, const(void)* data);
GLib2.List* g_list_remove_link(GLib2.List* list, GLib2.List* llink);
GLib2.List* g_list_reverse(GLib2.List* list);
GLib2.List* g_list_sort(GLib2.List* list, CompareFunc compare_func);
GLib2.List* g_list_sort_with_data(GLib2.List* list, CompareDataFunc compare_func, void* user_data);
MainContext* /*new*/ g_main_context_new();
int g_main_context_acquire(MainContext* this_);
void g_main_context_add_poll(MainContext* this_, PollFD* fd, int priority);
int g_main_context_check(MainContext* this_, int max_priority, PollFD* fds, int n_fds);
void g_main_context_dispatch(MainContext* this_);
Source* g_main_context_find_source_by_funcs_user_data(MainContext* this_, SourceFuncs* funcs, void* user_data);
Source* g_main_context_find_source_by_id(MainContext* this_, uint source_id);
Source* g_main_context_find_source_by_user_data(MainContext* this_, void* user_data);
PollFunc g_main_context_get_poll_func(MainContext* this_);
void g_main_context_invoke(MainContext* this_, SourceFunc function_, void* data);
void g_main_context_invoke_full(MainContext* this_, int priority, SourceFunc function_, void* data, DestroyNotify notify);
int g_main_context_is_owner(MainContext* this_);
int g_main_context_iteration(MainContext* this_, int may_block);
int g_main_context_pending(MainContext* this_);
void g_main_context_pop_thread_default(MainContext* this_);
int g_main_context_prepare(MainContext* this_, int* priority);
void g_main_context_push_thread_default(MainContext* this_);
int g_main_context_query(MainContext* this_, int max_priority, /*out*/ int* timeout_, /*out*/ PollFD* fds, /*out*/ int n_fds);
MainContext* /*new*/ g_main_context_ref(MainContext* this_);
void g_main_context_release(MainContext* this_);
void g_main_context_remove_poll(MainContext* this_, PollFD* fd);
void g_main_context_set_poll_func(MainContext* this_, PollFunc func);
void g_main_context_unref(MainContext* this_);
int g_main_context_wait(MainContext* this_, Cond* cond, Mutex* mutex);
void g_main_context_wakeup(MainContext* this_);
MainContext* g_main_context_default();
MainContext* g_main_context_get_thread_default();
MainLoop* /*new*/ g_main_loop_new(MainContext* context, int is_running);
MainContext* g_main_loop_get_context(MainLoop* this_);
int g_main_loop_is_running(MainLoop* this_);
void g_main_loop_quit(MainLoop* this_);
MainLoop* /*new*/ g_main_loop_ref(MainLoop* this_);
void g_main_loop_run(MainLoop* this_);
void g_main_loop_unref(MainLoop* this_);
void g_mapped_file_free(MappedFile* this_);
char* /*new*/ g_mapped_file_get_contents(MappedFile* this_);
size_t g_mapped_file_get_length(MappedFile* this_);
MappedFile* g_mapped_file_ref(MappedFile* this_);
void g_mapped_file_unref(MappedFile* this_);
MappedFile* g_mapped_file_new(char* filename, int writable, GLib2.Error** error);
int g_markup_parse_context_end_parse(MarkupParseContext* this_, GLib2.Error** error);
void g_markup_parse_context_free(MarkupParseContext* this_);
char* g_markup_parse_context_get_element(MarkupParseContext* this_);
GLib2.SList* g_markup_parse_context_get_element_stack(MarkupParseContext* this_);
void g_markup_parse_context_get_position(MarkupParseContext* this_, int* line_number=null, int* char_number=null);
void* g_markup_parse_context_get_user_data(MarkupParseContext* this_);
int g_markup_parse_context_parse(MarkupParseContext* this_, char* text, ssize_t text_len, GLib2.Error** error);
void* g_markup_parse_context_pop(MarkupParseContext* this_);
void g_markup_parse_context_push(MarkupParseContext* this_, MarkupParser* parser, void* user_data);
MarkupParseContext* g_markup_parse_context_new(MarkupParser* parser, MarkupParseFlags flags, void* user_data, DestroyNotify user_data_dnotify);
char* /*new*/ g_match_info_expand_references(MatchInfo* this_, char* string_to_expand, GLib2.Error** error);
char* /*new*/ g_match_info_fetch(MatchInfo* this_, int match_num);
char** g_match_info_fetch_all(MatchInfo* this_);
char* /*new*/ g_match_info_fetch_named(MatchInfo* this_, char* name);
int g_match_info_fetch_named_pos(MatchInfo* this_, char* name, /*out*/ int* start_pos=null, /*out*/ int* end_pos=null);
int g_match_info_fetch_pos(MatchInfo* this_, int match_num, /*out*/ int* start_pos=null, /*out*/ int* end_pos=null);
void g_match_info_free(MatchInfo* this_);
int g_match_info_get_match_count(MatchInfo* this_);
Regex* /*new*/ g_match_info_get_regex(MatchInfo* this_);
char* g_match_info_get_string(MatchInfo* this_);
int g_match_info_is_partial_match(MatchInfo* this_);
int g_match_info_matches(MatchInfo* this_);
int g_match_info_next(MatchInfo* this_, GLib2.Error** error);
MatchInfo* /*new*/ g_match_info_ref(MatchInfo* this_);
void g_match_info_unref(MatchInfo* this_);
void* g_mem_chunk_alloc(MemChunk* this_);
void* g_mem_chunk_alloc0(MemChunk* this_);
void g_mem_chunk_clean(MemChunk* this_);
void g_mem_chunk_destroy(MemChunk* this_);
void g_mem_chunk_free(MemChunk* this_, void* mem);
void g_mem_chunk_print(MemChunk* this_);
void g_mem_chunk_reset(MemChunk* this_);
void g_mem_chunk_info();
MemChunk* g_mem_chunk_new(char* name, int atom_size, size_t area_size, int type);
int g_node_child_index(Node* this_, void* data);
int g_node_child_position(Node* this_, Node* child);
void g_node_children_foreach(Node* this_, TraverseFlags flags, NodeForeachFunc func, void* data);
Node* g_node_copy(Node* this_);
Node* g_node_copy_deep(Node* this_, CopyFunc copy_func, void* data);
uint g_node_depth(Node* this_);
void g_node_destroy(Node* this_);
Node* g_node_find(Node* this_, TraverseType order, TraverseFlags flags, void* data);
Node* g_node_find_child(Node* this_, TraverseFlags flags, void* data);
Node* g_node_first_sibling(Node* this_);
Node* g_node_get_root(Node* this_);
Node* g_node_insert(Node* this_, int position, Node* node);
Node* g_node_insert_after(Node* this_, Node* sibling, Node* node);
Node* g_node_insert_before(Node* this_, Node* sibling, Node* node);
int g_node_is_ancestor(Node* this_, Node* descendant);
Node* g_node_last_child(Node* this_);
Node* g_node_last_sibling(Node* this_);
uint g_node_max_height(Node* this_);
uint g_node_n_children(Node* this_);
uint g_node_n_nodes(Node* this_, TraverseFlags flags);
Node* g_node_nth_child(Node* this_, uint n);
Node* g_node_prepend(Node* this_, Node* node);
void g_node_reverse_children(Node* this_);
void g_node_traverse(Node* this_, TraverseType order, TraverseFlags flags, int max_depth, NodeTraverseFunc func, void* data);
void g_node_unlink(Node* this_);
Node* g_node_new(void* data);
void g_node_pop_allocator();
void g_node_push_allocator(void* dummy);
void* g_once_impl(Once* this_, ThreadFunc func, void* arg);
int g_once_init_enter(size_t* value_location);
int g_once_init_enter_impl(size_t* value_location);
void g_once_init_leave(size_t* value_location, size_t initialization_value);
void g_option_context_add_group(OptionContext* this_, OptionGroup* group);
void g_option_context_add_main_entries(OptionContext* this_, OptionEntry* entries, char* translation_domain);
void g_option_context_free(OptionContext* this_);
char* g_option_context_get_description(OptionContext* this_);
char* /*new*/ g_option_context_get_help(OptionContext* this_, int main_help, OptionGroup* group);
int g_option_context_get_help_enabled(OptionContext* this_);
int g_option_context_get_ignore_unknown_options(OptionContext* this_);
OptionGroup* g_option_context_get_main_group(OptionContext* this_);
char* g_option_context_get_summary(OptionContext* this_);
int g_option_context_parse(OptionContext* this_, /*inout*/ int* argc, /*inout*/ char*** argv, GLib2.Error** error);
void g_option_context_set_description(OptionContext* this_, char* description);
void g_option_context_set_help_enabled(OptionContext* this_, int help_enabled);
void g_option_context_set_ignore_unknown_options(OptionContext* this_, int ignore_unknown);
void g_option_context_set_main_group(OptionContext* this_, OptionGroup* group);
void g_option_context_set_summary(OptionContext* this_, char* summary);
void g_option_context_set_translate_func(OptionContext* this_, TranslateFunc func, void* data, DestroyNotify destroy_notify);
void g_option_context_set_translation_domain(OptionContext* this_, char* domain);
OptionContext* g_option_context_new(char* parameter_string);
void g_option_group_add_entries(OptionGroup* this_, OptionEntry* entries);
void g_option_group_free(OptionGroup* this_);
void g_option_group_set_error_hook(OptionGroup* this_, OptionErrorFunc error_func);
void g_option_group_set_parse_hooks(OptionGroup* this_, OptionParseFunc pre_parse_func, OptionParseFunc post_parse_func);
void g_option_group_set_translate_func(OptionGroup* this_, TranslateFunc func, void* data, DestroyNotify destroy_notify);
void g_option_group_set_translation_domain(OptionGroup* this_, char* domain);
OptionGroup* g_option_group_new(char* name, char* description, char* help_description, void* user_data, DestroyNotify destroy);
int g_pattern_spec_equal(PatternSpec* this_, PatternSpec* pspec2);
void g_pattern_spec_free(PatternSpec* this_);
PatternSpec* g_pattern_spec_new(char* pattern);
void g_ptr_array_add(PtrArray* array, void* data);
void g_ptr_array_foreach(PtrArray* array, Func func, void* user_data);
void** g_ptr_array_free(PtrArray* array, int free_seg);
PtrArray* g_ptr_array_new();
PtrArray* g_ptr_array_new_full(uint reserved_size, DestroyNotify element_free_func);
PtrArray* g_ptr_array_new_with_free_func(DestroyNotify element_free_func);
PtrArray* g_ptr_array_ref(PtrArray* array);
int g_ptr_array_remove(PtrArray* array, void* data);
int g_ptr_array_remove_fast(PtrArray* array, void* data);
void* g_ptr_array_remove_index(PtrArray* array, uint index_);
void* g_ptr_array_remove_index_fast(PtrArray* array, uint index_);
void g_ptr_array_remove_range(PtrArray* array, uint index_, uint length);
void g_ptr_array_set_free_func(PtrArray* array, DestroyNotify element_free_func);
void g_ptr_array_set_size(PtrArray* array, int length);
PtrArray* g_ptr_array_sized_new(uint reserved_size);
void g_ptr_array_sort(PtrArray* array, CompareFunc compare_func);
void g_ptr_array_sort_with_data(PtrArray* array, CompareDataFunc compare_func, void* user_data);
void g_ptr_array_unref(PtrArray* array);
void g_queue_clear(Queue* this_);
Queue* g_queue_copy(Queue* this_);
void g_queue_delete_link(Queue* this_, GLib2.List* link_);
GLib2.List* g_queue_find(Queue* this_, const(void)* data);
GLib2.List* g_queue_find_custom(Queue* this_, const(void)* data, CompareFunc func);
void g_queue_foreach(Queue* this_, Func func, void* user_data);
void g_queue_free(Queue* this_);
uint g_queue_get_length(Queue* this_);
int g_queue_index(Queue* this_, const(void)* data);
void g_queue_init(Queue* this_);
void g_queue_insert_after(Queue* this_, GLib2.List* sibling, void* data);
void g_queue_insert_before(Queue* this_, GLib2.List* sibling, void* data);
void g_queue_insert_sorted(Queue* this_, void* data, CompareDataFunc func, void* user_data);
int g_queue_is_empty(Queue* this_);
int g_queue_link_index(Queue* this_, GLib2.List* link_);
void* g_queue_peek_head(Queue* this_);
GLib2.List* g_queue_peek_head_link(Queue* this_);
void* g_queue_peek_nth(Queue* this_, uint n);
GLib2.List* g_queue_peek_nth_link(Queue* this_, uint n);
void* g_queue_peek_tail(Queue* this_);
GLib2.List* g_queue_peek_tail_link(Queue* this_);
void* g_queue_pop_head(Queue* this_);
GLib2.List* g_queue_pop_head_link(Queue* this_);
void* g_queue_pop_nth(Queue* this_, uint n);
GLib2.List* g_queue_pop_nth_link(Queue* this_, uint n);
void* g_queue_pop_tail(Queue* this_);
GLib2.List* g_queue_pop_tail_link(Queue* this_);
void g_queue_push_head(Queue* this_, void* data);
void g_queue_push_head_link(Queue* this_, GLib2.List* link_);
void g_queue_push_nth(Queue* this_, void* data, int n);
void g_queue_push_nth_link(Queue* this_, int n, GLib2.List* link_);
void g_queue_push_tail(Queue* this_, void* data);
void g_queue_push_tail_link(Queue* this_, GLib2.List* link_);
int g_queue_remove(Queue* this_, const(void)* data);
uint g_queue_remove_all(Queue* this_, const(void)* data);
void g_queue_reverse(Queue* this_);
void g_queue_sort(Queue* this_, CompareDataFunc compare_func, void* user_data);
void g_queue_unlink(Queue* this_, GLib2.List* link_);
Queue* g_queue_new();
Rand* g_rand_copy(Rand* this_);
double g_rand_double(Rand* this_);
double g_rand_double_range(Rand* this_, double begin, double end);
void g_rand_free(Rand* this_);
uint g_rand_int(Rand* this_);
int g_rand_int_range(Rand* this_, int begin, int end);
void g_rand_set_seed(Rand* this_, uint seed);
void g_rand_set_seed_array(Rand* this_, uint* seed, uint seed_length);
Rand* g_rand_new();
Rand* g_rand_new_with_seed(uint seed);
Rand* g_rand_new_with_seed_array(uint* seed, uint seed_length);
Regex* /*new*/ g_regex_new(char* pattern, RegexCompileFlags compile_options, RegexMatchFlags match_options, GLib2.Error** error);
int g_regex_get_capture_count(Regex* this_);
RegexCompileFlags g_regex_get_compile_flags(Regex* this_);
RegexMatchFlags g_regex_get_match_flags(Regex* this_);
int g_regex_get_max_backref(Regex* this_);
char* g_regex_get_pattern(Regex* this_);
int g_regex_get_string_number(Regex* this_, char* name);
int g_regex_match(Regex* this_, char* string_, RegexMatchFlags match_options, /*out*/ MatchInfo** match_info=null);
int g_regex_match_all(Regex* this_, char* string_, RegexMatchFlags match_options, /*out*/ MatchInfo** match_info=null);
int g_regex_match_all_full(Regex* this_, char* string_, ssize_t string_len, int start_position, RegexMatchFlags match_options, /*out*/ MatchInfo** match_info, GLib2.Error** error);
int g_regex_match_full(Regex* this_, char* string_, ssize_t string_len, int start_position, RegexMatchFlags match_options, /*out*/ MatchInfo** match_info, GLib2.Error** error);
Regex* /*new*/ g_regex_ref(Regex* this_);
char* /*new*/ g_regex_replace(Regex* this_, char* string_, ssize_t string_len, int start_position, char* replacement, RegexMatchFlags match_options, GLib2.Error** error);
char* /*new*/ g_regex_replace_eval(Regex* this_, char* string_, ssize_t string_len, int start_position, RegexMatchFlags match_options, RegexEvalCallback eval, void* user_data, GLib2.Error** error);
char* /*new*/ g_regex_replace_literal(Regex* this_, char* string_, ssize_t string_len, int start_position, char* replacement, RegexMatchFlags match_options, GLib2.Error** error);
char** g_regex_split(Regex* this_, char* string_, RegexMatchFlags match_options);
char** g_regex_split_full(Regex* this_, char* string_, ssize_t string_len, int start_position, RegexMatchFlags match_options, int max_tokens, GLib2.Error** error);
void g_regex_unref(Regex* this_);
int g_regex_check_replacement(char* replacement, /*out*/ int* has_references, GLib2.Error** error);
Quark g_regex_error_quark();
char* /*new*/ g_regex_escape_nul(char* string_, int length);
char* /*new*/ g_regex_escape_string(char* string_, int length);
int g_regex_match_simple(char* pattern, char* string_, RegexCompileFlags compile_options, RegexMatchFlags match_options);
char** g_regex_split_simple(char* pattern, char* string_, RegexCompileFlags compile_options, RegexMatchFlags match_options);
int g_relation_count(Relation* this_, const(void)* key, int field);
int g_relation_delete(Relation* this_, const(void)* key, int field);
void g_relation_destroy(Relation* this_);
int g_relation_exists(Relation* this_, ...);
void g_relation_index(Relation* this_, int field, HashFunc hash_func, EqualFunc key_equal_func);
void g_relation_insert(Relation* this_, ...);
void g_relation_print(Relation* this_);
Tuples* g_relation_select(Relation* this_, const(void)* key, int field);
Relation* g_relation_new(int fields);
GLib2.SList* g_slist_alloc();
GLib2.SList* g_slist_append(GLib2.SList* list, void* data);
GLib2.SList* g_slist_concat(GLib2.SList* list1, GLib2.SList* list2);
GLib2.SList* g_slist_copy(GLib2.SList* list);
GLib2.SList* g_slist_delete_link(GLib2.SList* list, GLib2.SList* link_);
GLib2.SList* g_slist_find(GLib2.SList* list, const(void)* data);
GLib2.SList* g_slist_find_custom(GLib2.SList* list, const(void)* data, CompareFunc func);
void g_slist_foreach(GLib2.SList* list, Func func, void* user_data);
void g_slist_free(GLib2.SList* list);
void g_slist_free_1(GLib2.SList* list);
void g_slist_free_full(GLib2.SList* list, DestroyNotify free_func);
int g_slist_index(GLib2.SList* list, const(void)* data);
GLib2.SList* g_slist_insert(GLib2.SList* list, void* data, int position);
GLib2.SList* g_slist_insert_before(GLib2.SList* slist, GLib2.SList* sibling, void* data);
GLib2.SList* g_slist_insert_sorted(GLib2.SList* list, void* data, CompareFunc func);
GLib2.SList* g_slist_insert_sorted_with_data(GLib2.SList* list, void* data, CompareDataFunc func, void* user_data);
GLib2.SList* g_slist_last(GLib2.SList* list);
uint g_slist_length(GLib2.SList* list);
GLib2.SList* g_slist_nth(GLib2.SList* list, uint n);
void* g_slist_nth_data(GLib2.SList* list, uint n);
void g_slist_pop_allocator();
int g_slist_position(GLib2.SList* list, GLib2.SList* llink);
GLib2.SList* g_slist_prepend(GLib2.SList* list, void* data);
void g_slist_push_allocator(void* dummy);
GLib2.SList* g_slist_remove(GLib2.SList* list, const(void)* data);
GLib2.SList* g_slist_remove_all(GLib2.SList* list, const(void)* data);
GLib2.SList* g_slist_remove_link(GLib2.SList* list, GLib2.SList* link_);
GLib2.SList* g_slist_reverse(GLib2.SList* list);
GLib2.SList* g_slist_sort(GLib2.SList* list, CompareFunc compare_func);
GLib2.SList* g_slist_sort_with_data(GLib2.SList* list, CompareDataFunc compare_func, void* user_data);
uint g_scanner_cur_line(Scanner* this_);
uint g_scanner_cur_position(Scanner* this_);
TokenType g_scanner_cur_token(Scanner* this_);
TokenValue g_scanner_cur_value(Scanner* this_);
void g_scanner_destroy(Scanner* this_);
int g_scanner_eof(Scanner* this_);
void g_scanner_error(Scanner* this_, char* format, ...);
TokenType g_scanner_get_next_token(Scanner* this_);
void g_scanner_input_file(Scanner* this_, int input_fd);
void g_scanner_input_text(Scanner* this_, char* text, uint text_len);
void* g_scanner_lookup_symbol(Scanner* this_, char* symbol);
TokenType g_scanner_peek_next_token(Scanner* this_);
void g_scanner_scope_add_symbol(Scanner* this_, uint scope_id, char* symbol, void* value);
void g_scanner_scope_foreach_symbol(Scanner* this_, uint scope_id, HFunc func, void* user_data);
void* g_scanner_scope_lookup_symbol(Scanner* this_, uint scope_id, char* symbol);
void g_scanner_scope_remove_symbol(Scanner* this_, uint scope_id, char* symbol);
uint g_scanner_set_scope(Scanner* this_, uint scope_id);
void g_scanner_sync_file_offset(Scanner* this_);
void g_scanner_unexp_token(Scanner* this_, TokenType expected_token, char* identifier_spec, char* symbol_spec, char* symbol_name, char* message, int is_error);
void g_scanner_warn(Scanner* this_, char* format, ...);
Scanner* g_scanner_new(ScannerConfig* config_templ);
SequenceIter* g_sequence_append(Sequence* this_, void* data);
void g_sequence_foreach(Sequence* this_, Func func, void* user_data);
void g_sequence_free(Sequence* this_);
SequenceIter* g_sequence_get_begin_iter(Sequence* this_);
SequenceIter* g_sequence_get_end_iter(Sequence* this_);
SequenceIter* g_sequence_get_iter_at_pos(Sequence* this_, int pos);
int g_sequence_get_length(Sequence* this_);
SequenceIter* g_sequence_insert_sorted(Sequence* this_, void* data, CompareDataFunc cmp_func, void* cmp_data);
SequenceIter* g_sequence_insert_sorted_iter(Sequence* this_, void* data, SequenceIterCompareFunc iter_cmp, void* cmp_data);
SequenceIter* g_sequence_lookup(Sequence* this_, void* data, CompareDataFunc cmp_func, void* cmp_data);
SequenceIter* g_sequence_lookup_iter(Sequence* this_, void* data, SequenceIterCompareFunc iter_cmp, void* cmp_data);
SequenceIter* g_sequence_prepend(Sequence* this_, void* data);
SequenceIter* g_sequence_search(Sequence* this_, void* data, CompareDataFunc cmp_func, void* cmp_data);
SequenceIter* g_sequence_search_iter(Sequence* this_, void* data, SequenceIterCompareFunc iter_cmp, void* cmp_data);
void g_sequence_sort(Sequence* this_, CompareDataFunc cmp_func, void* cmp_data);
void g_sequence_sort_iter(Sequence* this_, SequenceIterCompareFunc cmp_func, void* cmp_data);
void g_sequence_foreach_range(SequenceIter* begin, SequenceIter* end, Func func, void* user_data);
void* g_sequence_get(SequenceIter* iter);
SequenceIter* g_sequence_insert_before(SequenceIter* iter, void* data);
void g_sequence_move(SequenceIter* src, SequenceIter* dest);
void g_sequence_move_range(SequenceIter* dest, SequenceIter* begin, SequenceIter* end);
Sequence* g_sequence_new(DestroyNotify data_destroy);
SequenceIter* g_sequence_range_get_midpoint(SequenceIter* begin, SequenceIter* end);
void g_sequence_remove(SequenceIter* iter);
void g_sequence_remove_range(SequenceIter* begin, SequenceIter* end);
void g_sequence_set(SequenceIter* iter, void* data);
void g_sequence_sort_changed(SequenceIter* iter, CompareDataFunc cmp_func, void* cmp_data);
void g_sequence_sort_changed_iter(SequenceIter* iter, SequenceIterCompareFunc iter_cmp, void* cmp_data);
void g_sequence_swap(SequenceIter* a, SequenceIter* b);
int g_sequence_iter_compare(SequenceIter* this_, SequenceIter* b);
int g_sequence_iter_get_position(SequenceIter* this_);
Sequence* g_sequence_iter_get_sequence(SequenceIter* this_);
int g_sequence_iter_is_begin(SequenceIter* this_);
int g_sequence_iter_is_end(SequenceIter* this_);
SequenceIter* g_sequence_iter_move(SequenceIter* this_, int delta);
SequenceIter* g_sequence_iter_next(SequenceIter* this_);
SequenceIter* g_sequence_iter_prev(SequenceIter* this_);
Source* /*new*/ g_source_new(SourceFuncs* source_funcs, uint struct_size);
void g_source_add_child_source(Source* this_, Source* child_source);
void g_source_add_poll(Source* this_, PollFD* fd);
uint g_source_attach(Source* this_, MainContext* context);
void g_source_destroy(Source* this_);
int g_source_get_can_recurse(Source* this_);
MainContext* g_source_get_context(Source* this_);
void g_source_get_current_time(Source* this_, TimeVal* timeval);
uint g_source_get_id(Source* this_);
char* g_source_get_name(Source* this_);
int g_source_get_priority(Source* this_);
long g_source_get_time(Source* this_);
int g_source_is_destroyed(Source* this_);
Source* /*new*/ g_source_ref(Source* this_);
void g_source_remove_child_source(Source* this_, Source* child_source);
void g_source_remove_poll(Source* this_, PollFD* fd);
void g_source_set_callback(Source* this_, SourceFunc func, void* data, DestroyNotify notify);
void g_source_set_callback_indirect(Source* this_, void* callback_data, SourceCallbackFuncs* callback_funcs);
void g_source_set_can_recurse(Source* this_, int can_recurse);
void g_source_set_funcs(Source* this_, SourceFuncs* funcs);
void g_source_set_name(Source* this_, char* name);
void g_source_set_priority(Source* this_, int priority);
void g_source_unref(Source* this_);
int g_source_remove(uint tag);
int g_source_remove_by_funcs_user_data(SourceFuncs* funcs, void* user_data);
int g_source_remove_by_user_data(void* user_data);
void g_source_set_name_by_id(uint tag, char* name);
void g_static_mutex_free(StaticMutex* this_);
void g_static_mutex_init(StaticMutex* this_);
Mutex* g_static_mutex_get_mutex_impl(Mutex** mutex);
void g_static_private_free(StaticPrivate* this_);
void* g_static_private_get(StaticPrivate* this_);
void g_static_private_init(StaticPrivate* this_);
void g_static_private_set(StaticPrivate* this_, void* data, DestroyNotify notify);
void g_static_rw_lock_free(StaticRWLock* this_);
void g_static_rw_lock_init(StaticRWLock* this_);
void g_static_rw_lock_reader_lock(StaticRWLock* this_);
int g_static_rw_lock_reader_trylock(StaticRWLock* this_);
void g_static_rw_lock_reader_unlock(StaticRWLock* this_);
void g_static_rw_lock_writer_lock(StaticRWLock* this_);
int g_static_rw_lock_writer_trylock(StaticRWLock* this_);
void g_static_rw_lock_writer_unlock(StaticRWLock* this_);
void g_static_rec_mutex_free(StaticRecMutex* this_);
void g_static_rec_mutex_init(StaticRecMutex* this_);
void g_static_rec_mutex_lock(StaticRecMutex* this_);
void g_static_rec_mutex_lock_full(StaticRecMutex* this_, uint depth);
int g_static_rec_mutex_trylock(StaticRecMutex* this_);
void g_static_rec_mutex_unlock(StaticRecMutex* this_);
uint g_static_rec_mutex_unlock_full(StaticRecMutex* this_);
String* /*new*/ g_string_append(String* this_, char* val);
String* /*new*/ g_string_append_c(String* this_, char c);
String* /*new*/ g_string_append_len(String* this_, char* val, ssize_t len);
void g_string_append_printf(String* this_, char* format, ...);
String* /*new*/ g_string_append_unichar(String* this_, dchar wc);
String* /*new*/ g_string_append_uri_escaped(String* this_, char* unescaped, char* reserved_chars_allowed, int allow_utf8);
void g_string_append_vprintf(String* this_, char* format, va_list args);
String* /*new*/ g_string_ascii_down(String* this_);
String* /*new*/ g_string_ascii_up(String* this_);
String* /*new*/ g_string_assign(String* this_, char* rval);
String* /*new*/ g_string_down(String* this_);
int g_string_equal(String* this_, String* v2);
String* /*new*/ g_string_erase(String* this_, ssize_t pos, ssize_t len);
char* /*new*/ g_string_free(String* this_, int free_segment);
uint g_string_hash(String* this_);
String* /*new*/ g_string_insert(String* this_, ssize_t pos, char* val);
String* /*new*/ g_string_insert_c(String* this_, ssize_t pos, char c);
String* /*new*/ g_string_insert_len(String* this_, ssize_t pos, char* val, ssize_t len);
String* /*new*/ g_string_insert_unichar(String* this_, ssize_t pos, dchar wc);
String* /*new*/ g_string_overwrite(String* this_, size_t pos, char* val);
String* /*new*/ g_string_overwrite_len(String* this_, size_t pos, char* val, ssize_t len);
String* /*new*/ g_string_prepend(String* this_, char* val);
String* /*new*/ g_string_prepend_c(String* this_, char c);
String* /*new*/ g_string_prepend_len(String* this_, char* val, ssize_t len);
String* /*new*/ g_string_prepend_unichar(String* this_, dchar wc);
void g_string_printf(String* this_, char* format, ...);
String* /*new*/ g_string_set_size(String* this_, size_t len);
String* /*new*/ g_string_truncate(String* this_, size_t len);
String* /*new*/ g_string_up(String* this_);
void g_string_vprintf(String* this_, char* format, va_list args);
void g_string_chunk_clear(StringChunk* this_);
void g_string_chunk_free(StringChunk* this_);
char* /*new*/ g_string_chunk_insert(StringChunk* this_, char* string_);
char* /*new*/ g_string_chunk_insert_const(StringChunk* this_, char* string_);
char* /*new*/ g_string_chunk_insert_len(StringChunk* this_, char* string_, ssize_t len);
StringChunk* g_string_chunk_new(size_t size);
void g_test_log_buffer_free(TestLogBuffer* this_);
TestLogMsg* g_test_log_buffer_pop(TestLogBuffer* this_);
void g_test_log_buffer_push(TestLogBuffer* this_, uint n_bytes, ubyte* bytes);
TestLogBuffer* g_test_log_buffer_new();
void g_test_log_msg_free(TestLogMsg* this_);
void g_test_suite_add(TestSuite* this_, TestCase* test_case);
void g_test_suite_add_suite(TestSuite* this_, TestSuite* nestedsuite);
void* g_thread_join(Thread* this_);
void g_thread_set_priority(Thread* this_, ThreadPriority priority);
Thread* g_thread_create_full(ThreadFunc func, void* data, c_ulong stack_size, int joinable, int bound, ThreadPriority priority, GLib2.Error** error);
Quark g_thread_error_quark();
void g_thread_exit(void* retval);
void g_thread_foreach(Func thread_func, void* user_data);
int g_thread_get_initialized();
void g_thread_init(ThreadFunctions* vtable);
void g_thread_init_with_errorcheck_mutexes(ThreadFunctions* vtable);
Thread* g_thread_self();
void g_thread_pool_free(ThreadPool* this_, int immediate, int wait_);
int g_thread_pool_get_max_threads(ThreadPool* this_);
uint g_thread_pool_get_num_threads(ThreadPool* this_);
void g_thread_pool_push(ThreadPool* this_, void* data, GLib2.Error** error);
void g_thread_pool_set_max_threads(ThreadPool* this_, int max_threads, GLib2.Error** error);
void g_thread_pool_set_sort_function(ThreadPool* this_, CompareDataFunc func, void* user_data);
uint g_thread_pool_unprocessed(ThreadPool* this_);
uint g_thread_pool_get_max_idle_time();
int g_thread_pool_get_max_unused_threads();
uint g_thread_pool_get_num_unused_threads();
ThreadPool* g_thread_pool_new(Func func, void* user_data, int max_threads, int exclusive, GLib2.Error** error);
void g_thread_pool_set_max_idle_time(uint interval);
void g_thread_pool_set_max_unused_threads(int max_threads);
void g_thread_pool_stop_unused_threads();
void g_time_val_add(TimeVal* this_, c_long microseconds);
char* /*new*/ g_time_val_to_iso8601(TimeVal* this_);
int g_time_val_from_iso8601(char* iso_date, TimeVal* time_);
int g_time_zone_adjust_time(TimeZone* this_, TimeType type, long* time_);
int g_time_zone_find_interval(TimeZone* this_, TimeType type, long time_);
char* g_time_zone_get_abbreviation(TimeZone* this_, int interval);
int g_time_zone_get_offset(TimeZone* this_, int interval);
int g_time_zone_is_dst(TimeZone* this_, int interval);
TimeZone* g_time_zone_ref(TimeZone* this_);
void g_time_zone_unref(TimeZone* this_);
TimeZone* g_time_zone_new(char* identifier=null);
TimeZone* g_time_zone_new_local();
TimeZone* g_time_zone_new_utc();
void g_timer_continue(Timer* this_);
void g_timer_destroy(Timer* this_);
double g_timer_elapsed(Timer* this_, c_ulong* microseconds);
void g_timer_reset(Timer* this_);
void g_timer_start(Timer* this_);
void g_timer_stop(Timer* this_);
Timer* g_timer_new();
uint g_trash_stack_height(TrashStack** stack_p);
void* g_trash_stack_peek(TrashStack** stack_p);
void* g_trash_stack_pop(TrashStack** stack_p);
void g_trash_stack_push(TrashStack** stack_p, void* data_p);
void g_tree_destroy(Tree* this_);
void g_tree_foreach(Tree* this_, TraverseFunc func, void* user_data);
int g_tree_height(Tree* this_);
void g_tree_insert(Tree* this_, void* key, void* value);
void* g_tree_lookup(Tree* this_, const(void)* key);
int g_tree_lookup_extended(Tree* this_, const(void)* lookup_key, void** orig_key, void** value);
int g_tree_nnodes(Tree* this_);
Tree* g_tree_ref(Tree* this_);
int g_tree_remove(Tree* this_, const(void)* key);
void g_tree_replace(Tree* this_, void* key, void* value);
void* g_tree_search(Tree* this_, CompareFunc search_func, const(void)* user_data);
int g_tree_steal(Tree* this_, const(void)* key);
void g_tree_traverse(Tree* this_, TraverseFunc traverse_func, TraverseType traverse_type, void* user_data);
void g_tree_unref(Tree* this_);
Tree* g_tree_new(CompareFunc key_compare_func);
Tree* g_tree_new_full(CompareDataFunc key_compare_func, void* key_compare_data, DestroyNotify key_destroy_func, DestroyNotify value_destroy_func);
Tree* g_tree_new_with_data(CompareDataFunc key_compare_func, void* key_compare_data);
void g_tuples_destroy(Tuples* this_);
void* g_tuples_index(Tuples* this_, int index_, int field);
Variant* /*new*/ g_variant_new(char* format_string, ...);
Variant* g_variant_new_array(VariantType* child_type, Variant** children, size_t n_children);
Variant* g_variant_new_boolean(int value);
Variant* g_variant_new_byte(ubyte value);
Variant* g_variant_new_bytestring(ubyte* string_);
Variant* g_variant_new_bytestring_array(char** strv, ssize_t length);
Variant* g_variant_new_dict_entry(Variant* key, Variant* value);
Variant* g_variant_new_double(double value);
Variant* g_variant_new_from_data(VariantType* type, const(ubyte)* data, size_t size, int trusted, DestroyNotify notify, void* user_data);
Variant* g_variant_new_handle(int value);
Variant* g_variant_new_int16(short value);
Variant* g_variant_new_int32(int value);
Variant* g_variant_new_int64(long value);
Variant* g_variant_new_maybe(VariantType* child_type=null, Variant* child=null);
Variant* g_variant_new_object_path(char* object_path);
Variant* g_variant_new_objv(char** strv, ssize_t length);
Variant* /*new*/ g_variant_new_parsed(char* format, ...);
Variant* /*new*/ g_variant_new_parsed_va(char* format, va_list* app);
Variant* g_variant_new_signature(char* signature);
Variant* g_variant_new_string(char* string_);
Variant* g_variant_new_strv(char** strv, ssize_t length);
Variant* g_variant_new_tuple(Variant** children, size_t n_children);
Variant* g_variant_new_uint16(ushort value);
Variant* g_variant_new_uint32(uint value);
Variant* g_variant_new_uint64(ulong value);
Variant* /*new*/ g_variant_new_va(char* format_string, char** endptr, va_list* app);
Variant* g_variant_new_variant(Variant* value);
Variant* /*new*/ g_variant_byteswap(Variant* this_);
VariantClass g_variant_classify(Variant* this_);
int g_variant_compare(Variant* this_, const(Variant)* two);
ubyte* /*new*/ g_variant_dup_bytestring(Variant* this_, /*out*/ size_t* length=null);
char** /*new*/ g_variant_dup_bytestring_array(Variant* this_, /*out*/ size_t* length=null);
char** /*new*/ g_variant_dup_objv(Variant* this_, /*out*/ size_t* length=null);
char* /*new*/ g_variant_dup_string(Variant* this_, /*out*/ size_t* length);
char** /*new*/ g_variant_dup_strv(Variant* this_, /*out*/ size_t* length=null);
int g_variant_equal(Variant* this_, const(Variant)* two);
void g_variant_get(Variant* this_, char* format_string, ...);
int g_variant_get_boolean(Variant* this_);
ubyte g_variant_get_byte(Variant* this_);
ubyte* g_variant_get_bytestring(Variant* this_);
char** /*new container*/ g_variant_get_bytestring_array(Variant* this_, /*out*/ size_t* length=null);
void g_variant_get_child(Variant* this_, size_t index_, char* format_string, ...);
Variant* /*new*/ g_variant_get_child_value(Variant* this_, size_t index_);
const(void)* g_variant_get_data(Variant* this_);
double g_variant_get_double(Variant* this_);
const(void)* g_variant_get_fixed_array(Variant* this_, /*out*/ size_t* n_elements, size_t element_size);
int g_variant_get_handle(Variant* this_);
short g_variant_get_int16(Variant* this_);
int g_variant_get_int32(Variant* this_);
long g_variant_get_int64(Variant* this_);
Variant* /*new*/ g_variant_get_maybe(Variant* this_);
Variant* /*new*/ g_variant_get_normal_form(Variant* this_);
char** /*new container*/ g_variant_get_objv(Variant* this_, /*out*/ size_t* length=null);
size_t g_variant_get_size(Variant* this_);
char* g_variant_get_string(Variant* this_, /*out*/ size_t* length=null);
char** /*new container*/ g_variant_get_strv(Variant* this_, /*out*/ size_t* length=null);
char* g_variant_get_type_string(Variant* this_);
ushort g_variant_get_uint16(Variant* this_);
uint g_variant_get_uint32(Variant* this_);
ulong g_variant_get_uint64(Variant* this_);
void g_variant_get_va(Variant* this_, char* format_string, char** endptr, va_list* app);
Variant* /*new*/ g_variant_get_variant(Variant* this_);
uint g_variant_hash(Variant* this_);
int g_variant_is_container(Variant* this_);
int g_variant_is_floating(Variant* this_);
int g_variant_is_normal_form(Variant* this_);
int g_variant_is_of_type(Variant* this_, VariantType* type);
VariantIter* /*new*/ g_variant_iter_new(Variant* this_);
int g_variant_lookup(Variant* this_, char* key, char* format_string, ...);
Variant* /*new*/ g_variant_lookup_value(Variant* this_, char* key, VariantType* expected_type=null);
size_t g_variant_n_children(Variant* this_);
char* /*new*/ g_variant_print(Variant* this_, int type_annotate);
String* /*new*/ g_variant_print_string(Variant* this_, String* string_, int type_annotate);
Variant* /*new*/ g_variant_ref(Variant* this_);
Variant* /*new*/ g_variant_ref_sink(Variant* this_);
void g_variant_store(Variant* this_, void* data);
Variant* /*new*/ g_variant_take_ref(Variant* this_);
void g_variant_unref(Variant* this_);
int g_variant_is_object_path(char* string_);
int g_variant_is_signature(char* string_);
Variant* /*new*/ g_variant_parse(VariantType* type, char* text, char* limit, char** endptr, GLib2.Error** error);
Quark g_variant_parser_get_error_quark();
VariantBuilder* /*new*/ g_variant_builder_new(VariantType* type);
void g_variant_builder_add(VariantBuilder* this_, char* format_string, ...);
void g_variant_builder_add_parsed(VariantBuilder* this_, char* format, ...);
void g_variant_builder_add_value(VariantBuilder* this_, Variant* value);
void g_variant_builder_clear(VariantBuilder* this_);
void g_variant_builder_close(VariantBuilder* this_);
Variant* g_variant_builder_end(VariantBuilder* this_);
void g_variant_builder_init(VariantBuilder* this_, VariantType* type);
void g_variant_builder_open(VariantBuilder* this_, VariantType* type);
VariantBuilder* /*new*/ g_variant_builder_ref(VariantBuilder* this_);
void g_variant_builder_unref(VariantBuilder* this_);
VariantIter* /*new*/ g_variant_iter_copy(VariantIter* this_);
void g_variant_iter_free(VariantIter* this_);
size_t g_variant_iter_init(VariantIter* this_, Variant* value);
int g_variant_iter_loop(VariantIter* this_, char* format_string, ...);
size_t g_variant_iter_n_children(VariantIter* this_);
int g_variant_iter_next(VariantIter* this_, char* format_string, ...);
Variant* /*new*/ g_variant_iter_next_value(VariantIter* this_);
VariantType* /*new*/ g_variant_type_new(char* type_string);
VariantType* /*new*/ g_variant_type_new_tuple(VariantType** items, int length);
VariantType* /*new*/ g_variant_type_copy(VariantType* this_);
char* /*new*/ g_variant_type_dup_string(VariantType* this_);
VariantType* g_variant_type_element(VariantType* this_);
int g_variant_type_equal(VariantType* this_, const(VariantType)* type2);
VariantType* g_variant_type_first(VariantType* this_);
void g_variant_type_free(VariantType* this_);
size_t g_variant_type_get_string_length(VariantType* this_);
uint g_variant_type_hash(VariantType* this_);
int g_variant_type_is_array(VariantType* this_);
int g_variant_type_is_basic(VariantType* this_);
int g_variant_type_is_container(VariantType* this_);
int g_variant_type_is_definite(VariantType* this_);
int g_variant_type_is_dict_entry(VariantType* this_);
int g_variant_type_is_maybe(VariantType* this_);
int g_variant_type_is_subtype_of(VariantType* this_, VariantType* supertype);
int g_variant_type_is_tuple(VariantType* this_);
int g_variant_type_is_variant(VariantType* this_);
VariantType* g_variant_type_key(VariantType* this_);
size_t g_variant_type_n_items(VariantType* this_);
VariantType* /*new*/ g_variant_type_new_array(VariantType* this_);
VariantType* /*new*/ g_variant_type_new_dict_entry(VariantType* this_, VariantType* value);
VariantType* /*new*/ g_variant_type_new_maybe(VariantType* this_);
VariantType* g_variant_type_next(VariantType* this_);
char* g_variant_type_peek_string(VariantType* this_);
VariantType* g_variant_type_value(VariantType* this_);
VariantType* g_variant_type_checked_(char* arg_a);
int g_variant_type_string_is_valid(char* type_string);
int g_variant_type_string_scan(char* string_, char* limit=null, /*out*/ char** endptr=null);
int g_access(char* filename, int mode);
int g_ascii_digit_value(char c);
char* /*new*/ g_ascii_dtostr(char* buffer, int buf_len, double d);
char* /*new*/ g_ascii_formatd(char* buffer, int buf_len, char* format, double d);
int g_ascii_strcasecmp(char* s1, char* s2);
char* /*new*/ g_ascii_strdown(char* str, ssize_t len);
int g_ascii_strncasecmp(char* s1, char* s2, size_t n);
double g_ascii_strtod(char* nptr, char** endptr);
long g_ascii_strtoll(char* nptr, char** endptr, uint base);
ulong g_ascii_strtoull(char* nptr, char** endptr, uint base);
char* /*new*/ g_ascii_strup(char* str, ssize_t len);
char g_ascii_tolower(char c);
char g_ascii_toupper(char c);
int g_ascii_xdigit_value(char c);
void g_assert_warning(char* log_domain, char* file, int line, char* pretty_function, char* expression);
void g_assertion_message(char* domain, char* file, int line, char* func, char* message);
void g_assertion_message_cmpnum(char* domain, char* file, int line, char* func, char* expr, real arg1, char* cmp, real arg2, char numtype);
void g_assertion_message_cmpstr(char* domain, char* file, int line, char* func, char* expr, char* arg1, char* cmp, char* arg2);
void g_assertion_message_error(char* domain, char* file, int line, char* func, char* expr, Error* error, Quark error_domain, int error_code);
void g_assertion_message_expr(char* domain, char* file, int line, char* func, char* expr);
void g_atexit(VoidFunc func);
int g_atomic_int_add(int* atomic, int val);
uint g_atomic_int_and(uint* atomic, uint val);
int g_atomic_int_compare_and_exchange(int* atomic, int oldval, int newval);
int g_atomic_int_dec_and_test(int* atomic);
int g_atomic_int_exchange_and_add(int* atomic, int val);
int g_atomic_int_get(int* atomic);
void g_atomic_int_inc(int* atomic);
uint g_atomic_int_or(uint* atomic, uint val);
void g_atomic_int_set(int* atomic, int newval);
uint g_atomic_int_xor(uint* atomic, uint val);
ssize_t g_atomic_pointer_add(void* atomic, ssize_t val);
size_t g_atomic_pointer_and(void* atomic, size_t val);
int g_atomic_pointer_compare_and_exchange(void* atomic, void* oldval, void* newval);
void* g_atomic_pointer_get(void* atomic);
size_t g_atomic_pointer_or(void* atomic, size_t val);
void g_atomic_pointer_set(void* atomic, void* newval);
size_t g_atomic_pointer_xor(void* atomic, size_t val);
ubyte* /*new*/ g_base64_decode(char* text, /*out*/ size_t* out_len);
ubyte* g_base64_decode_inplace(/*inout*/ ubyte* text, /*inout*/ size_t* out_len);
size_t g_base64_decode_step(ubyte* in_, size_t len, /*out*/ ubyte* out_, /*inout*/ int* state, /*inout*/ uint* save);
char* /*new*/ g_base64_encode(ubyte* data, size_t len);
size_t g_base64_encode_close(int break_lines, /*out*/ ubyte* out_, /*inout*/ int* state, /*inout*/ int* save);
size_t g_base64_encode_step(ubyte* in_, size_t len, int break_lines, /*out*/ ubyte* out_, /*inout*/ int* state, /*inout*/ int* save);
char* g_basename(char* file_name);
void g_bit_lock(int* address, int lock_bit);
int g_bit_nth_lsf(c_ulong mask, int nth_bit);
int g_bit_nth_msf(c_ulong mask, int nth_bit);
uint g_bit_storage(c_ulong number);
int g_bit_trylock(int* address, int lock_bit);
void g_bit_unlock(int* address, int lock_bit);
void g_blow_chunks();
char* /*new*/ g_build_filename(char* first_element, ...);
char* /*new*/ g_build_filenamev(char** args);
char* /*new*/ g_build_path(char* separator, char* first_element, ...);
char* /*new*/ g_build_pathv(char* separator, char** args);
int g_chdir(char* path);
char* glib_check_version(uint required_major, uint required_minor, uint required_micro);
uint g_child_watch_add(Pid pid, ChildWatchFunc function_, void* data);
uint g_child_watch_add_full(int priority, Pid pid, ChildWatchFunc function_, void* data, DestroyNotify notify);
Source* /*new*/ g_child_watch_source_new(Pid pid);
void g_clear_error(GLib2.Error** error);
char* /*new*/ g_compute_checksum_for_data(ChecksumType checksum_type, ubyte* data, size_t length);
char* /*new*/ g_compute_checksum_for_string(ChecksumType checksum_type, char* str, ssize_t length);
char* /*new*/ g_compute_hmac_for_data(ChecksumType digest_type, ubyte* key, size_t key_len, ubyte* data, size_t length);
char* /*new*/ g_compute_hmac_for_string(ChecksumType digest_type, ubyte* key, size_t key_len, char* str, ssize_t length);
char* /*new*/ g_convert(char* str, ssize_t len, char* to_codeset, char* from_codeset, /*out*/ size_t* bytes_read, /*out*/ size_t* bytes_written, GLib2.Error** error);
Quark g_convert_error_quark();
char* /*new*/ g_convert_with_fallback(char* str, ssize_t len, char* to_codeset, char* from_codeset, char* fallback, size_t* bytes_read, size_t* bytes_written, GLib2.Error** error);
char* /*new*/ g_convert_with_iconv(char* str, ssize_t len, IConv converter, size_t* bytes_read, size_t* bytes_written, GLib2.Error** error);
void g_datalist_clear(Data** datalist);
void g_datalist_foreach(Data** datalist, DataForeachFunc func, void* user_data);
void* g_datalist_get_data(Data** datalist, char* key);
uint g_datalist_get_flags(Data** datalist);
void* g_datalist_id_get_data(Data** datalist, Quark key_id);
void* g_datalist_id_remove_no_notify(Data** datalist, Quark key_id);
void g_datalist_id_set_data_full(Data** datalist, Quark key_id, void* data, DestroyNotify destroy_func);
void g_datalist_init(Data** datalist);
void g_datalist_set_flags(Data** datalist, uint flags);
void g_datalist_unset_flags(Data** datalist, uint flags);
void g_dataset_destroy(const(void)* dataset_location);
void g_dataset_foreach(const(void)* dataset_location, DataForeachFunc func, void* user_data);
void* g_dataset_id_get_data(const(void)* dataset_location, Quark key_id);
void* g_dataset_id_remove_no_notify(const(void)* dataset_location, Quark key_id);
void g_dataset_id_set_data_full(const(void)* dataset_location, Quark key_id, void* data, DestroyNotify destroy_func);
char* g_dcgettext(char* domain, char* msgid, int category);
char* g_dgettext(char* domain, char* msgid);
int g_direct_equal(const(void)* v1, const(void)* v2);
uint g_direct_hash(const(void)* v);
char* g_dngettext(char* domain, char* msgid, char* msgid_plural, c_ulong n);
int g_double_equal(const(void)* v1, const(void)* v2);
uint g_double_hash(const(void)* v);
char* g_dpgettext(char* domain, char* msgctxtid, size_t msgidoffset);
char* g_dpgettext2(char* domain, char* context, char* msgid);
FileError g_file_error_from_errno(int err_no);
Quark g_file_error_quark();
int g_file_get_contents(char* filename, /*out*/ ubyte** contents, /*out*/ size_t* length, GLib2.Error** error);
int g_file_open_tmp(char* tmpl, /*out*/ char** name_used, GLib2.Error** error);
char* /*new*/ g_file_read_link(char* filename, GLib2.Error** error);
int g_file_set_contents(char* filename, ubyte* contents, ssize_t length, GLib2.Error** error);
int g_file_test(char* filename, FileTest test);
char* /*new*/ g_filename_display_basename(char* filename);
char* /*new*/ g_filename_display_name(char* filename);
char* /*new*/ g_filename_from_uri(char* uri, char** hostname, GLib2.Error** error);
char* /*new*/ g_filename_from_utf8(char* utf8string, ssize_t len, size_t* bytes_read, size_t* bytes_written, GLib2.Error** error);
char* /*new*/ g_filename_to_uri(char* filename, char* hostname, GLib2.Error** error);
char* /*new*/ g_filename_to_utf8(char* opsysstring, ssize_t len, size_t* bytes_read, size_t* bytes_written, GLib2.Error** error);
char* /*new*/ g_find_program_in_path(char* program);
char* /*new*/ g_format_size(ulong size);
char* /*new*/ g_format_size_for_display(long size);
char* /*new*/ g_format_size_full(ulong size, FormatSizeFlags flags);
int g_fprintf(FILE* file, char* format, ...);
void g_free(void* mem);
char* g_get_application_name();
int g_get_charset(char** charset);
char* /*new*/ g_get_current_dir();
void g_get_current_time(TimeVal* result);
char** /*new*/ g_get_environ();
int g_get_filename_charsets(char*** charsets);
char* g_get_home_dir();
char* g_get_host_name();
char** g_get_language_names();
char** /*new*/ g_get_locale_variants(char* locale);
long g_get_monotonic_time();
char* /*new*/ g_get_prgname();
char* g_get_real_name();
long g_get_real_time();
char** g_get_system_config_dirs();
char** g_get_system_data_dirs();
char* g_get_tmp_dir();
char* g_get_user_cache_dir();
char* g_get_user_config_dir();
char* g_get_user_data_dir();
char* g_get_user_name();
char* g_get_user_runtime_dir();
char* g_get_user_special_dir(UserDirectory directory);
char* g_getenv(char* variable);
int g_hostname_is_ascii_encoded(char* hostname);
int g_hostname_is_ip_address(char* hostname);
int g_hostname_is_non_ascii(char* hostname);
char* /*new*/ g_hostname_to_ascii(char* hostname);
char* /*new*/ g_hostname_to_unicode(char* hostname);
uint g_idle_add(SourceFunc function_, void* data);
uint g_idle_add_full(int priority, SourceFunc function_, void* data, DestroyNotify notify);
int g_idle_remove_by_data(void* data);
Source* /*new*/ g_idle_source_new();
int g_int64_equal(const(void)* v1, const(void)* v2);
uint g_int64_hash(const(void)* v);
int g_int_equal(const(void)* v1, const(void)* v2);
uint g_int_hash(const(void)* v);
char* g_intern_static_string(char* string_=null);
char* g_intern_string(char* string_=null);
uint g_io_add_watch(IOChannel* channel, IOCondition condition, IOFunc func, void* user_data);
uint g_io_add_watch_full(IOChannel* channel, int priority, IOCondition condition, IOFunc func, void* user_data, DestroyNotify notify);
Source* /*new*/ g_io_create_watch(IOChannel* channel, IOCondition condition);
char** /*new*/ g_listenv();
char* /*new*/ g_locale_from_utf8(char* utf8string, ssize_t len, size_t* bytes_read, size_t* bytes_written, GLib2.Error** error);
char* /*new*/ g_locale_to_utf8(char* opsysstring, ssize_t len, size_t* bytes_read, size_t* bytes_written, GLib2.Error** error);
void g_log(char* log_domain, LogLevelFlags log_level, char* format, ...);
void g_log_default_handler(char* log_domain, LogLevelFlags log_level, char* message, void* unused_data);
void g_log_remove_handler(char* log_domain, uint handler_id);
LogLevelFlags g_log_set_always_fatal(LogLevelFlags fatal_mask);
LogFunc g_log_set_default_handler(LogFunc log_func, void* user_data);
LogLevelFlags g_log_set_fatal_mask(char* log_domain, LogLevelFlags fatal_mask);
uint g_log_set_handler(char* log_domain, LogLevelFlags log_levels, LogFunc log_func, void* user_data);
void g_logv(char* log_domain, LogLevelFlags log_level, char* format, va_list args);
Source* g_main_current_source();
int g_main_depth();
void* g_malloc(size_t n_bytes);
void* g_malloc0(size_t n_bytes);
void* g_malloc0_n(size_t n_blocks, size_t n_block_bytes);
void* g_malloc_n(size_t n_blocks, size_t n_block_bytes);
int g_markup_collect_attributes(char* element_name, char** attribute_names, char** attribute_values, Error** error, MarkupCollectType first_type, char* first_attr, ...);
Quark g_markup_error_quark();
char* /*new*/ g_markup_escape_text(char* text, ssize_t length);
char* /*new*/ g_markup_printf_escaped(char* format, ...);
char* /*new*/ g_markup_vprintf_escaped(char* format, va_list args);
int g_mem_is_system_malloc();
void g_mem_profile();
void g_mem_set_vtable(MemVTable* vtable);
void* g_memdup(const(void)* mem, uint byte_size);
int g_mkdir_with_parents(char* pathname, int mode);
char* /*new*/ g_mkdtemp(char* tmpl);
char* /*new*/ g_mkdtemp_full(char* tmpl, int mode);
int g_mkstemp(char* tmpl);
int g_mkstemp_full(char* tmpl, int flags, int mode);
void g_nullify_pointer(void** nullify_location);
void g_on_error_query(char* prg_name);
void g_on_error_stack_trace(char* prg_name);
Quark g_option_error_quark();
uint g_parse_debug_string(char* string_, DebugKey* keys, uint nkeys);
char* /*new*/ g_path_get_basename(char* file_name);
char* /*new*/ g_path_get_dirname(char* file_name);
int g_path_is_absolute(char* file_name);
char* g_path_skip_root(char* file_name);
int g_pattern_match(PatternSpec* pspec, uint string_length, char* string_, char* string_reversed);
int g_pattern_match_simple(char* pattern, char* string_);
int g_pattern_match_string(PatternSpec* pspec, char* string_);
void g_pointer_bit_lock(void* address, int lock_bit);
int g_pointer_bit_trylock(void* address, int lock_bit);
void g_pointer_bit_unlock(void* address, int lock_bit);
int g_poll(PollFD* fds, uint nfds, int timeout);
void g_prefix_error(Error** err, char* format, ...);
void g_print(char* format, ...);
void g_printerr(char* format, ...);
int g_printf(char* format, ...);
size_t g_printf_string_upper_bound(char* format, va_list args);
void g_propagate_error(Error** dest, Error* src);
void g_propagate_prefixed_error(Error** dest, Error* src, char* format, ...);
void g_qsort_with_data(const(void)* pbase, int total_elems, size_t size, CompareDataFunc compare_func, void* user_data);
Quark g_quark_from_static_string(char* string_=null);
Quark g_quark_from_string(char* string_=null);
char* g_quark_to_string(Quark quark);
Quark g_quark_try_string(char* string_=null);
double g_random_double();
double g_random_double_range(double begin, double end);
uint g_random_int();
int g_random_int_range(int begin, int end);
void g_random_set_seed(uint seed);
void* g_realloc(void* mem, size_t n_bytes);
void* g_realloc_n(void* mem, size_t n_blocks, size_t n_block_bytes);
void g_reload_user_special_dirs_cache();
void g_return_if_fail_warning(char* log_domain, char* pretty_function, char* expression);
int g_rmdir(char* filename);
void g_set_application_name(char* application_name);
void g_set_error(Error** err, Quark domain, int code, char* format, ...);
void g_set_error_literal(Error** err, Quark domain, int code, char* message);
void g_set_prgname(char* prgname);
PrintFunc g_set_print_handler(PrintFunc func);
PrintFunc g_set_printerr_handler(PrintFunc func);
int g_setenv(char* variable, char* value, int overwrite);
Quark g_shell_error_quark();
int g_shell_parse_argv(char* command_line, /*out*/ int* argcp, /*out*/ char*** argvp, GLib2.Error** error);
char* /*new*/ g_shell_quote(char* unquoted_string);
char* /*new*/ g_shell_unquote(char* quoted_string, GLib2.Error** error);
void* g_slice_alloc(size_t block_size);
void* g_slice_alloc0(size_t block_size);
void* g_slice_copy(size_t block_size, const(void)* mem_block);
void g_slice_free1(size_t block_size, void* mem_block);
void g_slice_free_chain_with_offset(size_t block_size, void* mem_chain, size_t next_offset);
long g_slice_get_config(SliceConfig ckey);
long* g_slice_get_config_state(SliceConfig ckey, long address, uint* n_values);
void g_slice_set_config(SliceConfig ckey, long value);
int g_snprintf(char* string_, c_ulong n, char* format, ...);
uint g_spaced_primes_closest(uint num);
int g_spawn_async(char* working_directory, char** argv, char** envp, SpawnFlags flags, SpawnChildSetupFunc child_setup, void* user_data, /*out*/ Pid* child_pid, GLib2.Error** error);
int g_spawn_async_with_pipes(char* working_directory, char** argv, char** envp, SpawnFlags flags, SpawnChildSetupFunc child_setup, void* user_data, /*out*/ Pid* child_pid, /*out*/ int* standard_input, /*out*/ int* standard_output, /*out*/ int* standard_error, GLib2.Error** error);
void g_spawn_close_pid(Pid pid);
int g_spawn_command_line_async(char* command_line, GLib2.Error** error);
int g_spawn_command_line_sync(char* command_line, /*out*/ ubyte** standard_output, /*out*/ ubyte** standard_error, /*out*/ int* exit_status, GLib2.Error** error);
Quark g_spawn_error_quark();
int g_spawn_sync(char* working_directory, char** argv, char** envp, SpawnFlags flags, SpawnChildSetupFunc child_setup, void* user_data, /*out*/ ubyte** standard_output, /*out*/ ubyte** standard_error, /*out*/ int* exit_status, GLib2.Error** error);
int g_sprintf(char* string_, char* format, ...);
char* /*new*/ g_stpcpy(char* dest, char* src);
int g_str_equal(const(void)* v1, const(void)* v2);
int g_str_has_prefix(char* str, char* prefix);
int g_str_has_suffix(char* str, char* suffix);
uint g_str_hash(const(void)* v);
char* /*new*/ g_strcanon(char* string_, char* valid_chars, char substitutor);
int g_strcasecmp(char* s1, char* s2);
char* /*new*/ g_strchomp(char* string_);
char* /*new*/ g_strchug(char* string_);
int g_strcmp0(char* str1, char* str2);
char* /*new*/ g_strcompress(char* source);
char* /*new*/ g_strconcat(char* string1, ...);
char* /*new*/ g_strdelimit(char* string_, char* delimiters, char new_delimiter);
char* /*new*/ g_strdown(char* string_);
char* /*new*/ g_strdup(char* str);
char* /*new*/ g_strdup_printf(char* format, ...);
char* /*new*/ g_strdup_vprintf(char* format, va_list args);
char** g_strdupv(char** str_array);
char* g_strerror(int errnum);
char* /*new*/ g_strescape(char* source, char* exceptions);
void g_strfreev(char** str_array);
String* /*new*/ g_string_new(char* init);
String* /*new*/ g_string_new_len(char* init, ssize_t len);
String* /*new*/ g_string_sized_new(size_t dfl_size);
char* g_strip_context(char* msgid, char* msgval);
char* /*new*/ g_strjoin(char* separator, ...);
char* /*new*/ g_strjoinv(char* separator, char** str_array);
size_t g_strlcat(char* dest, char* src, size_t dest_size);
size_t g_strlcpy(char* dest, char* src, size_t dest_size);
int g_strncasecmp(char* s1, char* s2, uint n);
char* /*new*/ g_strndup(char* str, size_t n);
char* /*new*/ g_strnfill(size_t length, char fill_char);
char* /*new*/ g_strreverse(char* string_);
char* /*new*/ g_strrstr(char* haystack, char* needle);
char* /*new*/ g_strrstr_len(char* haystack, ssize_t haystack_len, char* needle);
char* g_strsignal(int signum);
char** g_strsplit(char* string_, char* delimiter, int max_tokens);
char** g_strsplit_set(char* string_, char* delimiters, int max_tokens);
char* /*new*/ g_strstr_len(char* haystack, ssize_t haystack_len, char* needle);
double g_strtod(char* nptr, char** endptr);
char* /*new*/ g_strup(char* string_);
Type g_strv_get_type();
uint g_strv_length(char** str_array);
void g_test_add_data_func(char* testpath, const(void)* test_data, TestDataFunc test_func);
void g_test_add_func(char* testpath, TestFunc test_func);
void g_test_add_vtable(char* testpath, size_t data_size, const(void)* test_data, TestFixtureFunc data_setup, TestFixtureFunc data_test, TestFixtureFunc data_teardown);
void g_test_bug(char* bug_uri_snippet);
void g_test_bug_base(char* uri_pattern);
TestCase* g_test_create_case(char* test_name, size_t data_size, const(void)* test_data, TestFixtureFunc data_setup, TestFixtureFunc data_test, TestFixtureFunc data_teardown);
TestSuite* g_test_create_suite(char* suite_name);
void g_test_fail();
TestSuite* g_test_get_root();
void g_test_init(int* argc, char*** argv, ...);
void g_test_log_set_fatal_handler(TestLogFatalFunc log_func, void* user_data);
char* g_test_log_type_name(TestLogType log_type);
void g_test_maximized_result(double maximized_quantity, char* format, ...);
void g_test_message(char* format, ...);
void g_test_minimized_result(double minimized_quantity, char* format, ...);
void g_test_queue_destroy(DestroyNotify destroy_func, void* destroy_data);
void g_test_queue_free(void* gfree_pointer);
double g_test_rand_double();
double g_test_rand_double_range(double range_start, double range_end);
int g_test_rand_int();
int g_test_rand_int_range(int begin, int end);
int g_test_run();
int g_test_run_suite(TestSuite* suite);
double g_test_timer_elapsed();
double g_test_timer_last();
void g_test_timer_start();
void g_test_trap_assertions(char* domain, char* file, int line, char* func, ulong assertion_flags, char* pattern);
int g_test_trap_fork(ulong usec_timeout, TestTrapFlags test_trap_flags);
int g_test_trap_has_passed();
int g_test_trap_reached_timeout();
uint g_timeout_add(uint interval, SourceFunc function_, void* data);
uint g_timeout_add_full(int priority, uint interval, SourceFunc function_, void* data, DestroyNotify notify);
uint g_timeout_add_seconds(uint interval, SourceFunc function_, void* data);
uint g_timeout_add_seconds_full(int priority, uint interval, SourceFunc function_, void* data, DestroyNotify notify);
Source* /*new*/ g_timeout_source_new(uint interval);
Source* /*new*/ g_timeout_source_new_seconds(uint interval);
void* g_try_malloc(size_t n_bytes);
void* g_try_malloc0(size_t n_bytes);
void* g_try_malloc0_n(size_t n_blocks, size_t n_block_bytes);
void* g_try_malloc_n(size_t n_blocks, size_t n_block_bytes);
void* g_try_realloc(void* mem, size_t n_bytes);
void* g_try_realloc_n(void* mem, size_t n_blocks, size_t n_block_bytes);
wchar* g_ucs4_to_utf16(dchar* str, c_long len, c_long* items_read, c_long* items_written, GLib2.Error** error);
char* /*new*/ g_ucs4_to_utf8(dchar* str, c_long len, c_long* items_read, c_long* items_written, GLib2.Error** error);
UnicodeBreakType g_unichar_break_type(dchar c);
int g_unichar_combining_class(dchar uc);
int g_unichar_compose(dchar a, dchar b, dchar* ch);
int g_unichar_decompose(dchar ch, dchar* a, dchar* b);
int g_unichar_digit_value(dchar c);
size_t g_unichar_fully_decompose(dchar ch, int compat, dchar* result, size_t result_len);
int g_unichar_get_mirror_char(dchar ch, dchar* mirrored_ch);
UnicodeScript g_unichar_get_script(dchar ch);
int g_unichar_isalnum(dchar c);
int g_unichar_isalpha(dchar c);
int g_unichar_iscntrl(dchar c);
int g_unichar_isdefined(dchar c);
int g_unichar_isdigit(dchar c);
int g_unichar_isgraph(dchar c);
int g_unichar_islower(dchar c);
int g_unichar_ismark(dchar c);
int g_unichar_isprint(dchar c);
int g_unichar_ispunct(dchar c);
int g_unichar_isspace(dchar c);
int g_unichar_istitle(dchar c);
int g_unichar_isupper(dchar c);
int g_unichar_iswide(dchar c);
int g_unichar_iswide_cjk(dchar c);
int g_unichar_isxdigit(dchar c);
int g_unichar_iszerowidth(dchar c);
int g_unichar_to_utf8(dchar c, char* outbuf);
dchar g_unichar_tolower(dchar c);
dchar g_unichar_totitle(dchar c);
dchar g_unichar_toupper(dchar c);
UnicodeType g_unichar_type(dchar c);
int g_unichar_validate(dchar ch);
int g_unichar_xdigit_value(dchar c);
dchar* g_unicode_canonical_decomposition(dchar ch, size_t* result_len);
void g_unicode_canonical_ordering(dchar* string_, size_t len);
UnicodeScript g_unicode_script_from_iso15924(uint iso15924);
uint g_unicode_script_to_iso15924(UnicodeScript script);
int g_unlink(char* filename);
void g_unsetenv(char* variable);
char* /*new*/ g_uri_escape_string(char* unescaped, char* reserved_chars_allowed, int allow_utf8);
char** g_uri_list_extract_uris(char* uri_list);
char* /*new*/ g_uri_parse_scheme(char* uri);
char* /*new*/ g_uri_unescape_segment(char* escaped_string, char* escaped_string_end, char* illegal_characters);
char* /*new*/ g_uri_unescape_string(char* escaped_string, char* illegal_characters);
void g_usleep(c_ulong microseconds);
dchar* g_utf16_to_ucs4(wchar* str, c_long len, c_long* items_read, c_long* items_written, GLib2.Error** error);
char* /*new*/ g_utf16_to_utf8(wchar* str, c_long len, c_long* items_read, c_long* items_written, GLib2.Error** error);
char* /*new*/ g_utf8_casefold(char* str, ssize_t len);
int g_utf8_collate(char* str1, char* str2);
char* /*new*/ g_utf8_collate_key(char* str, ssize_t len);
char* /*new*/ g_utf8_collate_key_for_filename(char* str, ssize_t len);
char* /*new*/ g_utf8_find_next_char(char* p, char* end);
char* /*new*/ g_utf8_find_prev_char(char* str, char* p);
dchar g_utf8_get_char(char* p);
dchar g_utf8_get_char_validated(char* p, ssize_t max_len);
char* /*new*/ g_utf8_normalize(char* str, ssize_t len, NormalizeMode mode);
char* /*new*/ g_utf8_offset_to_pointer(char* str, c_long offset);
c_long g_utf8_pointer_to_offset(char* str, char* pos);
char* /*new*/ g_utf8_prev_char(char* p);
char* /*new*/ g_utf8_strchr(char* p, ssize_t len, dchar c);
char* /*new*/ g_utf8_strdown(char* str, ssize_t len);
c_long g_utf8_strlen(char* p, ssize_t max);
char* /*new*/ g_utf8_strncpy(char* dest, char* src, size_t n);
char* /*new*/ g_utf8_strrchr(char* p, ssize_t len, dchar c);
char* /*new*/ g_utf8_strreverse(char* str, ssize_t len);
char* /*new*/ g_utf8_strup(char* str, ssize_t len);
char* /*new*/ g_utf8_substring(char* str, c_long start_pos, c_long end_pos);
dchar* g_utf8_to_ucs4(char* str, c_long len, c_long* items_read, c_long* items_written, GLib2.Error** error);
dchar* g_utf8_to_ucs4_fast(char* str, c_long len, c_long* items_written);
wchar* g_utf8_to_utf16(char* str, c_long len, c_long* items_read, c_long* items_written, GLib2.Error** error);
int g_utf8_validate(char* str, ssize_t max_len, /*out*/ char** end=null);
Type g_variant_get_gtype();
VariantType* g_variant_get_type(Variant* value);
int g_vasprintf(char** string_, char* format, va_list args);
int g_vfprintf(FILE* file, char* format, va_list args);
int g_vprintf(char* format, va_list args);
int g_vsnprintf(char* string_, c_ulong n, char* format, va_list args);
int g_vsprintf(char* string_, char* format, va_list args);
void g_warn_message(char* domain, char* file, int line, char* func, char* warnexpr);
}