X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=glib.h;h=d7ac6d503f78e2dafd274e1d9df2f6ac664c4249;hb=39732afc59b5e3db38467b047090b0d72040255f;hp=21ec71ab31ce820fe571a0d5ba13c019b7fbc5dc;hpb=7c467669cc1d4f83bd7c5ecfe440bfee8c2f4504;p=platform%2Fupstream%2Fglib.git diff --git a/glib.h b/glib.h index 21ec71a..d7ac6d5 100644 --- a/glib.h +++ b/glib.h @@ -74,6 +74,17 @@ */ #include +/* Define some mathematical constants that aren't available + * symbolically in some strict ISO C implementations. + */ +#define G_E 2.7182818284590452354E0 +#define G_LN2 6.9314718055994530942E-1 +#define G_LN10 2.3025850929940456840E0 +#define G_PI 3.14159265358979323846E0 +#define G_PI_2 1.57079632679489661923E0 +#define G_PI_4 0.78539816339744830962E0 +#define G_SQRT2 1.4142135623730950488E0 + /* include varargs functions for assertment macros */ #include @@ -147,6 +158,14 @@ extern "C" { #define G_STRINGIFY(macro_or_string) G_STRINGIFY_ARG (macro_or_string) #define G_STRINGIFY_ARG(contents) #contents +/* provide a string identifying the current code position */ +#ifdef __GNUC__ +# define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__) ":" __PRETTY_FUNCTION__ "()" +#else +# define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__) +#endif + + /* Count the number of elements in an array. The array must be defined * as such; using this with a dynamically allocated array will give * incorrect results. @@ -171,9 +190,9 @@ extern "C" { * fields through their offsets. */ #define G_STRUCT_OFFSET(struct_type, member) \ - ((gulong) ((gchar*) &((struct_type*) 0)->member)) + ((glong) ((guint8*) &((struct_type*) 0)->member)) #define G_STRUCT_MEMBER_P(struct_p, struct_offset) \ - ((gpointer) ((gchar*) (struct_p) + (gulong) (struct_offset))) + ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) #define G_STRUCT_MEMBER(member_type, struct_p, struct_offset) \ (*(member_type*) G_STRUCT_MEMBER_P ((struct_p), (struct_offset))) @@ -481,6 +500,7 @@ typedef short gshort; typedef long glong; typedef int gint; typedef gint gboolean; +typedef gchar* gstring; typedef unsigned char guchar; typedef unsigned short gushort; @@ -678,19 +698,19 @@ typedef gint32 GTime; */ #ifdef G_OS_WIN32 # ifdef GLIB_COMPILATION -# define GUTILS_C_VAR __declspec(dllexport) +# define GLIB_VAR __declspec(dllexport) # else /* !GLIB_COMPILATION */ -# define GUTILS_C_VAR extern __declspec(dllimport) +# define GLIB_VAR extern __declspec(dllimport) # endif /* !GLIB_COMPILATION */ #else /* !G_OS_WIN32 */ -# define GUTILS_C_VAR extern +# define GLIB_VAR extern #endif /* !G_OS_WIN32 */ -GUTILS_C_VAR const guint glib_major_version; -GUTILS_C_VAR const guint glib_minor_version; -GUTILS_C_VAR const guint glib_micro_version; -GUTILS_C_VAR const guint glib_interface_age; -GUTILS_C_VAR const guint glib_binary_age; +GLIB_VAR const guint glib_major_version; +GLIB_VAR const guint glib_minor_version; +GLIB_VAR const guint glib_micro_version; +GLIB_VAR const guint glib_interface_age; +GLIB_VAR const guint glib_binary_age; #define GLIB_CHECK_VERSION(major,minor,micro) \ (GLIB_MAJOR_VERSION > (major) || \ @@ -817,8 +837,6 @@ 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); @@ -975,7 +993,7 @@ GList* g_list_insert_sorted (GList *list, GList* g_list_concat (GList *list1, GList *list2); GList* g_list_remove (GList *list, - gpointer data); + gconstpointer data); GList* g_list_remove_link (GList *list, GList *llink); GList* g_list_delete_link (GList *list, @@ -985,14 +1003,14 @@ GList* g_list_copy (GList *list); GList* g_list_nth (GList *list, guint n); GList* g_list_find (GList *list, - gpointer data); + gconstpointer data); GList* g_list_find_custom (GList *list, - gpointer data, + gconstpointer data, GCompareFunc func); gint g_list_position (GList *list, GList *llink); gint g_list_index (GList *list, - gpointer data); + gconstpointer data); GList* g_list_last (GList *list); GList* g_list_first (GList *list); guint g_list_length (GList *list); @@ -1024,10 +1042,13 @@ GSList* g_slist_insert (GSList *list, GSList* g_slist_insert_sorted (GSList *list, gpointer data, GCompareFunc func); +GSList* g_slist_insert_before (GSList *slist, + GSList *sibling, + gpointer data); GSList* g_slist_concat (GSList *list1, GSList *list2); GSList* g_slist_remove (GSList *list, - gpointer data); + gconstpointer data); GSList* g_slist_remove_link (GSList *list, GSList *link); GSList* g_slist_delete_link (GSList *list, @@ -1037,14 +1058,14 @@ GSList* g_slist_copy (GSList *list); GSList* g_slist_nth (GSList *list, guint n); GSList* g_slist_find (GSList *list, - gpointer data); + gconstpointer data); GSList* g_slist_find_custom (GSList *list, - gpointer data, + gconstpointer data, GCompareFunc func); gint g_slist_position (GSList *list, GSList *llink); gint g_slist_index (GSList *list, - gpointer data); + gconstpointer data); GSList* g_slist_last (GSList *list); guint g_slist_length (GSList *list); void g_slist_foreach (GSList *list, @@ -1077,7 +1098,6 @@ void g_queue_push_tail_link (GQueue *queue, GList* g_queue_pop_head_link (GQueue *queue); GList* g_queue_pop_tail_link (GQueue *queue); - /* Hash tables */ GHashTable* g_hash_table_new (GHashFunc hash_func, @@ -1118,7 +1138,7 @@ void g_cache_destroy (GCache *cache); gpointer g_cache_insert (GCache *cache, gpointer key); void g_cache_remove (GCache *cache, - gpointer value); + gconstpointer value); void g_cache_key_foreach (GCache *cache, GHFunc func, gpointer user_data); @@ -1135,16 +1155,16 @@ void g_tree_insert (GTree *tree, gpointer key, gpointer value); void g_tree_remove (GTree *tree, - gpointer key); + gconstpointer key); gpointer g_tree_lookup (GTree *tree, - gpointer key); + gconstpointer 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); + GCompareFunc search_func, + gconstpointer data); gint g_tree_height (GTree *tree); gint g_tree_nnodes (GTree *tree); @@ -1570,6 +1590,9 @@ void g_usleep (gulong microseconds); gchar* g_strdelimit (gchar *string, const gchar *delimiters, gchar new_delimiter); +gchar* g_strcanon (gchar *string, + const gchar *valid_chars, + gchar subsitutor); gdouble g_strtod (const gchar *nptr, gchar **endptr); gchar* g_strerror (gint errnum); @@ -1579,9 +1602,9 @@ gint g_strcasecmp (const gchar *s1, 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); +gchar* g_strdown (gchar *string); +gchar* g_strup (gchar *string); +gchar* g_strreverse (gchar *string); /* removes leading spaces */ gchar* g_strchug (gchar *string); /* removes trailing spaces */ @@ -1686,6 +1709,9 @@ gchar* g_path_skip_root (gchar *file_name); gchar* g_dirname (const gchar *file_name); gchar* g_get_current_dir (void); +/* Get the codeset for the current locale */ +/* gchar * g_get_codeset (void); */ + /* return the environment string for the variable. The returned memory * must not be freed. */ gchar* g_getenv (const gchar *variable); @@ -1839,10 +1865,13 @@ GString* g_string_new (const gchar *init); GString* g_string_sized_new (guint dfl_size); void g_string_free (GString *string, gboolean free_segment); +gboolean g_string_equal (const GString *v, + const GString *v2); +guint g_string_hash (const GString *str); GString* g_string_assign (GString *string, const gchar *rval); GString* g_string_truncate (GString *string, - gint len); + guint len); GString* g_string_insert_len (GString *string, gint pos, const gchar *val, @@ -1963,13 +1992,13 @@ GByteArray* g_byte_array_remove_index_fast (GByteArray *array, /* Hash Functions */ -gint g_str_equal (gconstpointer v, - gconstpointer v2); -guint g_str_hash (gconstpointer v); +gboolean g_str_equal (gconstpointer v, + gconstpointer v2); +guint g_str_hash (gconstpointer v); -gint g_int_equal (gconstpointer v, - gconstpointer v2); -guint g_int_hash (gconstpointer v); +gint g_int_equal (gconstpointer v, + gconstpointer v2); +guint g_int_hash (gconstpointer v); /* This "hash" function will just return the key's adress as an * unsigned integer. Useful for hashing on plain adresses or @@ -2057,6 +2086,7 @@ void g_dataset_foreach (gconstpointer dataset_location, /* Character sets */ #define G_CSET_A_2_Z "ABCDEFGHIJKLMNOPQRSTUVWXYZ" #define G_CSET_a_2_z "abcdefghijklmnopqrstuvwxyz" +#define G_CSET_DIGITS "0123456789" #define G_CSET_LATINC "\300\301\302\303\304\305\306"\ "\307\310\311\312\313\314\315\316\317\320"\ "\321\322\323\324\325\326"\ @@ -2803,7 +2833,7 @@ gint g_io_channel_unix_get_fd (GIOChannel *channel); #ifdef G_OS_WIN32 -GUTILS_C_VAR guint g_pipe_readable_msg; +GLIB_VAR guint g_pipe_readable_msg; #define G_WIN32_MSG_HANDLE 19981206 @@ -2959,6 +2989,8 @@ typedef struct _GMutex GMutex; typedef struct _GCond GCond; typedef struct _GPrivate GPrivate; typedef struct _GStaticPrivate GStaticPrivate; +typedef struct _GAsyncQueue GAsyncQueue; +typedef struct _GThreadPool GThreadPool; typedef struct _GThreadFunctions GThreadFunctions; struct _GThreadFunctions @@ -2996,9 +3028,9 @@ struct _GThreadFunctions void (*thread_self) (gpointer thread); }; -GUTILS_C_VAR GThreadFunctions g_thread_functions_for_glib_use; -GUTILS_C_VAR gboolean g_thread_use_default_impl; -GUTILS_C_VAR gboolean g_threads_got_initialized; +GLIB_VAR GThreadFunctions g_thread_functions_for_glib_use; +GLIB_VAR gboolean g_thread_use_default_impl; +GLIB_VAR gboolean g_threads_got_initialized; /* initializes the mutex/cond/private implementation for glib, might * only be called once, and must not be called directly or indirectly @@ -3130,7 +3162,7 @@ void g_static_rw_lock_free (GStaticRWLock* lock); * G_TRYLOCK() respectively. */ extern void glib_dummy_decl (void); -#define G_LOCK_NAME(name) (g__ ## name ## _lock) +#define G_LOCK_NAME(name) g__ ## name ## _lock #ifdef G_THREADS_ENABLED # define G_LOCK_DEFINE_STATIC(name) static G_LOCK_DEFINE (name) # define G_LOCK_DEFINE(name) \ @@ -3152,12 +3184,11 @@ extern void glib_dummy_decl (void); #name); \ g_static_mutex_unlock (&G_LOCK_NAME (name)); \ }G_STMT_END -# define G_TRYLOCK(name) G_STMT_START{ \ - g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \ +# define G_TRYLOCK(name) \ + (g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \ "file %s: line %d (%s): try locking: %s ", \ __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \ - #name); \ - }G_STMT_END, g_static_mutex_trylock (&G_LOCK_NAME (name)) + #name), g_static_mutex_trylock (&G_LOCK_NAME (name))) # else /* !G_DEBUG_LOCKS */ # define G_LOCK(name) g_static_mutex_lock (&G_LOCK_NAME (name)) # define G_UNLOCK(name) g_static_mutex_unlock (&G_LOCK_NAME (name)) @@ -3172,9 +3203,132 @@ extern void glib_dummy_decl (void); # define G_TRYLOCK(name) (TRUE) #endif /* !G_THREADS_ENABLED */ +/* Asyncronous Queues, can be used to communicate between threads + */ + +/* Get a new GAsyncQueue with the ref_count 1 */ +GAsyncQueue* g_async_queue_new (void); + +/* Lock and unlock an GAsyncQueue, all functions lock the queue for + * themselves, but in certain cirumstances you want to hold the lock longer, + * thus you lock the queue, call the *_unlocked functions and unlock it again + */ +void g_async_queue_lock (GAsyncQueue *queue); +void g_async_queue_unlock (GAsyncQueue *queue); + +/* Ref and unref the GAsyncQueue. g_async_queue_unref_unlocked makes + * no sense, as after the unreffing the Queue might be gone and can't + * be unlocked. So you have a function to call, if you don't hold the + * lock (g_async_queue_unref) and one to call, when you already hold + * the lock (g_async_queue_unref_and_unlock). After that however, you + * don't hold the lock anymore and the Queue might in fact be + * destroyed, if you unrefed to zero */ +void g_async_queue_ref (GAsyncQueue *queue); +void g_async_queue_ref_unlocked (GAsyncQueue *queue); +void g_async_queue_unref (GAsyncQueue *queue); +void g_async_queue_unref_and_unlock (GAsyncQueue *queue); + +/* Push data into the async queue. Must not be NULL */ +void g_async_queue_push (GAsyncQueue *queue, + gpointer data); +void g_async_queue_push_unlocked (GAsyncQueue *queue, + gpointer data); + +/* Pop data from the async queue, when no data is there, the thread is blocked + * until data arrives */ +gpointer g_async_queue_pop (GAsyncQueue *queue); +gpointer g_async_queue_pop_unlocked (GAsyncQueue *queue); + +/* Try to pop data, NULL is returned in case of empty queue */ +gpointer g_async_queue_try_pop (GAsyncQueue *queue); +gpointer g_async_queue_try_pop_unlocked (GAsyncQueue *queue); + +/* Wait for data until at maximum until end_time is reached, NULL is returned + * in case of empty queue*/ +gpointer g_async_queue_timed_pop (GAsyncQueue *queue, + GTimeVal *end_time); +gpointer g_async_queue_timed_pop_unlocked (GAsyncQueue *queue, + GTimeVal *end_time); + +/* Return the length of the queue, negative values mean, that threads + * are waiting, positve values mean, that there are entries in the + * queue. Actually this function returns the length of the queue minus + * the number of waiting threads, g_async_queue_length == 0 could also + * mean 'n' entries in the queue and 'n' thread waiting, such can + * happen due to locking of the queue or due to scheduling. */ +gint g_async_queue_length (GAsyncQueue *queue); +gint g_async_queue_length_unlocked (GAsyncQueue *queue); + +/* Thread Pools + */ + +/* The real GThreadPool is bigger, so you may only create a thread + * pool with the constructor function */ +struct _GThreadPool +{ + GFunc thread_func; + gulong stack_size; + gboolean bound; + GThreadPriority priority; + gboolean exclusive; + gpointer user_data; +}; + +/* Get a thread pool with the function thread_func, at most max_threads may + * run at a time (max_threads == -1 means no limit), stack_size, bound, + * priority like in g_thread_create, exclusive == TRUE means, that the threads + * shouldn't be shared and that they will be prestarted (otherwise they are + * started, as needed) user_data is the 2nd argument to the thread_func */ +GThreadPool* g_thread_pool_new (GFunc thread_func, + gint max_threads, + gulong stack_size, + gboolean bound, + GThreadPriority priority, + gboolean exclusive, + gpointer user_data); + +/* Push new data into the thread pool. This task is assigned to a thread later + * (when the maximal number of threads is reached for that pool) or now + * (otherwise). If necessary a new thread will be started. The function + * returns immediatly */ +void g_thread_pool_push (GThreadPool *pool, + gpointer data); + +/* Set the number of threads, which can run concurrently for that pool, -1 + * means no limit. 0 means has the effect, that the pool won't process + * requests until the limit is set higher again */ +void g_thread_pool_set_max_threads (GThreadPool *pool, + gint max_threads); +gint g_thread_pool_get_max_threads (GThreadPool *pool); + +/* Get the number of threads assigned to that pool. This number doesn't + * necessarily represent the number of working threads in that pool */ +guint g_thread_pool_get_num_threads (GThreadPool *pool); + +/* Get the number of unprocessed items in the pool */ +guint g_thread_pool_unprocessed (GThreadPool *pool); + +/* Free the pool, immediate means, that all unprocessed items in the queue + * wont be processed, wait means, that the function doesn't return immediatly, + * but after all threads in the pool are ready processing items. immediate + * does however not mean, that threads are killed. */ +void g_thread_pool_free (GThreadPool *pool, + gboolean immediate, + gboolean wait); + +/* Set the maximal number of unused threads before threads will be stopped by + * GLib, -1 means no limit */ +void g_thread_pool_set_max_unused_threads (gint max_threads); +gint g_thread_pool_get_max_unused_threads (void); +guint g_thread_pool_get_num_unused_threads (void); + +/* Stop all currently unused threads, but leave the limit untouched */ +void g_thread_pool_stop_unused_threads (void); + +#include + #ifdef __cplusplus } #endif /* __cplusplus */ - #endif /* __G_LIB_H__ */