Created attachment 221980 [details] [review]
Add a GStaticString type

Attached is a patch that adds an immutable reference counted string type to Glib, similar to QString and NSString. The API is 

G_BEGIN_DECLS

typedef struct _GStaticString GStaticString;

GStaticString *g_static_string_new                  (const char *str);
GStaticString *g_static_string_new_with_buffer      (char  *buffer,
                                                     gssize length);
GStaticString *g_static_string_new_from_format      (const char *format,
                                                     ...);
GStaticString *g_static_string_ref                  (GStaticString *sstr);
void           g_static_string_unref                (GStaticString *sstr);
const char *   g_static_string_get_cstring          (GStaticString *sstr);
gsize          g_static_string_get_length           (GStaticString *sstr);
GStaticString *g_static_string_concat               (GStaticString *sstr_a,
                                                     GStaticString *sstr_b);
GStaticString *g_static_string_append_cstring       (GStaticString *sstr,
                                                     const char    *str);
GStaticString *g_static_string_append_format        (GStaticString *sstr,
                                                     const char    *format,
                                                     ...);
GStaticString *g_static_string_prepend_cstring      (GStaticString *sstr,
                                                     const char    *str);
GStaticString *g_static_string_prepend_format       (GStaticString *sstr,
                                                     const char    *format,
                                                     ...);
GStaticString *g_static_string_canon                (GStaticString *sstr,
                                                     const char    *valid_chars,
                                                     char           substitutor);
GStaticString *g_static_string_delimit              (GStaticString *sstr,
                                                     const char    *delimiters,
                                                     char           new_delimiter);
GStaticString *g_static_string_reverse              (GStaticString *sstr);
gssize         g_static_string_find_string          (GStaticString *haystack_sstr,
                                                     GStaticString *needle_sstr);
gssize         g_static_string_find_cstring         (GStaticString *haystack_sstr,
                                                     const char    *needle_str);
gssize         g_static_string_reverse_find_string  (GStaticString *haystack_sstr,
                                                     GStaticString *needle_sstr);
gssize         g_static_string_reverse_find_cstring (GStaticString *haystack_sstr,
                                                     const char    *needle_str);
GStaticString *g_static_string_copy_range           (GStaticString *sstr,
                                                     gsize          start,
                                                     gsize          length);
gboolean       g_static_string_is_equal_cstring     (GStaticString *sstr,
                                                     const char    *str);
int            g_static_string_compare              (GStaticString *sstr_a,
                                                     GStaticString *sstr_b);
int            g_static_string_compare_cstring      (GStaticString *sstr_a,
                                                     const char    *str_b);
int            g_static_string_casecompare          (GStaticString *sstr_a,
                                                     GStaticString *sstr_b);
int            g_static_string_casecompare_cstring  (GStaticString *sstr_a,
                                                     const char    *str_b);
G_END_DECLS

The point is to reduce the number of short lived copies of strings, for example

char *name;
g_object_get (object, "name", &name, NULL);
g_print ("The object name is %s", name);
g_free (name);

is a fairly common (if simplified) pattern. Changing that to

GStaticString *name;
g_object_get (object, "name", &name, NULL);
g_print ("The object name is %s", g_static_string_get_cstring (name));
g_static_string_unref (name);

would just pass around the same GStaticString that is held in object saving the time needed to allocate and copy the string.

GStaticStrings are also cached, so for the case
a = g_static_string_new ("test");
b = g_static_string_new ("test");

a == b, reducing string comparisons to a simple address comparison.

Open issues:
* It'd be nice if gtk used GStaticString everywhere, but that's a large change for the future. It would still be good to have something like this in glib so people could get some of the benefits of it in their applications.

* NSString has compiler support to make creating NSStrings easy: @"hello world". Something like that to make creating GStaticString would be nice too: G_("hello world") for example. However finding a short macro name that doesn't clash will be tricky. Same for _get_cstring ();

* I'm not sure of g_static_string_new_with_buffer (buffer, length); The GStaticString takes ownership of the buffer, but due to caching it may not need to so it frees the buffer, meaning that after calling _new_with_buffer @buffer may, or may not, be valid memory anymore, the calling function has no way of knowing. It's a very useful function internally and I can see a lot of use for it to external applications, but these semantics are strange. Is it ok to document them or should we just not export the function at all?

* Should it require UTF-8 only strings? What other features would be needed for UTF-8 support?