glib.h

本文档详细介绍了在WINDOWS下用VC6.0编译ORTP的方法,还有要用到的4个头文件

typedef gint        (*GCompareFunc)     (gconstpointer  a,
												 gconstpointer  b);
typedef gchar*      (*GCompletionFunc)  (gpointer);
typedef void        (*GDestroyNotify)   (gpointer   data);
typedef void        (*GDataForeachFunc) (GQuark     key_id,
												 gpointer   data,
												 gpointer   user_data);
typedef void        (*GFunc)        (gpointer   data,
												 gpointer   user_data);
typedef guint       (*GHashFunc)        (gconstpointer  key);
typedef void        (*GFreeFunc)        (gpointer   data);
typedef void        (*GHFunc)       (gpointer   key,
												 gpointer   value,
												 gpointer   user_data);
typedef gboolean    (*GHRFunc)      (gpointer   key,
												 gpointer   value,
												 gpointer   user_data);
typedef gint        (*GHookCompareFunc) (GHook      *new_hook,
												 GHook      *sibling);
typedef gboolean    (*GHookFindFunc)    (GHook      *hook,
												 gpointer    data);
typedef void        (*GHookMarshaller)  (GHook      *hook,
												 gpointer    data);
typedef gboolean    (*GHookCheckMarshaller) (GHook      *hook,
												 gpointer    data);
typedef void        (*GHookFunc)        (gpointer    data);
typedef gboolean    (*GHookCheckFunc)   (gpointer    data);
typedef void        (*GHookFreeFunc)    (GHookList      *hook_list,
												 GHook          *hook);
typedef void        (*GLogFunc)     (const gchar   *log_domain,
												 GLogLevelFlags log_level,
												 const gchar   *message,
												 gpointer   user_data);
typedef gboolean    (*GNodeTraverseFunc)    (GNode         *node,
												 gpointer   data);
typedef void        (*GNodeForeachFunc) (GNode         *node,
												 gpointer   data);
typedef gint        (*GSearchFunc)      (gpointer   key,
												 gpointer   data);
typedef void        (*GScannerMsgFunc)  (GScanner      *scanner,
												 gchar         *message,
												 gint       error);
typedef gint        (*GTraverseFunc)    (gpointer   key,
												 gpointer   value,
												 gpointer   data);
typedef void        (*GVoidFunc)        (void);


struct _GList
{
	gpointer data;
	GList *next;
	GList *prev;
};

struct _GSList
{
	gpointer data;
	GSList *next;
};

struct _GString
{
	gchar *str;
	gint len;
};

struct _GArray
{
	gchar *data;
	guint len;
};

struct _GByteArray
{
	guint8 *data;
	guint   len;
};

struct _GPtrArray
{
	gpointer *pdata;
	guint     len;
};

struct _GTuples
{
	guint len;
};

struct _GDebugKey
{
	gchar *key;
	guint  value;
};


/* Doubly linked lists
 */
void   g_list_push_allocator    (GAllocator     *allocator);
void   g_list_pop_allocator     (void);
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)


/* Singly linked lists
 */
void    g_slist_push_allocator  (GAllocator     *allocator);
void    g_slist_pop_allocator   (void);
GSList* g_slist_alloc       (void);
void    g_slist_free        (GSList     *list);
void    g_slist_free_1      (GSList     *list);
GSList* g_slist_append      (GSList     *list,
								 gpointer    data);
GSList* g_slist_prepend     (GSList     *list,
								 gpointer    data);
GSList* g_slist_insert      (GSList     *list,
								 gpointer    data,
								 gint        position);
GSList* g_slist_insert_sorted   (GSList     *list,
								 gpointer    data,
								 GCompareFunc    func);
GSList* g_slist_concat      (GSList     *list1,
								 GSList     *list2);
GSList* g_slist_remove      (GSList     *list,
								 gpointer    data);
GSList* g_slist_remove_link (GSList     *list,
								 GSList     *llink);
GSList* g_slist_reverse     (GSList     *list);
GSList* g_slist_copy        (GSList     *list);
GSList* g_slist_nth     (GSList     *list,
								 guint       n);
GSList* g_slist_find        (GSList     *list,
								 gpointer    data);
GSList* g_slist_find_custom (GSList     *list,
								 gpointer    data,
								 GCompareFunc    func);
gint    g_slist_position    (GSList     *list,
								 GSList     *llink);
gint    g_slist_index       (GSList     *list,
								 gpointer    data);
GSList* g_slist_last        (GSList     *list);
guint   g_slist_length      (GSList     *list);
void    g_slist_foreach     (GSList     *list,
								 GFunc       func,
								 gpointer    user_data);
GSList*  g_slist_sort           (GSList          *list,
												 GCompareFunc    compare_func);
gpointer g_slist_nth_data   (GSList     *list,
								 guint       n);
#define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL)


/* 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);


/* Caches
 */
GCache*  g_cache_new           (GCacheNewFunc      value_new_func,
								GCacheDestroyFunc  value_destroy_func,
								GCacheDupFunc      key_dup_func,
								GCacheDestroyFunc  key_destroy_func,
								GHashFunc      hash_key_func,
								GHashFunc      hash_value_func,
								GCompareFunc       key_compare_func);
void     g_cache_destroy       (GCache        *cache);
gpointer g_cache_insert        (GCache        *cache,
								gpointer       key);
void     g_cache_remove        (GCache        *cache,
								gpointer       value);
void     g_cache_key_foreach   (GCache        *cache,
								GHFunc         func,
								gpointer       user_data);
void     g_cache_value_foreach (GCache        *cache,
								GHFunc         func,
								gpointer       user_data);


/* 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);



/* N-way tree implementation
 */
struct _GNode
{
	gpointer data;
	GNode   *next;
	GNode   *prev;
	GNode   *parent;
	GNode   *children;
};

#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)

void     g_node_push_allocator  (GAllocator       *allocator);
void     g_node_pop_allocator   (void);
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);

/* convenience macros */
#define g_node_append(parent, node)             \
		 g_node_insert_before ((parent), NULL, (node))
#define g_node_insert_data(parent, position, data)      \
		 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))
#define g_node_prepend_data(parent, data)           \
		 g_node_prepend ((parent), g_node_new (data))
#define g_node_append_data(parent, 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)
#define  g_node_next_sibling(node)  ((node) ? \
										 ((GNode*) (node))->next : NULL)
#define  g_node_first_child(node)   ((node) ? \
										 ((GNode*) (node))->children : NULL)


/* Callback maintenance functions
 */
#define G_HOOK_FLAG_USER_SHIFT  (4)
typedef enum
{
	G_HOOK_FLAG_ACTIVE    = 1 << 0,
	G_HOOK_FLAG_IN_CALL   = 1 << 1,
	G_HOOK_FLAG_MASK  = 0x0f
} GHookFlagMask;

#define G_HOOK_DEFERRED_DESTROY ((GHookFreeFunc) 0x01)

struct _GHookList
{
	guint      seq_id;
	guint      hook_size;