Copyright © 2002 by Mige Harimurti
This material may be distributed only subject to the terms and conditions set forth in Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/).
Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.
Daftar Isi
glib adalah pustaka (library) dalam bahasa pemrograman C. Tujuan dari pustaka ini portabilitas, terutama pada sistem-sistem UNIX dan Windows. Disertakan juga di dalam glib struktur data yang sering digunakan dalam pembuatan program, khususnya untuk aplikasi GTK+ dan Gnome. Karakteristik penting dari glib yaitu :
sederhana
konsisten
object oriented
Sifat-sifat ini dijaga semaksimal mungkin dalam glib. Mengapa menggunakan C bukan C++ ? Bahasa C adalah bahasa yang telah matang, dengan standard yang telah diimplementasikan di berbagai jenis platform. Mungkin hal yang agak aneh adalah bagaimana object oriented dalam bahasa C. Sifat object oriented ini diimpelementasikan dengan 'aturan' nama fungsi dan urutan parameternya dalam glib. Juga urutan variabel dalam pembuatan struktur data.
glib mempunyai hanya satu berkas header yaitu 'glib.h'. Sangat dianjurkan untuk melihat glib.h untuk mengetahui lebih dalam tentang pustaka ini. Bahkan jika anda mempunyai pengalaman dalam pemrograman dengan bahasa C, dianjurkan untuk melihat source code glib. Karena anda akan melihat gaya pemrograman yang bersih dan mudah dibaca. Juga dapat digunakan sebagai referensi dalam jika anda membuat pustaka (library).
glib menyediakan pengganti elemen-elemen dasar dalam bahasa C standard. Di bawah ini akan dijelaskan tipe, makro, dan fungsi-fungsi alokasi memori serta fungsi-fungsi pengolahan string.
glib menggunakan definisi tipe sendiri sebagai pengganti tipe dasar dalam bahasa C. Dengan beberapa tujuan yang diharapkan. Sebagai contoh : gint32 akan dipastikan 32 bit, yang dalam C standard tidak dapat dipastikan; guint lebih mudah ditulis daripada unsigned. Beberapa digunakan untuk menjaga konsistensi, seperti : gchar sebagai pengganti dari char.
Tipe dasar yang didefinisikan oleh glib :
gint8, guint8, gint16, guint16, gint32, guint32, gint64, and guint64 adalah integer dengan kepastian ukuran. Namun tidak semua platform menyediakan integer 64 bit. Jika ada, glib akan mendefinisikan (define)G_HAVE_GINT64.
gboolean berguna untuk membuat kode anda lebih terbaca karena C tidak mempunyai tipe boolean.
gchar, gshort, glong, gint, gfloat dan gdouble dibuat untuk menjaga konsistensi.
gpointer lebih mudah dibaca dibandingkan dengan void *.
gconstpointer sebagai pengganti const (void*).
const gpointer
diartikan sebagai konstanta pointer, bukan pointer ke sebuah konstanta.
glib mendefinisikan beberapa makro yang sering digunakan dalam C.
TRUE adalah 1.
FALSE adalah 0.
NULL adalah ((void*)0).
MIN(a,b) mengambil nilai terkecil dari parameternya.
MAX(a,b) mengambil nilai terbesar dari parameternya.
ABS(x) mengambil nilai absolut dari parameter.
CLAMP(x, low, high) bernilai x jika dalam selang [low, high], low jika x < low, high jika x > high.
glib mempunyai beberapa makro untuk keperluan debug. GTK+ menggunakan makro ini cukup sering, inilah salah satu alasan mengapa GTK+ sangat stabil dan mudah digunakan. Makro-makro ini akan diabaikan apabila anda mendifinisikan (define) G_DISABLE_CHECKS atau G_DISABLE_ASSERT, sehingga tidak akan mengurangi kecepatan pada aplikasi akhir. Gunakan makro-makro ini sebanyak mungkin, anda akan menemukan banyak bug dengan cepat. Terutama jika anda membuat pustaka, orang lain akan cepat mengetahui saat mereka kurang tepat dalam menggunakan pustaka anda.
Tapi berhati-hatilah dalam penggunaan makro-makro ini. Jangan sampai program anda tergantung pada hasil makro. Ingat, makro ini akan 'hilang' jika anda anda mendifinisikan G_DISABLE_CHECKS atau G_DISABLE_ASSERT.
g_return_if_fail(kondisi) mencetak peringatan dan segera keluar dari fungsi jika kondisi bernilai FALSE, khusus untuk fungsi yang tidak mengembalikan suatu nilai (void function atau procedure).
g_return_val_if_fail(kondisi, nilai) sama dengan g_return_if_fail(kondisi) dengan mengembalikan nilai fungsi. Isi nilai dengan nilai yang sesuai dengan tipe fungsi.
g_assert(kondisi) mirip dengan fungsi assert() namun bergantung pada G_DISABLE_ASSERT. Keluar dari program jika kondisi bernilai false.
g_assert_not_reached(), sama dengan g_assert(FALSE) .
Penggunaan g_return_if_fail() untuk memeriksa apakah parameter yang diberikan mempunyai nilai yang benar. Jika tidak bernilai benar, anda harus memeriksa kode yang memanggil fungsi dan perhatikan nilai parameternya.
Penggunaan g_assert() untuk memeriksa konsistensi dalam
fungsi.
|
GDate* g_date_new_dmy(GDateDay Day, GdateMonth m, GdateYear y) { Gdate *d; g_return_val_if_fail(g_date_valid_dmy(day,m,y), null);
d = g_new(GDate,1);
d->dmy = TRUE;
d->month = m; d->day = day; d->year = y;
} |
Semua makro untuk debug mencetak pesan peringatan (warning) menggunakan g_log() atau fasilitas message logging yang lain. Memungkinkan Anda untuk menampilkan pesan ke dialog box atau ke berkas selain menampilkannya di console.
glib membungkus fungsi standard malloc() dan free().
Sifat penting :
g_malloc() selalu mengembalikan gpointer, bukan char*, sehingga tidak perlu casting.
g_malloc()akan menghentikan program jika fungsi malloc() di dalamnya gagal.
g_malloc()memeriksa size of 0 dengan mengembalikan NULL.
g_free() akan mengabaikan pointer NULL.
g_malloc() dan g_free() mendukung berbagai keperluan memory debugging dan profiling. Contohnya jika anda menggunakan option --enable-mem-check dalam script konfigurasi glib, g_free() akan menampilkan peringatan jika anda membebaskan pointer yang sama lebih dari satu kali.
|
Daftar Fungsi Alokasi Memori #include <glib.h> gpointer g_malloc(gulong size) void g_free(gpointer mem) gpointer g_realloc(gpointer mem, gulong size) gpointer g_memdup(gconstpointer mem, giunt bytesize) |
Penting diperhatikan untuk memastikan pasangan antara g_malloc() dan g_free(),malloc() biasa dengan free(), serta (jika anda menggunakan C++) new dan delete.
g_realloc() sepadan dengan realloc(). g_memdup() meduplikasi serangkaian byte memori. g_realloc() dan g_malloc0() mengembalikan nilai NULL jika anda meminta 0 byte, konsisten dengan g_malloc(), kecuali g_memdup().
g_malloc0() mengisi memori dengan bit 0, bukan nilai 0. Umumnya terjadi kesalahan dengan anggapan akan mendapatkan nilai 0.0 (floating point).
|
Daftar Makro Alokasi Memori #include <glib.h> g_new(tipe, jumlah) g_new0(tipe, jumlah) g_renew(tipe, mem, jumlah) |
Juga disediakan makro pengalokasian
memori dengan tipe tertentu. Isi tipe dengan nama tipe, isi jumlah dengan
jumlah blok dari tipe yang diinginkan. Makro ini otomatis melakukan cast yang sesuai pada pointer
yang dikembalikan.
glib menyediakan sejumlah fungsi-fungsi yang berkaitan dengan string. Beberapa khusus dibuat untuk glib, sedangkan yang lain untuk tujuan portabilitas. Semuanya menggunakan fungsi-fungsi pengalokasian memori dari glib.
Jika menginginkan tipe yang lebih baik dari gchar* dapat digunakan tipe GString.
|
Daftar Fungsi String #include <glib.h> /* String utility functions that modify a string argument or * return a constant string that must not be freed. */ #define G_STR_DELIMITERS "_-|> <." gchar* g_strdelimit (gchar *string, const gchar *delimiters, gchar new_delimiter); gdouble g_strtod (const gchar *nptr, gchar **endptr); gchar* g_strerror (gint errnum); gchar* g_strsignal (gint signum); gint g_strcasecmp (const gchar *s1, const gchar *s2); gint g_strncasecmp (const gchar *s1, const gchar *s2, guint n); void g_strdown (gchar *string); void g_strup (gchar *string); void g_strreverse (gchar *string);
/* removes leading spaces */ gchar* g_strchug (gchar *string); /* removes trailing spaces */ gchar* g_strchomp (gchar *string); /* removes leading & trailing spaces */ #define g_strstrip( string ) g_strchomp (g_strchug (string))
/* String utility functions that return a newly allocated string which * ought to be freed from the caller at some point. */ gchar* g_strdup (const gchar *str); gchar* g_strdup_printf (const gchar *format, ...) G_GNUC_PRINTF (1, 2); gchar* g_strdup_vprintf (const gchar *format, va_list args); gchar* g_strndup (const gchar *str, guint n); gchar* g_strnfill (guint length, gchar fill_char); gchar* g_strconcat (const gchar *string1, ...); /* NULL terminated */ gchar* g_strjoin (const gchar *separator, ...); /* NULL terminated */ gchar* g_strescape (gchar *string); gpointer g_memdup (gconstpointer mem, guint byte_size);
/* NULL terminated string arrays. * g_strsplit() splits up string into max_tokens tokens at delim and * returns a newly allocated string array. * g_strjoinv() concatenates all of str_array's strings, sliding in an * optional separator, the returned string is newly allocated. * g_strfreev() frees the array itself and all of its strings. */ gchar** g_strsplit (const gchar *string, const gchar *delimiter, gint max_tokens); gchar* g_strjoinv (const gchar *separator, gchar **str_array); void g_strfreev (gchar **str_array);
/* calculate a string size, guarranteed to fit format + args. */ guint g_printf_string_upper_bound (const gchar* format, va_list args); |
g_strdup() dan g_strndup() membuat alokasi dari str atau n karakter pertama dari str. Untuk menjaga konsistensi dalam glib maka fungsi-fungsi ini akan mengembalikan nilai NULL jika argumennya NULL.
g_strdup_printf() perlu diperhatikan. Fungsi ini memudahkan dalam penulisan kode yang umumnya seperti berikut :
gchar* str = g_malloc(256);
g_snprintf(str, 256, "%d printf style %s", 1, "format");
Dapat dipadankan dengan kode berikut :
gchar * str = g_strdup_printf("%d printf style %s", 1, "format");
g_strconcat()memberikan
alokasi string baru dengan menggabungkan setiap string dalam
argumennya. Argumen terakhir harus NULL. g_strjoin() berlaku serupa namun menambahkan
separator diantara setiap string. Jika separatornya NULL maka
dianggap tidak ada separator. g_strsplit() memisahkan string dengan delimiter,
dengan mengembalikan array baru. g_strfreev() membebaskan setiap string dalam
array dan kemudian membebaskan array.
glib menyertakan beberapa struktur data siap pakai yang banyak digunakan sehingga anda tidak perlu membuat struktur data setiap kali diperlukan.
glib menyediakan list generik baik singly-linked-list dan doubly-linked-list, GSList dan Glist. GSList dan Glist mempunyai fungsi-fungsi yang sepadan. Tentu saja GSList tidak mempunyai g_list_previous(). Bagian ini akan membahas GSList namun seluruhkan dapat diterapkan pada GList.
Perhatikan bahwa fungsi-fungsi untuk GSList mempunyai awalan g_slist_ dan fungsi-fungsi GList menggunakan awalan g_list_.
|
Daftar Struktur List #include <glib.h> typedef struct _GList GList; typedef struct _GSList GSList;
struct _GList { gpointer data; GList *next; GList *prev; };
struct _GSList { gpointer data; GSList *next; }; |
|
Daftar Fungsi List #include <glib.h> /* Doubly linked lists */ GList* g_list_alloc (void); void g_list_free (GList *list); void g_list_free_1 (GList *list); GList* g_list_append (GList *list, gpointer data); GList* g_list_prepend (GList *list, gpointer data); GList* g_list_insert (GList *list, gpointer data, gint position); GList* g_list_insert_sorted (GList *list, gpointer data, GCompareFunc func); GList* g_list_concat (GList *list1, GList *list2); GList* g_list_remove (GList *list, gpointer data); GList* g_list_remove_link (GList *list, GList *llink); GList* g_list_reverse (GList *list); GList* g_list_copy (GList *list); GList* g_list_nth (GList *list, guint n); GList* g_list_find (GList *list, gpointer data); GList* g_list_find_custom (GList *list, gpointer data, GCompareFunc func); gint g_list_position (GList *list, GList *llink); gint g_list_index (GList *list, gpointer data); GList* g_list_last (GList *list); GList* g_list_first (GList *list); guint g_list_length (GList *list); void g_list_foreach (GList *list, GFunc func, gpointer user_data); GList* g_list_sort (GList *list, GCompareFunc compare_func); gpointer g_list_nth_data (GList *list, guint n); #define g_list_previous(list) ((list) ? (((GList *)(list))->prev) : NULL) #define g_list_next(list) ((list) ? (((GList *)(list))->next) : NULL) |
List kosong adalah pointer NULL. Contoh membuat list :
GSList * mylist = NULL;
gchar * myelement = g_strdup("Sebuah string");
mylist = g_slist_append(mylist, myelement);
Dalam implementasi list, glib sangat dipengaruhi oleh bahasa Lisp.
Perhatikan bahwa anda harus mengganti list dengan hasil fungsi karena ujung (head) list kemungkinan berubah.
Contoh menghapus element dalam list :
mylist = g_slist_remove(mylist, myelement);
Nilai mylist sekarang adalah NULL. Tetapi Anda masih harus membebaskan elemen anda sendiri.
Untuk menghapus semua elemen dalam list, gunakan g_slist_free().g_slist_free() tidak mempunyai nilai kembali karena dipastikan selalu NULL. Jadi anda dapat memberikan nilai NULL pada list anda jika anda mau. Jelas g_slist_free() hanya menghapus list, anda harus memutuskan apa yang akan anda lakukan dengan elemen-elemennya.
Untuk mengakses elemen, anda dapat menggunakan struktur GSList:
gchar * mydata = mylist->data;
Untuk proses iterasi, anda dapat membuat kode seperti ini :
GSList * mytmp = mylist;
while (mytmp != NULL)
{
printf("List data : %p\n", mytmp->data);
mytmp = g_slist_next(mytmp);
}
Untuk catatan, glib tidak menyimpan pointer ekor (tail)list. Jadi proses prepend membutuhkan waktu yang konstan, sedangkan append, insert dan remove proposional dengan panjang list.
Karena append adalah fungsi yang 'mahal', membuat list dengan g_slist_append() bukan ide yang baik. Gunakan g_slist_prepend() dan kemudian gunakan g_slist_reverse() jika anda mengharuskan urutan yang sesuai.
g_slist_foreach() menggunakan fungsi Gfunc untuk setiap elemen di dalam list. Fungsi Gfunc didefinisikan sebagai :
typedef void (*Gfunc) (gpointer data, gpointer user_data);
Di dalam g_slist_foreach(GList *list, GFunc func, gpointer user_data) fungsi Gfunc anda akan digunakan untuk setiap list->data di dalam list dan menyertakan user_data sebagai argumen ke dua.
g_slist_concat() menggabungkan dua list menjadi satu list baru. Dua list yang dipassing ke dalam fungsi dianggap sudah dihapus. Sama halnya dengan list yang dipassing ke dalam g_slist_reverse().
g_slist_copy() menghasilkan list baru yang merupakan duplikat list argumen. List yang dipassing ke g_slist_copy() akan tetap, sehingga masih dapat digunakan. Jadi pada waktunya anda harus menghapus kedua list tersebut.
Beberapa fungsi menggunakan GCompareFunc dalam argumennya. Didefinisikan sebagai berikut :
typedef gint (*GCompareFunc) (gconstpointer a, gconstpointer b);
Jika a < b maka fungsi seharusnya mengembalikan nilai negatif. Jika a > b maka fungsi seharusnya mengembalikan nilai positif. Jika a == b maka harus mengembalikan nilai 0.
Jika anda telah mempunyai fungsi perbandingan ini, anda dapat memasukkan elemen ke dalam list yang telah urut. List diurutkan dalam urutan naik (ascending order). Anda juga dapat mencari elemen tertentu dalam list menggunakan g_slist_find_custom().
g_slist_insert_sorted() adalah fungsi yang "mahal" untuk membangun list. Lebih baik jika anda menggunakan prepend dan kemudian g_slist_sort().
Ada dua jenis tree dalam glib.Pertama, GTree adalah binary tree yang seimbang (balanced), sangat berguna untuk menyimpan pasangan key-value yang diurutkan berdasarkan key. Kedua, GNode berguna untuk menyimpan sembarang data struktur tree, semisal tree hasil parsing atau struktur taksonomi.
Untuk membuat strukur GTree dapat menggunakan g_tree_new() dan g_tree_destroy().GCompareFunc adalah fungsi yang sama seperti dijelaskan dalam GList. Fungsi ini digunakan dalam membandingkan key dalam tree.
|
Daftar Fungsi GTree #include <glib.h> /* Balanced binary trees */ GTree* g_tree_new (GCompareFunc key_compare_func); void g_tree_destroy (GTree *tree); void g_tree_insert (GTree *tree, gpointer key, gpointer value); void g_tree_remove (GTree *tree, gpointer key); gpointer g_tree_lookup (GTree *tree, gpointer key); void g_tree_traverse (GTree *tree, GTraverseFunc traverse_func, GTraverseType traverse_type, gpointer data); gpointer g_tree_search (GTree *tree, GSearchFunc search_func, gpointer data); gint g_tree_height (GTree *tree); gint g_tree_nnodes (GTree *tree); |
g_tree_insert() menggantikan nilai yang ada, karena itu hati-hatilah jika nilai yang ada merupakan pointer ke memori yang dialokasikan. Jika g_tree_lookup() gagal menemukan key maka akan mengembalikan nilai NULL. Baik key dan value adalah tipe gpointer tetapi makro GPOINTER_TO_INT() and GPOINTER_TO_UINT() dapat digunakan.
g_tree_nnodes() dan g_tree_height() menggambarkan ukuran tree.
Dengan g_tree_traverse() kita dapat mengunjungi setiap node di dalam tree. Fungsi dengan tipe GTraverseFunc akan dipanggil dengan argumen key-value. Definisi tipe ini adalah :
typedef gint (*GTraverseFunc) (gpointer key, gpointer value, gpointer data);
GTraverseType adalah enumerasi dengan kemungkinan nilainya adalah :
G_IN_ORDER akan mengunjungi tree secara rekursif dari kiri dahulu, node saat ini dan kemudian ke kanan. Kunjungan akan berurutan dari terkecil ke terbesar tergantung pada fungsi GCompareFunc.
G_PRE_ORDER akan mengunjungi tree secara rekursif dimulai dari node saat ini, ke kiri dan kemudian ke kanan.
G_POST_ORDER akan mengunjungi tree secara rekursif dimulai dari kiri kemudian ke kanan dan node saat ini.
G_LEVEL_ORDER hanya untuk GNode. Tidak berlaku di GTree.
GNode adalah implementasi N-way tree dengan doubly linked list antara parent dan child. Hampir semua fungsi-fungsi list berlaku juga pada GNode. Struktur GNode dapat dilihat sebagai berikut :
/* N-way tree implementation
*/
typedef struct _GNode GNode;
struct _GNode
{
gpointer data;
GNode *next;
GNode *prev;
GNode *parent;
GNode *children;
};
Untuk membuat node terdapat fungsi _new(). g_node_new()
mengalokasikan node tanpa child dan parent.
Umumnya g_node_new()
digunakan untuk membuat root node.
|
Daftar Fungsi GNode #include <glib.h> #define G_NODE_IS_ROOT(node) (((GNode*) (node))->parent == NULL && \ ((GNode*) (node))->prev == NULL && \ ((GNode*) (node))->next == NULL) #define G_NODE_IS_LEAF(node) (((GNode*) (node))->children == NULL) GNode* g_node_new (gpointer data); void g_node_destroy (GNode *root); void g_node_unlink (GNode *node); GNode* g_node_insert (GNode *parent, gint position, GNode *node); GNode* g_node_insert_before(GNode *parent, GNode *sibling, GNode *node); GNode* g_node_prepend (GNode *parent, GNode *node); guint g_node_n_nodes (GNode *root, GTraverseFlags flags); GNode* g_node_get_root (GNode *node); gboolean g_node_is_ancestor(GNode *node, GNode *descendant); guint g_node_depth (GNode *node); GNode* g_node_find (GNode *root, GTraverseType order, GTraverseFlags flags, gpointer data);
#define g_node_append(parent, node) \ g_node_insert_before ((parent), NULL, (node))
g_node_insert ((parent), (position), g_node_new (data))
#define g_node_insert_data_before(parent, sibling, data) \ g_node_insert_before ((parent), (sibling), g_node_new (data))
g_node_prepend ((parent), g_node_new (data))
g_node_insert_before ((parent), NULL, g_node_new (data))
/* traversal function, assumes that `node' is root * (only traverses `node' and its subtree). * this function is just a high level interface to * low level traversal functions, optimized for speed. */ void g_node_traverse (GNode *root, GTraverseType order, GTraverseFlags flags, gint max_depth, GNodeTraverseFunc func, gpointer data);
/* return the maximum tree height starting with `node', this is an expensive * operation, since we need to visit all nodes. this could be shortened by * adding `guint height' to struct _GNode, but then again, this is not very * often needed, and would make g_node_insert() more time consuming. */ guint g_node_max_height (GNode *root); void g_node_children_foreach (GNode *node, GTraverseFlags flags, GNodeForeachFunc func, gpointer data); void g_node_reverse_children (GNode *node); guint g_node_n_children (GNode *node); GNode* g_node_nth_child (GNode *node, guint n); GNode* g_node_last_child (GNode *node); GNode* g_node_find_child (GNode *node, GTraverseFlags flags, gpointer data); gint g_node_child_position(GNode *node, GNode *child); gint g_node_child_index (GNode *node, gpointer data); GNode* g_node_first_sibling(GNode *node); GNode* g_node_last_sibling (GNode *node);
#define g_node_prev_sibling(node) ((node) ? \ ((GNode*) (node))->prev : NULL)
((GNode*) (node))->next : NULL)
((GNode*) (node))->children : NULL) |
Tersedia makro untuk mengakses GNode. Seperti biasa dilakukan pengecekan apakah argumennya NULL dan mengembalikan NULL jika demikian. g_node_prev_sibling(), g_node_next_sibling(), g_node_first_child().
Untuk menghapus node dari tree terdapat dua fungsi. g_node_destroy() menghapus node dari tree serta semua children-nya. g_node_unlink() memisahkan node dari tree, jadi mengubah subtree menjadi tree tersendiri.
Juga terdapat dua makro untuk mengetahui apakah node adalah ujung-ujung dari tree yaitu : G_NODE_IS_ROOT() dan G_NODE_IS_LEAF().Root adalah node tanpa parent dan sibling. Leaf adalah node tanpa children.
Informasi tentang GNode antara lain adalah jumlah node g_node_n_nodes(), mendapatkan root-nya g_node_get_root(), kedalamannya g_node_depth() dan node mana yang berisi pointer data tertentu g_node_find().
GTraverseType mirip pada GTree, nilainya di GNode adalah :
G_IN_ORDER, pertama rekursif ke child paling kiri kemudian mengunjungi node-nya sendiri dan rekursif ke node-node child yang lain. Biasanya tidak terlalu berguna, umumnya hanya digunakan dalam GTree.
G_PRE_ORDER, mengunjungi node saat ini kemudian rekursif ke setiap child.
G_POST_ORDER, rekursif ke setiap child kemudian mengunjungi node saat ini.
G_LEVEL_ORDER mengunjungi node saat ini kemudian setiap node child dan kemudian setiap child dari node child dan seterusnya. Dengan kata lain mengunjungi setiap node pada depth 0, setiap node pada depth 1 dan seterusnya.
Fungsi tree-traversal mempunyai argumen GTraverseFlags. Ini adalah bitfield yang digunakan untuk mengatur cara kunjungan. Saat ini hanya tiga flag. Anda hanya dapat mengunjungi leaf node saja, hanya bukan leaf node saja, dan semua node.
G_TRAVERSE_LEAFS
G_TRAVERSE_NON_LEAFS
G_TRAVERSE_ALL, ini hanya cara lain dari (G_TRAVERSE_LEAFS | G_TRAVERSE_NON_LEAFS)
Fungsi-fungsi GNode
yang lain cukup jelas, kebanyakan hanya operasi pada barisan node child.
Dua fungsi yang digunakan khusus untuk GNode adalah :
typedef gboolean (*GNodeTraverseFunc) (GNode *node, gpointer data);
typedef void (*GNodeForeachFunc) (GNode *node, gpointer data);
GNodeTraverseFunc mengembalikan nilai TRUE untuk menghentikan jalannya kunjungan. Dapat dikombinasikan dengan g_node_traverse() untuk mencari node dalam tree.
GHashTable adalah implementasi tabel hash yang sederhana, menyediakan associative array dengan pencarian dalam waktu yang konstan. Untuk menggunakan tabel hash Anda harus menyediakan fungsi GHashFunc yang mengembalikan nilai integer positif.
typedef guint (*GHashFunc) (gconstpointer key);
Nilai yang dikembalikan oleh GHashFunc seharusnya terdistribusi dengan merata dalam himpunan kemungkinan nilainya. Fungsi ini juga harus cepat karena digunakan dalam setiap pencarian.
Satu fungsi lain yang dibutuhkan adalah fungsi GCompareFunc untuk menguji kesamaan dari key. Dengan catatan bahwa fungsi ini berbeda dengan fungsi GCompareFunc dalam GSList dan GTree.
typedef gint (*GCompareFunc) (gconstpointer a, gconstpointer b);
Fungsi ini sebagai operator kesamaan dengan mengembalikan nilai TRUE jika kedua argumennya “sama”. Namun bukan seperti fungsi perbandingan dalam qsort(). Fungsi perbandingan key digunakan saat GHashFunc mengembalikan nilai yang sama dengan key yang berbeda.
Untuk membuat dan menghapus GHashTable gunakan g_hash_table_new() dan g_hash_table_destroy(). Untuk diingat bahwa glib tidak dapat menghapus isi tabel, Anda harus mengapus isi tablenya sendiri. g_hash_table_destroy() hanya menghapus tabelnya saja.
|
Daftar Fungsi GHashTable #include <glib.h> /* Hash tables */ GHashTable* g_hash_table_new (GHashFunc hash_func, GCompareFunc key_compare_func); void g_hash_table_destroy (GHashTable *hash_table); void g_hash_table_insert (GHashTable *hash_table, gpointer key, gpointer value); void g_hash_table_remove (GHashTable *hash_table, gconstpointer key); gpointer g_hash_table_lookup (GHashTable *hash_table, gconstpointer key); gboolean g_hash_table_lookup_extended(GHashTable *hash_table, gconstpointer lookup_key, gpointer *orig_key, gpointer *value); void g_hash_table_freeze (GHashTable *hash_table); void g_hash_table_thaw (GHashTable *hash_table); void g_hash_table_foreach (GHashTable *hash_table, GHFunc func, gpointer user_data); guint g_hash_table_foreach_remove (GHashTable *hash_table, GHRFunc func, gpointer user_data); guint g_hash_table_size (GHashTable *hash_table); |
Fungsi-fungsi hash dan pembanding yang siap pakai juga disediakan untuk tipe key yang sering digunakan yaitu : integer (g_int_hash(), g_int_equal()), pointer (g_direct_hash(), g_direct_equal()) dan string (g_str_hash(),g_str_equal()).
Perhatikan untuk tipe integer fungsinya menggunakan argumen pointer ke gint bukan hanya gint. Jika Anda menggunakan NULL sebagai argumen fungsi hash di g_hash_table_new(), g_direct_hash() akan digunakan. Jika NULL digunakan sebagai argumen fungsi kesamaan maka perbandingan pointer sederhana akan digunakan (sama dengan menggunakan g_direct_equal() tetapi tanpa pemanggilan fungsi).
Beberapa fungsi yang berguna untuk memanipulasi tabel hash : g_hash_table_insert(), g_hash_table_remove(), g_hash_table_lookup(), g_hash_table_lookup_extended(). Fungsi insert tidak mengalokasikan key atau value lagi. Key dan value akan langsung dimasukkan dalam tabel hash. Perhatikan, key-value akan menimpa pasangan key-value yang ada jika key-nya “sama”. Jika hal ini menjadi masalah, lakukan lookup atau remove sebelum insert. Sangat hati-hati jika pasangan key-value dialokasikan secara dinamik.
g_hash_table_lookup() mengembalikan value yang ditemukan untuk key yang dicari, atau mengembalikan NULL jika tidak ada value. Namun hal ini tidak selalu diharapkan. Misalnya jika NULL adalah value yang benar. Kasus lain, jika Anda menggunakan string sebagai key, khususnya jika stringnya dialokasikan secara dinamik, hanya mengetahui bahwa sebuah key ada di dalam tabel biasanya tidaklah cukup. Anda dapat mengambil string key yang sebenarnya di dalam tabel hash. Fungsi lookup yang lain disediakan yaitu g_hash_table_lookup_extended(). Jika mengembalikan nilai TRUE, akan menempatkan pasangan key-value ke dalam argumennya.
Secara internal membangun struktur data tabel hash itu memerlukan waktu yang banyak. Terutama jika Anda melakukan proses insert dalam jumlah yang banyak. Setiap kali proses insert dijalankan, terjadi penyesuaian terhadap ukuran tablenya. Oleh karena itu proses penyesuaian ukuran ini dapat dicegah untuk sementara, yaitu dengan membekukan tabel hash (freeze). Jika Anda telah selesai dengan penambahan dan penghapusan item, Anda dapat mencairkan kembali tabel hashnya (thaw). Fungsi-fungsi ini adalah g_hash_table_freeze() dan g_hash_table_thaw().
Masih banyak lagi fitur dari glib. Sumber informasi yang terbaik dari glib, seperti biasa, adalah membaca source-code. Namun sebagai permulaan sebaiknya Anda melihat berkas header glib.h. Anda juga dapat menuju ke http://www.gtk.org .