1.1. Idle functions

Besides events, you can also register idle functions. If your application has to do some work what has very low priority (e.g refining graphics or save some backups or user information), it can be done with an idle function. These functions run only when no events exist in the event queue.

1.2. Timeout functions

Timeout functions work in a bit different way. After the given time, a new event gets into the event loop, with a default priority. This event will generate a call to the specified function. After the function call, the timer restarts, but only if the timeout function returned TRUE. Otherwise, this timer gets destroyed, and will generate events no more.

#include <glib.h>

#define COUNT_UNTIL 2
#define TIMEOUT 2

static int counter;

GMainLoop *main_loop;

gboolean
timeout_func(gpointer data)
{
    counter++;

    g_printf("Running for the %d. time.\n", counter);

    if (counter == COUNT_UNTIL)
    {
        g_main_loop_quit(main_loop);
        return FALSE;
    }

    return TRUE;
}

int
main(int argc, char **argv)
{
    counter = 0;

    main_loop = g_main_loop_new(NULL, FALSE);

    g_timeout_add_seconds(TIMEOUT, timeout_func, NULL);

    g_main_loop_run(main_loop);

    return 0;
}

After compiling and running this example, you will see that (in the ideal case) timeout_func() will be called every two seconds, exactly two times. Let's get through this program, line by line.

In main(), I simply initialize the counter variable to indicate that the current loop number is 0. Then I create the main loop object with g_main_loop_new(). The first parameter is the context, where the event loop will receive its events. As I passed NULL, it will be set to the default context. In a more complicated environment, e.g when using threads, it can be something totally different. The second parameter is FALSE, which indicates that this loop is currently not running. In some special cases a main loop can be initialized with a running state if you set this parameter to TRUE.

When the main loop is created, I add a new timeout function. In every TIMEOUT seconds, the function timeout_func() will be called with the user parameter of NULL.

Now that the main loop is ready, and we set up every event sources, it's time to get this loop running. This is done in the next line, with the call to g_main_loop_run(). It gets only one parameter: the variable which contains the event loop "object".

When our main event loop will end, the program gets to the last line, which will make main() to return 0, indicating that everything went fine. But how will this infinite loop end?

timeout_func() will do this work. First of all, it increases the counter variable, then it prints out the number of the current call, and check the counter variable. If it reached COUNT_UNTIL, it calls g_main_loop_quit(), which will tell the running event loop main_loop to finish running. In this case, the loop will wait for every running event handlers to return, and when they do, the call to g_main_loop_run() in main() will return. Also, to be so called good programmers, we return FALSE to indicate that we don't need this timeout function any more, so it can be removed from the event loop's sources.

This strictness is not really needed in this example. As we already said our event loop to stop running, it will never call timeout_func() again. Anyhow, it's easier to learn this type of programming this early. It can save you hours of debugging later.

At the end of timeout_func() I return TRUE. This will tell the timeout handler that we still need this function to be called after the specified time (defined in seconds with the TIMEOUT macro) elapses.

2.1. Basic memory handling

GLib has recreated the standard memory allocation procedures. Their functions use the standard ones as a backend, but they are extended heavily. They can terminate your application when they cannot allocate memory, or fill the allocated space with zeros. Also, there are some macros to ease the allocation of memory "arrays", like many int *'s. It's good to see this written, but how does it work?

#include <glib.h>

int
main(int argc, char **argv)
{
    gchar *string;
    gsize huge_size = 0xffffffff;

    string = g_new(gchar, 10);
    /* string is not initialized, it points to a random area now */
    string[0] = 'H';
    string[1] = '!';
    string[2] = '\0';
    g_printf("%s\n", string);
    g_free(string);

    string = (gchar *)g_malloc0(10);
    /* string is now initilazized with nul-bytes */
    string[0] = 'H';
    string[1] = '!';
    g_printf("%s\n", string);
    g_free(string);

    /* The next allocate should fail */
    string = g_try_malloc(huge_size);
    if (string == NULL)
        g_printf("Failed to allocate %lu bytes of memory.\n", huge_size);
    else
        g_free(string);

    return 0;
}

This little program demostrates the three main aspects of memory allocation. In the first part, I allocate a gchar pointer with 10 bytes of memory. g_new doesn't initialize the allocated memory, so the string I put in it by characters (H and !) has to be suffixed with a nul-byte.

2.2. Memory slices and chunks

Slices are small chunks of memory with equal sizes. Their use over the standard or GLib'ized malloc() family is wise if you need many chunks of memory with a small size, because the allocator is optimized. This way you application will consume much less physical memory. Although memory is not a real problem nowadays, it can also speed up your application. In pre-2.8 GLib they were called memory chunks, which had several disadvantages. So called memory chunks are now deprecated, and slices should be used instead.

2.3. Caches

Caches allow sharing of complex data structures. This can come handy if you need to share bigger resources.

2.4. Trash stacks

3.1. Singly linked lists

Singly linked lists are the most effective if memory comes into your mind. In this case the internal structure contains only one pointer which points to the next element. This make searching a bit slow, as you need to start from the first element to iterate through the whole list. It uses the slice allocator, thus being very effective on memory usage.

3.2. Doubly linked lists

The doubly linked list is the improved version of the singly linked one. In this case, the structure also contains a pointer to the previous value. This can speed up searching, but because of the two internal pointers it consumes a bit more memory. However, it also uses the slice allocator, so the memory usage of this list can still be small.

3.3. Double-ended queues

Queues are special doubly linked lists. Queues store both the starting and ending element of the list, so it is easy to use them both as a FIFO or LIFO queue. Using this type of list is much slower than the former two, as it always have to update its internal structure, which contains a pointer of the starting and ending element, so as the count of elements.

3.4. Sequences

Sequences are the other type of special lists. The API suggests it's some sort of a list, but internally it is stored as a binary tree. This makes sequences highly sortable.

3.5. Hash tables

Hash tables are what their name suggests: tables. They are actually key-value pairs, making them good for storing data like configuration items and such.

3.6. Arrays

Normal, pointer and byte arrays

3.7. Balanced binary trees

Balanced binary trees can be looked at as they are hash tables optimized for searching and traversing in order.

3.8. N-ary trees

3.9. Quarks

3.10. Keyed data lists

3.11. Datasets

3.12. Relations and tuples

4.1. Basic string handling

dup, fill, etc.

4.2. Advanced string handling

4.3. Formatting and printing

*printf*

4.4. Getting character information (character classes)

is_*

4.5. Basic string conversion

upper, lower, reverse and friends

4.6. Advanced conversion

split and company

4.7. Character set conversion

4.8. Unicode handling

4.9. Base64 encoding

4.10. Checksums

4.11. URI functions

4.12. Shell related functions

4.13. Glob-style pattern matching

4.14. Simple XML parser

There is a library called libxml2, which is developed in parallel to GLib. It can be used for XML parsing (either), but there are times when you need to parse a very small XML chunk. For this, GLib gave us this very simple XML parser.