changeset 7786:203a18e56dc6

[gaim-migrate @ 8431] * Documentation is good. Not that I have any idea if any of my documentation works, because I haven't checked... I totally made up @note, but it sure seems reasonable to me. * A couple of stringref utility functions which seem useful in any case, like len and cmp. * I'm going ahead and pushing a stringref creation function which creates a zero-refcount stringref into CVS... Nothing uses it yet, but I think that it is useful even in the absence of major stringref conversion ... because it's garbage collected! If no one refs it before the next iteration of the mainloop, it will be freed ... if it is ref'd, of course, it will have to be freed normally by an unref at some later point. committer: Tailor Script <[e-mail]>

--- a/src/stringref.c	Sun Dec 07 16:15:21 2003 +0000
+++ b/src/stringref.c	Sun Dec 07 16:28:34 2003 +0000
@@ -1,5 +1,5 @@
 /**
- * @file stringref.c Reference-counted strings
+ * @file stringref.c Reference-counted immutable strings
  * @ingroup core
  *
  * gaim
@@ -29,6 +29,11 @@
 
 #include "stringref.h"
 
+static GList *gclist = NULL;
+
+static void stringref_free(GaimStringref *stringref);
+static gboolean gs_idle_cb(gpointer data);
+
 GaimStringref *gaim_stringref_new(const char *value)
 {
 	GaimStringref *newref;
@@ -43,6 +48,24 @@
 	return newref;
 }
 
+GaimStringref *gaim_stringref_new_noref(const char *value)
+{
+	GaimStringref *newref;
+
+	if (value == NULL)
+		return NULL;
+
+	newref = g_malloc(sizeof(GaimStringref) + strlen(value) + 1);
+	strcpy(newref->value, value);
+	newref->ref = 0x80000000;
+
+	if (gclist == NULL)
+		g_idle_add(gs_idle_cb, NULL);
+	gclist = g_list_prepend(gclist, newref);
+
+	return newref;
+}
+
 GaimStringref *gaim_stringref_printf(const char *format, ...)
 {
 	GaimStringref *newref;
@@ -71,11 +94,54 @@
 void gaim_stringref_unref(GaimStringref *stringref)
 {
 	g_return_if_fail(stringref != NULL);
-	if (--stringref->ref == 0)
+	if ((--(stringref->ref) & 0x7fffffff) == 0) {
+		if (stringref->ref & 0x80000000)
+			gclist = g_list_remove(gclist, stringref);
 		g_free(stringref);
+	}
 }
 
 const char *gaim_stringref_value(const GaimStringref *stringref)
 {
 	return (stringref == NULL ? NULL : stringref->value);
 }
+
+int gaim_stringref_cmp(const GaimStringref *s1, const GaimStringref *s2)
+{
+	return (s1 == s2 ? 0 : strcmp(gaim_stringref_value(s1), gaim_stringref_value(s2)));
+}
+
+size_t gaim_stringref_len(const GaimStringref *stringref)
+{
+	return strlen(gaim_stringref_value(stringref));
+}
+
+static void stringref_free(GaimStringref *stringref)
+{
+#ifdef DEBUG
+	if (stringref->ref != 0) {
+		gaim_debug(GAIM_DEBUG_ERROR, "stringref", "Free of nonzero (%d) ref stringref!\n", stringref->ref);
+		return;
+	}
+#endif /* DEBUG */
+	g_free(stringref);
+}
+
+static gboolean gs_idle_cb(gpointer data)
+{
+	GaimStringref *ref;
+	GList *del;
+
+	while (gclist != NULL) {
+		ref = gclist->data;
+		ref->ref &= 0x7fffffff;
+		if (ref->ref == 0) {
+			stringref_free(ref);
+		}
+		del = gclist;
+		gclist = gclist->next;
+		g_list_free_1(del);
+	}
+
+	return FALSE;
+}

--- a/src/stringref.h	Sun Dec 07 16:15:21 2003 +0000
+++ b/src/stringref.h	Sun Dec 07 16:28:34 2003 +0000
@@ -26,13 +26,24 @@
 #define _GAIM_STRINGREF_H_
 
 /**
+ * The internal representation of a stringref.
+ *
  * @note For this structure to be useful, the string contained within
  * it must be immutable -- for this reason, do _not_ access it
  * directly!
  */
 typedef struct _GaimStringref {
-	int ref;
-	char value[0];
+	unsigned int ref;	/**< The reference count of this string.
+	                         *   Note that reference counts are only
+				 *   31 bits, and the high-order bit
+				 *   indicates whether this string is up
+				 *   for GC at the next idle handler...
+				 *   But you aren't going to touch this
+				 *   anyway, right? */
+	char value[0];		/**< The string contained in this ref.
+	                         *   Notice that it is simply "hanging
+				 *   off the end" of the ref ... this
+				 *   is to save an allocation. */
 } GaimStringref;
 
 /**
@@ -48,6 +59,20 @@
 GaimStringref *gaim_stringref_new(const char *value);
 
 /**
+ * Creates an immutable reference-counted string object.  The newly
+ * created object will have a reference count of zero, and if it is
+ * not referenced before the next iteration of the mainloop it will
+ * be freed at that time.
+ *
+ * @param value This will be the value of the string; it will be
+ *              duplicated.
+ *
+ * @return A newly allocated string reference object with a refcount
+ *         of zero.
+ */
+GaimStringref *gaim_stringref_new_noref(const char *value);
+
+/**
  * Creates an immutable reference-counted string object from a printf
  * format specification and arguments.  The created object will have a
  * reference count of 1.
@@ -95,4 +120,26 @@
  */
 const char *gaim_stringref_value(const GaimStringref *stringref);
 
+/**
+ * Compare two stringrefs for string equality.  This returns the same
+ * value as strcmp would, where <0 indicates that s1 is "less than" s2
+ * in the ASCII lexicography, 0 indicates equality, etc.
+ *
+ * @param s1 The reference string.
+ *
+ * @param s2 The string to compare against the reference.
+ *
+ * @return An ordering indication on s1 and s2.
+ */
+int gaim_stringref_cmp(const GaimStringref *s1, const GaimStringref *s2);
+
+/**
+ * Find the length of the string inside a stringref.
+ *
+ * @param stringref The string in whose length we are interested.
+ *
+ * @return The length of the string in stringref
+ */
+size_t gaim_stringref_len(const GaimStringref *stringref);
+
 #endif /* _GAIM_STRINGREF_H_ */