GoGlibExtras

GoGlibExtras —

Synopsis




gpointer    (*GOMapFunc)                    (gpointer value);
void        go_ptr_array_insert             (GPtrArray *array,
                                             gpointer value,
                                             int index);
GSList*     go_hash_keys                    (GHashTable *hash);
GSList*     go_hash_values                  (GHashTable *hash);
GSList*     go_slist_map                    (GSList const *list,
                                             GOMapFunc map_func);
GSList*     go_slist_create                 (gpointer item1,
                                             ...);
void        go_slist_free_custom            (GSList *list,
                                             GFreeFunc free_func);
#define     go_string_slist_copy            (list)
GSList*     go_strsplit_to_slist            (char const *str,
                                             gchar delimiter);
#define     GO_SLIST_FOREACH                (list,valtype,val,stmnt)
#define     GO_SLIST_PREPEND                (list,item)
#define     GO_SLIST_APPEND                 (list,item)
#define     GO_SLIST_REMOVE                 (list,item)
#define     GO_SLIST_CONCAT                 (list_a,list_b)
#define     GO_SLIST_REVERSE                (list)
#define     GO_SLIST_SORT                   (list,cmp_func)
gint        go_list_index_custom            (GList *list,
                                             gpointer data,
                                             GCompareFunc cmp_func);
void        go_list_free_custom             (GList *list,
                                             GFreeFunc free_func);
#define     GO_LIST_FOREACH                 (list,valtype,val,stmnt)
#define     GO_LIST_PREPEND                 (list,item)
#define     GO_LIST_APPEND                  (list,item)
#define     GO_LIST_REMOVE                  (list,item)
#define     GO_LIST_CONCAT                  (list_a,list_b)
#define     GO_LIST_REVERSE                 (list)
#define     GO_LIST_SORT                    (list,cmp_func)
int         go_str_compare                  (void const *x,
                                             void const *y);
guint       go_ascii_strcase_hash           (gconstpointer v);
gint        go_ascii_strcase_equal          (gconstpointer v,
                                             gconstpointer v2);
gint        go_utf8_collate_casefold        (char const *a,
                                             char const *b);
char*       go_utf8_strcapital              (char const *p,
                                             gssize len);
void        go_strescape                    (GString *target,
                                             char const *str);
charconst * go_strunescape                  (GString *target,
                                             char const *str);
void        go_string_append_gstring        (GString *target,
                                             const GString *src);
charconst * go_guess_encoding               (char const *raw,
                                             size_t len,
                                             char const *user_guess,
                                             char **utf8_str);
charconst * go_get_real_name                (void);
void        go_destroy_password             (char *passwd);
GOMemChunk* go_mem_chunk_new                (char const *name,
                                             size_t user_atom_size,
                                             size_t chunk_size);
void        go_mem_chunk_destroy            (GOMemChunk *chunk,
                                             gboolean expect_leaks);
gpointer    go_mem_chunk_alloc              (GOMemChunk *chunk);
gpointer    go_mem_chunk_alloc0             (GOMemChunk *chunk);
void        go_mem_chunk_free               (GOMemChunk *chunk,
                                             gpointer mem);
void        go_mem_chunk_foreach_leak       (GOMemChunk *chunk,
                                             GFunc cb,
                                             gpointer user);
void        go_object_toggle                (gpointer object,
                                             const gchar *property_name);
GSList*     go_object_properties_collect    (GObject *obj);
void        go_object_properties_apply      (GObject *obj,
                                             GSList *props,
                                             gboolean changed_only);
void        go_object_properties_free       (GSList *props);

Description

Details

GOMapFunc ()

gpointer    (*GOMapFunc)                    (gpointer value);

value :
Returns :

go_ptr_array_insert ()

void        go_ptr_array_insert             (GPtrArray *array,
                                             gpointer value,
                                             int index);

array :
value :
index :

go_hash_keys ()

GSList*     go_hash_keys                    (GHashTable *hash);

Collects an unordered list of the keys in hash.

hash : GHashTable
Returns : a list which the caller needs to free. The content has not additional references added

go_hash_values ()

GSList*     go_hash_values                  (GHashTable *hash);

Collects an unordered list of the values in hash.

hash : GHashTable
Returns : a list which the caller needs to free. The content has not additional references added

go_slist_map ()

GSList*     go_slist_map                    (GSList const *list,
                                             GOMapFunc map_func);

list : list of some items
map_func : mapping function
Returns :

go_slist_create ()

GSList*     go_slist_create                 (gpointer item1,
                                             ...);

Creates a GList from NULL-terminated list of arguments.

item1 : First item.
... :
Returns : created list.

go_slist_free_custom ()

void        go_slist_free_custom            (GSList *list,
                                             GFreeFunc free_func);

Clears a list, calling free_func for each list item.

list : list of some items
free_func : function freeing list item

go_string_slist_copy()

#define	 go_string_slist_copy(list) go_slist_map (list, (GOMapFunc) g_strdup)

list :

go_strsplit_to_slist ()

GSList*     go_strsplit_to_slist            (char const *str,
                                             gchar delimiter);

Splits up string into tokens at delim and returns a string list.

str : String to split
delimiter : Token delimiter
Returns : string list which you should free after use using function e_free_string_list().

GO_SLIST_FOREACH()

#define     GO_SLIST_FOREACH(list,valtype,val,stmnt)

list :
valtype :
val :
stmnt :

GO_SLIST_PREPEND()

#define     GO_SLIST_PREPEND(list,item)

list :
item :

GO_SLIST_APPEND()

#define     GO_SLIST_APPEND(list,item)

list :
item :

GO_SLIST_REMOVE()

#define     GO_SLIST_REMOVE(list,item)

list :
item :

GO_SLIST_CONCAT()

#define     GO_SLIST_CONCAT(list_a,list_b)

list_a :
list_b :

GO_SLIST_REVERSE()

#define     GO_SLIST_REVERSE(list)

list :

GO_SLIST_SORT()

#define     GO_SLIST_SORT(list,cmp_func)

list :
cmp_func :

go_list_index_custom ()

gint        go_list_index_custom            (GList *list,
                                             gpointer data,
                                             GCompareFunc cmp_func);

list :
data :
cmp_func :
Returns :

go_list_free_custom ()

void        go_list_free_custom             (GList *list,
                                             GFreeFunc free_func);

Clears a list, calling free_func for each list item.

list : list of some items
free_func : function freeing list item

GO_LIST_FOREACH()

#define     GO_LIST_FOREACH(list,valtype,val,stmnt)

list :
valtype :
val :
stmnt :

GO_LIST_PREPEND()

#define     GO_LIST_PREPEND(list,item)

list :
item :

GO_LIST_APPEND()

#define     GO_LIST_APPEND(list,item)

list :
item :

GO_LIST_REMOVE()

#define     GO_LIST_REMOVE(list,item)

list :
item :

GO_LIST_CONCAT()

#define     GO_LIST_CONCAT(list_a,list_b)

list_a :
list_b :

GO_LIST_REVERSE()

#define     GO_LIST_REVERSE(list)

list :

GO_LIST_SORT()

#define     GO_LIST_SORT(list,cmp_func)

list :
cmp_func :

go_str_compare ()

int         go_str_compare                  (void const *x,
                                             void const *y);

x :
y :
Returns :

go_ascii_strcase_hash ()

guint       go_ascii_strcase_hash           (gconstpointer v);

v :
Returns :

go_ascii_strcase_equal ()

gint        go_ascii_strcase_equal          (gconstpointer v,
                                             gconstpointer v2);

v :
v2 :
Returns :

go_utf8_collate_casefold ()

gint        go_utf8_collate_casefold        (char const *a,
                                             char const *b);

a :
b :
Returns :

go_utf8_strcapital ()

char*       go_utf8_strcapital              (char const *p,
                                             gssize len);

Similar to g_utf8_strup and g_utf8_strup, except that this function creates a string "Very Much Like: This, One".

p : pointer to UTF-8 string
len : length in bytes, or -1.
Returns : newly allocated string.

go_strescape ()

void        go_strescape                    (GString *target,
                                             char const *str);

target :
str :

go_strunescape ()

charconst * go_strunescape                  (GString *target,
                                             char const *str);

target :
str :
Returns :

go_string_append_gstring ()

void        go_string_append_gstring        (GString *target,
                                             const GString *src);

target :
src :

go_guess_encoding ()

charconst * go_guess_encoding               (char const *raw,
                                             size_t len,
                                             char const *user_guess,
                                             char **utf8_str);

raw :
len :
user_guess :
utf8_str :
Returns :

go_get_real_name ()

charconst * go_get_real_name                (void);

Return a utf8 encoded string with the current user name. Caller should _NOT_ free the result.

Returns :

go_destroy_password ()

void        go_destroy_password             (char *passwd);

Overwrite a string holding a password. This is a separate routine to ensure that the compiler does not try to outsmart us.

Note: this does not free the memory.

passwd :

go_mem_chunk_new ()

GOMemChunk* go_mem_chunk_new                (char const *name,
                                             size_t user_atom_size,
                                             size_t chunk_size);

name :
user_atom_size :
chunk_size :
Returns :

go_mem_chunk_destroy ()

void        go_mem_chunk_destroy            (GOMemChunk *chunk,
                                             gboolean expect_leaks);

chunk :
expect_leaks :

go_mem_chunk_alloc ()

gpointer    go_mem_chunk_alloc              (GOMemChunk *chunk);

chunk :
Returns :

go_mem_chunk_alloc0 ()

gpointer    go_mem_chunk_alloc0             (GOMemChunk *chunk);

chunk :
Returns :

go_mem_chunk_free ()

void        go_mem_chunk_free               (GOMemChunk *chunk,
                                             gpointer mem);

chunk :
mem :

go_mem_chunk_foreach_leak ()

void        go_mem_chunk_foreach_leak       (GOMemChunk *chunk,
                                             GFunc cb,
                                             gpointer user);

chunk :
cb :
user :

go_object_toggle ()

void        go_object_toggle                (gpointer object,
                                             const gchar *property_name);

object :
property_name :

go_object_properties_collect ()

GSList*     go_object_properties_collect    (GObject *obj);

obj :
Returns :

go_object_properties_apply ()

void        go_object_properties_apply      (GObject *obj,
                                             GSList *props,
                                             gboolean changed_only);

obj :
props :
changed_only :

go_object_properties_free ()

void        go_object_properties_free       (GSList *props);

props :