## 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);
    char const *        go_strunescape                      (GString *target,
                                                             char const *str);
    void                go_string_append_gstring            (GString *target,
                                                             const GString *src);
    void                go_string_append_c_n                (GString *target,
                                                             char c,
                                                             gsize n);
    char const *        go_guess_encoding                   (char const *raw,
                                                             gsize len,
                                                             char const *user_guess,
                                                             char **utf8_str);
    char const *        go_get_real_name                    (void);
    void                go_destroy_password                 (char *passwd);

                        GOMemChunk;
    GOMemChunk *        go_mem_chunk_new                    (char const *name,
                                                             gsize user_atom_size,
                                                             gsize 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);
    gboolean            go_object_set_property              (GObject *obj,
                                                             const char *property_name,
                                                             const char *user_prop_name,
                                                             const char *value,
                                                             GError **err,
                                                             const char *error_template);

    gboolean            (*GOParseKeyValueFunc)              (const char *name,
                                                             const char *value,
                                                             GError **err,
                                                             gpointer user);
    gboolean            go_parse_key_value                  (const char *options,
                                                             GError **err,
                                                             GOParseKeyValueFunc handler,
                                                             gpointer user);

## 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` : | itionally `NULL`
`...` : | `NULL` terminated list of additional items
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 ()

    char const *        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_string_append_c_n ()

    void                go_string_append_c_n                (GString *target,
                                                             char c,
                                                             gsize n);

`target` : |
`c` : |
`n` : |

### go_guess_encoding ()

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

`raw` : |
`len` : |
`user_guess` : |
`utf8_str` : |
Returns : |

### go_get_real_name ()

    char const *        go_get_real_name                    (void);

Returns : | a utf8 encoded string with the current user name. Caller should _NOT_ free the result.

### 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` : | The buffer to clear

### GOMemChunk

    typedef struct _GOMemChunk GOMemChunk;

### go_mem_chunk_new ()

    GOMemChunk *        go_mem_chunk_new                    (char const *name,
                                                             gsize user_atom_size,
                                                             gsize 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);

Toggle a boolean object property.

`object` : | GObject
`property_name` : | 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` : |

### go_object_set_property ()

    gboolean            go_object_set_property              (GObject *obj,
                                                             const char *property_name,
                                                             const char *user_prop_name,
                                                             const char *value,
                                                             GError **err,
                                                             const char *error_template);

`obj` : |
`property_name` : |
`user_prop_name` : |
`value` : |
`err` : |
`error_template` : |
Returns : |

### GOParseKeyValueFunc ()

    gboolean            (*GOParseKeyValueFunc)              (const char *name,
                                                             const char *value,
                                                             GError **err,
                                                             gpointer user);

`name` : |
`value` : |
`err` : |
`user` : |
Returns : |

### go_parse_key_value ()

    gboolean            go_parse_key_value                  (const char *options,
                                                             GError **err,
                                                             GOParseKeyValueFunc handler,
                                                             gpointer user);

`options` : | Options string.
`err` : | Reference to store GError if parsing fails.
`handler` : | Handler to call for each key-value pair.
`user` : | user pointer.
Returns : |