glib.c.types

Undocumented in source.

Public Imports

gid.basictypes public import gid.basictypes;: Undocumented in source.

Members

Aliases

GDateDay alias GDateDay = ubyte: Integer representing a day of the month; between 1 and 31.
GDateYear alias GDateYear = ushort: Integer type representing a year.
GIConv alias GIConv = void*
GMainContextPusher alias GMainContextPusher = void: Opaque type. See g_main_context_pusher_new() for details.
GMutexLocker alias GMutexLocker = void: Opaque type. See g_mutex_locker_new() for details.
GPid alias GPid = int: A type which is used to hold a process identification.
GQuark alias GQuark = uint: A GQuark is a non-zero integer which uniquely identifies a particular string.
GRWLockReaderLocker alias GRWLockReaderLocker = void: Opaque type. See g_rw_lock_reader_locker_new() for details.
GRWLockWriterLocker alias GRWLockWriterLocker = void: Opaque type. See g_rw_lock_writer_locker_new() for details.
GRecMutexLocker alias GRecMutexLocker = void: Opaque type. See g_rec_mutex_locker_new() for details.
GRefString alias GRefString = char: A typedef for a reference-counted string. A pointer to a #GRefString can be treated like a standard char* array by all code, but can additionally have g_ref_string_*() methods called on it. g_ref_string_*() methods cannot be called on char* arrays not allocated using glib.global.refStringNew.
GStrv
alias GStrv = char**: A typedef alias for gchar**. This is mostly useful when used together with g_auto().
GTime alias GTime = int: Simply a replacement for time_t. It has been deprecated since it is not equivalent to time_t on 64-bit platforms with a 64-bit time_t.
GTimeSpan alias GTimeSpan = long: A value representing an interval of time, in microseconds.

Enums

GAsciiType enum GAsciiType

GBookmarkFileError enum GBookmarkFileError

Error codes returned by bookmark file parsing.

GChecksumType enum GChecksumType

The hashing algorithm to be used by #GChecksum when performing the digest of some data.

GConvertError enum GConvertError

Error codes returned by character set conversion routines.

GDateDMY enum GDateDMY

This enumeration isn't used in the API, but may be useful if you need to mark a number as a day, month, or year.

GDateMonth enum GDateMonth

Enumeration representing a month; values are G_DATE_JANUARY, G_DATE_FEBRUARY, etc. G_DATE_BAD_MONTH is the invalid value.

GDateWeekday enum GDateWeekday

Enumeration representing a day of the week; G_DATE_MONDAY, G_DATE_TUESDAY, etc. G_DATE_BAD_WEEKDAY is an invalid weekday.

GErrorType enum GErrorType

The possible errors, used in the @v_error field of #GTokenValue, when the token is a G_TOKEN_ERROR.

GFileError enum GFileError

Values corresponding to @errno codes returned from file operations on UNIX. Unlike @errno codes, GFileError values are available on all systems, even Windows. The exact meaning of each code depends on what sort of file operation you were performing; the UNIX documentation gives more details. The following error code descriptions come from the GNU C Library manual, and are under the copyright of that manual.

GFileSetContentsFlags enum GFileSetContentsFlags

Flags to pass to glib.global.fileSetContentsFull to affect its safety and performance.

GFileTest enum GFileTest

A test to perform on a file using glib.global.fileTest.

GFormatSizeFlags enum GFormatSizeFlags

Flags to modify the format of the string returned by glib.global.formatSizeFull.

GHookFlagMask enum GHookFlagMask

Flags used internally in the #GHook implementation.

GIOChannelError enum GIOChannelError

Error codes returned by #GIOChannel operations.

GIOCondition enum GIOCondition

A bitwise combination representing a condition to watch for on an event source.

GIOError enum GIOError

#GIOError is only used by the deprecated functions glib.iochannel.IOChannel.read, glib.iochannel.IOChannel.write, and glib.iochannel.IOChannel.seek.

GIOFlags enum GIOFlags

Specifies properties of a #GIOChannel. Some of the flags can only be read with glib.iochannel.IOChannel.getFlags, but not changed with glib.iochannel.IOChannel.setFlags.

GIOStatus enum GIOStatus

Statuses returned by most of the #GIOFuncs functions.

GKeyFileError enum GKeyFileError

Error codes returned by key file parsing.

GKeyFileFlags enum GKeyFileFlags

Flags which influence the parsing.

GLogLevelFlags enum GLogLevelFlags

Flags specifying the level of log messages.

GLogWriterOutput enum GLogWriterOutput

Return values from #GLogWriterFuncs to indicate whether the given log entry was successfully handled by the writer, or whether there was an error in handling it (and hence a fallback writer should be used).

GMainContextFlags enum GMainContextFlags

Flags to pass to glib.main_context.MainContext.newWithFlags which affect the behaviour of a #GMainContext.

GMarkupCollectType enum GMarkupCollectType

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.

GMarkupError enum GMarkupError

Error codes returned by markup parsing.

GMarkupParseFlags enum GMarkupParseFlags

Flags that affect the behaviour of the parser.

GNormalizeMode enum GNormalizeMode

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.

GNumberParserError enum GNumberParserError

Error codes returned by functions converting a string to a number.

GOnceStatus enum GOnceStatus

The possible statuses of a one-time initialization function controlled by a #GOnce struct.

GOptionArg enum GOptionArg

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: -x arg, with a long option: --name arg or combined in a single argument: --name=arg.

GOptionError enum GOptionError

Error codes returned by option parsing.

GOptionFlags enum GOptionFlags

Flags which modify individual options.

GRegexCompileFlags enum GRegexCompileFlags

Flags specifying compile-time options.

GRegexError enum GRegexError

Error codes returned by regular expressions functions.

GRegexMatchFlags enum GRegexMatchFlags

Flags specifying match-time options.

GSeekType enum GSeekType

An enumeration specifying the base position for a glib.iochannel.IOChannel.seekPosition operation.

GShellError enum GShellError

Error codes returned by shell functions.

GSliceConfig enum GSliceConfig

GSpawnError enum GSpawnError

Error codes returned by spawning processes.

GSpawnFlags enum GSpawnFlags

Flags passed to glib.global.spawnSync, glib.global.spawnAsync and glib.global.spawnAsyncWithPipes.

GTestFileType enum GTestFileType

The type of file to return the filename for, when used with glib.global.testBuildFilename.

GTestLogType enum GTestLogType

GTestResult enum GTestResult

GTestSubprocessFlags enum GTestSubprocessFlags

Flags to pass to glib.global.testTrapSubprocess to control input and output.

GTestTrapFlags enum GTestTrapFlags

Test traps are guards around forked tests. These flags determine what traps to set.

GThreadError enum GThreadError

Possible errors of thread related functions.

GThreadPriority enum GThreadPriority

Thread priorities.

GTimeType enum GTimeType

Disambiguates a given time in two ways.

GTokenType enum GTokenType

The possible types of token returned from each glib.scanner.Scanner.getNextToken call.

GTraverseFlags enum GTraverseFlags

Specifies which nodes are visited during several of the tree functions, including glib.node.Node.traverse and glib.node.Node.find.

GTraverseType enum GTraverseType

Specifies the type of traversal performed by glib.tree.Tree.traverse, glib.node.Node.traverse and glib.node.Node.find. The different orders are illustrated here:

In order: A, B, C, D, E, F, G, H, I
Pre order: F, B, A, D, C, E, G, I, H
Post order: A, C, E, D, B, H, I, G, F
Level order: F, B, G, A, D, I, C, E, H

GUnicodeBreakType enum GUnicodeBreakType

These are the possible line break classifications.

GUnicodeScript enum GUnicodeScript

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.

GUnicodeType enum GUnicodeType

These are the possible character classifications from the Unicode specification. See Unicode Character Database.

GUnixPipeEnd enum GUnixPipeEnd

Mnemonic constants for the ends of a Unix pipe.

GUriError enum GUriError

Error codes returned by #GUri methods.

GUriFlags enum GUriFlags

Flags that describe a URI.

GUriHideFlags enum GUriHideFlags

Flags describing what parts of the URI to hide in glib.uri.Uri.toStringPartial. Note that G_URI_HIDE_PASSWORD and G_URI_HIDE_AUTH_PARAMS will only work if the #GUri was parsed with the corresponding flags.

GUriParamsFlags enum GUriParamsFlags

Flags modifying the way parameters are handled by glib.uri.Uri.parseParams and #GUriParamsIter.

GUserDirectory enum GUserDirectory

These are logical ids for special directories which are defined depending on the platform used. You should use glib.global.getUserSpecialDir to retrieve the full path associated to the logical id.

GVariantClass enum GVariantClass

The range of possible top-level types of #GVariant instances.

GVariantParseError enum GVariantParseError

Error codes returned by parsing text-format GVariants.

Structs

GAllocator struct GAllocator
GArray struct GArray: Contains the public fields of a GArray.
GAsyncQueue struct GAsyncQueue: An opaque data structure which represents an asynchronous queue.
GBookmarkFile struct GBookmarkFile: glib.bookmark_file.BookmarkFile lets you parse, edit or create files containing bookmarks.
GByteArray struct GByteArray: Contains the public fields of a GByteArray.
GBytes struct GBytes: A simple refcounted data type representing an immutable sequence of zero or more bytes from an unspecified origin.
GCache struct GCache: A glib.cache.Cache allows sharing of complex data structures, in order to save system resources.
GChecksum struct GChecksum: GLib provides a generic API for computing checksums (or ‘digests’) for a sequence of arbitrary bytes, using various hashing algorithms like MD5, SHA-1 and SHA-256. Checksums are commonly used in various environments and specifications.
GCompletion struct GCompletion: glib.completion.Completion provides support for automatic completion of a string using any group of target strings. It is typically used for file name completion as is common in many UNIX shells.
GCond struct GCond: 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.
GData struct GData: An opaque data structure that represents a keyed data list.
GDate struct GDate: glib.date.Date is a struct for calendrical calculations.
GDateTime struct GDateTime: glib.date_time.DateTime is a structure that combines a Gregorian date and time into a single structure.
GDebugKey struct GDebugKey: Associates a string with a bit flag. Used in glib.global.parseDebugString.
GDir struct GDir: An opaque structure representing an opened directory.
GError struct GError: The glib.error.ErrorG structure contains information about an error that has occurred.
GHashTable struct GHashTable: The #GHashTable struct is an opaque data structure to represent a [Hash Table][glib-Hash-Tables]. It should only be accessed via the following functions.
GHashTableIter struct GHashTableIter: 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 glib.hash_table_iter.HashTableIter.init_.
GHmac struct GHmac: HMACs should be used when producing a cookie or hash based on data and a key. Simple mechanisms for using SHA1 and other algorithms to digest a key and data together are vulnerable to various security issues. HMAC
uses algorithms like SHA1 in a secure way to produce a digest of a key and data.
GHook struct GHook: The #GHook struct represents a single hook function in a #GHookList.
GHookList struct GHookList: The #GHookList struct represents a list of hook functions.
GIOChannel struct GIOChannel: The glib.iochannel.IOChannel data type aims to provide a portable method for using file descriptors, pipes, and sockets, and integrating them into the main event loop (see glib.main_context.MainContext). Currently, full support is available on UNIX platforms; support for Windows is only partially complete.
GIOFuncs struct GIOFuncs: A table of functions used to handle different types of #GIOChannel in a generic way.
GKeyFile struct GKeyFile: glib.key_file.KeyFile parses .ini-like config files.
GList struct GList: The #GList struct is used for each element in a doubly-linked list.
GLogField struct GLogField: Structure representing a single field in a structured log entry. See glib.global.logStructured for details.
GMainContext struct GMainContext: The glib.main_context.MainContext struct is an opaque data type representing a set of sources to be handled in a main loop.
GMainLoop struct GMainLoop: The glib.main_loop.MainLoop struct is an opaque data type representing the main event loop of a GLib or GTK application.
GMappedFile struct GMappedFile: The #GMappedFile represents a file mapping created with glib.mapped_file.MappedFile.new_. It has only private members and should not be accessed directly.
GMarkupParseContext struct GMarkupParseContext: A parse context is used to parse a stream of bytes that you expect to contain marked-up text.
GMarkupParser struct GMarkupParser: 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, glib.markup_parse_context.MarkupParseContext.parse will report that error back to its caller.
GMatchInfo struct GMatchInfo: A GMatchInfo is an opaque struct used to return information about matches.
GMemChunk struct GMemChunk
GMemVTable struct GMemVTable: 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 glib.global.memSetVtable, if it exists, should be prior to any use of GLib.
GNode struct GNode: The #GNode struct represents one node in a [n-ary tree][glib-N-ary-Trees].
GOnce struct GOnce: A #GOnce struct controls a one-time initialization function. Any one-time initialization function must have its own unique #GOnce struct.
GOptionContext struct GOptionContext: A glib.option_context.OptionContext struct defines which options are accepted by the commandline option parser. The struct has only private fields and should not be directly accessed.
GOptionEntry struct GOptionEntry: A GOptionEntry struct defines a single option. To have an effect, they must be added to a #GOptionGroup with glib.option_context.OptionContext.addMainEntries or glib.option_group.OptionGroup.addEntries.
GOptionGroup struct GOptionGroup: A glib.option_group.OptionGroup struct defines the options in a single group. The struct has only private fields and should not be directly accessed.
GPathBuf struct GPathBuf: glib.path_buf.PathBuf is a helper type that allows you to easily build paths from individual elements, using the platform specific conventions for path separators.
GPatternSpec struct GPatternSpec: A glib.pattern_spec.PatternSpec struct is the 'compiled' form of a glob-style pattern.
GPollFD struct GPollFD: Represents a file descriptor, which events to poll for, and which events occurred.
GPrivate struct GPrivate: The #GPrivate struct is an opaque data structure to represent a thread-local data key. It is approximately equivalent to the pthread_setspecific()/pthread_getspecific() APIs on POSIX and to TlsSetValue()/TlsGetValue() on Windows.
GPtrArray struct GPtrArray: Contains the public fields of a pointer array.
GQueue struct GQueue: Contains the public fields of a Queue[glib-Double-ended-Queues].
GRWLock struct GRWLock: The GRWLock struct is an opaque data structure to represent a reader-writer lock. It is similar to a #GMutex in that it allows multiple threads to coordinate access to a shared resource.
GRand struct GRand: The GRand struct is an opaque data structure. It should only be accessed through the g_rand_* functions.
GRecMutex struct GRecMutex: The GRecMutex struct is an opaque data structure to represent a recursive mutex. It is similar to a #GMutex with the difference that it is possible to lock a GRecMutex multiple times in the same thread without deadlock. When doing so, care has to be taken to unlock the recursive mutex as often as it has been locked.
GRegex struct GRegex: A glib.regex.Regex is the "compiled" form of a regular expression pattern.
GRelation struct GRelation: A glib.relation.Relation is a table of data which can be indexed on any number of fields, rather like simple database tables. A glib.relation.Relation contains a number of records, called tuples. Each record contains a number of fields. Records are not ordered, so it is not possible to find the record at a particular index.
GSList struct GSList: The #GSList struct is used for each element in the singly-linked list.
GScanner struct GScanner: glib.scanner.Scanner provides a general-purpose lexical scanner.
GScannerConfig struct GScannerConfig: Specifies the #GScanner parser configuration. Most settings can be changed during the parsing phase and will affect the lexical parsing of the next unpeeked token.
GSequence struct GSequence: The #GSequence struct is an opaque data type representing a sequence[glib-Sequences] data type.
GSequenceIter struct GSequenceIter: The #GSequenceIter struct is an opaque data type representing an iterator pointing into a #GSequence.
GSource struct GSource: The glib.source.Source struct is an opaque data type representing an event source.
GSourceCallbackFuncs struct GSourceCallbackFuncs: The glib.types.SourceCallbackFuncs struct contains functions for managing callback objects.
GSourceFuncs struct GSourceFuncs: The glib.types.SourceFuncs struct contains a table of functions used to handle event sources in a generic manner.
GSourcePrivate struct GSourcePrivate
GStatBuf struct GStatBuf: A type corresponding to the appropriate struct type for the stat() system call, depending on the platform and/or compiler being used.
GStaticMutex struct GStaticMutex: A #GStaticMutex works like a #GMutex.
GStaticPrivate struct GStaticPrivate: 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.
GStaticRWLock struct GStaticRWLock: 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.
GStaticRecMutex struct GStaticRecMutex: 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 glib.static_rec_mutex.StaticRecMutex.unlockFull: 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 glib.static_rec_mutex.StaticRecMutex.lockFull. In GLib 2.32, #GStaticRecMutex has been deprecated in favor of #GRecMutex.
GString struct GString: A glib.string_.String is an object that handles the memory management of a C string.
GStringChunk struct GStringChunk: glib.string_chunk.StringChunk provides efficient storage of groups of strings
GStrvBuilder struct GStrvBuilder: glib.strv_builder.StrvBuilder is a helper object to build a null-terminated string arrays.
GTestCase struct GTestCase: An opaque structure representing a test case.
GTestConfig struct GTestConfig
GTestLogBuffer struct GTestLogBuffer
GTestLogMsg struct GTestLogMsg
GTestSuite struct GTestSuite: An opaque structure representing a test suite.
GThread struct GThread: The #GThread struct represents a running thread. This struct is returned by glib.thread.Thread.new_ or glib.thread.Thread.tryNew. You can obtain the #GThread struct representing the current thread by calling glib.thread.Thread.self.
GThreadFunctions struct GThreadFunctions: This function table is no longer used by glib.thread.Thread.init_ to initialize the thread system.
GThreadPool struct GThreadPool: The glib.thread_pool.ThreadPool struct represents a thread pool.
GTimeVal struct GTimeVal: Represents a precise time, with seconds and microseconds.
GTimeZone struct GTimeZone: A glib.time_zone.TimeZone represents a time zone, at no particular point in time.
GTimer struct GTimer: glib.timer.Timer records a start time, and counts microseconds elapsed since that time.
GTrashStack struct GTrashStack: A glib.trash_stack.TrashStack is an efficient way to keep a stack of unused allocated memory chunks. Each memory chunk is required to be large enough to hold a [xlib.types.void*]. This allows the stack to be maintained without any space overhead, since the stack pointers can be stored inside the memory chunks.
GTree struct GTree: The GTree struct is an opaque data structure representing a [balanced binary tree][glib-Balanced-Binary-Trees]. It should be accessed only by using the following functions.
GTreeNode struct GTreeNode: An opaque type which identifies a specific node in a #GTree.
GTuples struct GTuples: The #GTuples struct is used to return records (or tuples) from the #GRelation by glib.relation.Relation.select. It only contains one public member - the number of records that matched. To access the matched records, you must use glib.tuples.Tuples.index.
GUnixPipe struct GUnixPipe: A Unix pipe. The advantage of this type over int[2] is that it can be closed automatically when it goes out of scope, using g_auto(GUnixPipe), on compilers that support that feature.
GUri struct GUri: The glib.uri.Uri type and related functions can be used to parse URIs into their components, and build valid URIs from individual components.
GUriParamsIter struct GUriParamsIter: Many URI schemes include one or more attribute/value pairs as part of the URI value. For example scheme://server/path?query=string&is=there has two attributes – query=string and is=there – in its query part.
GVariantBuilder struct GVariantBuilder: A utility type for constructing container-type #GVariant instances.
GVariantDict struct GVariantDict: #GVariantDict is a mutable interface to #GVariant dictionaries.
GVariantIter struct GVariantIter: #GVariantIter is an opaque data structure and can only be accessed using the following functions.
GVariantType struct GVariantType: A type in the glib.variant.VariantG type system.
VariantC struct VariantC: glib.variant.VariantG is a variant datatype; it can contain one or more values along with information about the type of the values.

Unions

GMutex union GMutex: The #GMutex struct is an opaque data structure to represent a mutex (mutual exclusion). It can be used to protect data against shared access.
GTokenValue union GTokenValue: A union holding the value of the token.

glib c modules