Index: libedataserver/e-memory.c
===================================================================
RCS file: /cvs/gnome/evolution-data-server/libedataserver/e-memory.c,v
retrieving revision 1.6
diff -u -p -r1.6 e-memory.c
--- libedataserver/e-memory.c	31 Aug 2005 04:26:10 -0000	1.6
+++ libedataserver/e-memory.c	20 Oct 2006 17:40:26 -0000
@@ -26,21 +26,8 @@
 #include <stdlib.h> /* alloca() */
 #include <glib.h>
 
-#define s(x)			/* strv debug */
-#define p(x)   /* poolv debug */
-#define p2(x)   /* poolv assertion checking */
-
 /*#define MALLOC_CHECK*/
 
-/*#define PROFILE_POOLV*/
-
-#ifdef PROFILE_POOLV
-#include <time.h>
-#define pp(x) x
-#else
-#define pp(x)
-#endif
-
 /*#define TIMEIT*/
 
 #ifdef TIMEIT
@@ -93,9 +80,6 @@ checkmem(void *p)
 		}
 	}
 }
-#define MPROBE(x) checkmem((void *)(x))
-#else
-#define MPROBE(x)
 #endif
 
 /* mempool class */
@@ -544,666 +528,6 @@ void e_mempool_destroy(MemPool *pool)
 	}
 }
 
-
-/*
-  string array classes
-*/
-
-#define STRV_UNPACKED ((unsigned char)(~0))
-
-struct _EStrv {
-	unsigned char length;	/* how many entries we have (or the token STRV_UNPACKED) */
-	char data[1];		/* data follows */
-};
-
-struct _s_strv_string {
-	char *string;		/* the string to output */
-	char *free;		/* a string to free, if we referenced it */
-};
-
-struct _e_strvunpacked {
-	unsigned char type;	/* we overload last to indicate this is unpacked */
-	MemPool *pool;		/* pool of memory for strings */
-	struct _EStrv *source;	/* if we were converted from a packed one, keep the source around for a while */
-	unsigned int length;
-	struct _s_strv_string strings[1]; /* the string array data follows */
-};
-
-/**
- * e_strv_new:
- * @size: The number of elements in the strv.  Currently this is limited
- * to 254 elements.
- * 
- * Create a new strv (string array) header.  strv's can be used to
- * create and work with arrays of strings that can then be compressed
- * into a space-efficient static structure.  This is useful
- * where a number of strings are to be stored for lookup, and not
- * generally edited afterwards.
- *
- * The size limit is currently 254 elements.  This will probably not
- * change as arrays of this size suffer significant performance
- * penalties when looking up strings with high indices.
- * 
- * Return value: 
- **/
-struct _EStrv *
-e_strv_new(int size)
-{
-	struct _e_strvunpacked *s;
-
-	g_assert(size<255);
-
-	s = g_malloc(sizeof(*s) + (size-1)*sizeof(s->strings[0]));
-	s(printf("new strv=%p, size = %d bytes\n", s, sizeof(*s) + (size-1)*sizeof(char *)));
-	s->type = STRV_UNPACKED;
-	s->pool = NULL;
-	s->length = size;
-	s->source = NULL;
-	memset(s->strings, 0, size*sizeof(s->strings[0]));
-
-	return (struct _EStrv *)s;
-}
-
-static struct _e_strvunpacked *
-strv_unpack(struct _EStrv *strv)
-{
-	struct _e_strvunpacked *s;
-	register char *p;
-	int i;
-
-	s(printf("unpacking\n"));
-
-	s = (struct _e_strvunpacked *)e_strv_new(strv->length);
-	p = strv->data;
-	for (i=0;i<s->length;i++) {
-		if (i>0)
-			while (*p++)
-				;
-		s->strings[i].string = p;
-	}
-	s->source = strv;
-	s->type = STRV_UNPACKED;
-
-	return s;
-}
-
-/**
- * e_strv_set_ref:
- * @strv: 
- * @index: 
- * @str: 
- * 
- * Set a string array element by reference.  The string
- * is not copied until the array is packed.
- * 
- * If @strv has been packed, then it is unpacked ready
- * for more inserts, and should be packed again once finished with.
- * The memory used by the original @strv is not freed until
- * the new strv is packed, or freed itself.
- *
- * Return value: A new EStrv if the strv has already
- * been packed, otherwise @strv.
- **/
-struct _EStrv *
-e_strv_set_ref(struct _EStrv *strv, int index, char *str)
-{
-	struct _e_strvunpacked *s;
-
-	s(printf("set ref %d '%s'\nawkmeharder: %s\n ", index, str, str));
-
-	if (strv->length != STRV_UNPACKED)
-		s = strv_unpack(strv);
-	else
-		s = (struct _e_strvunpacked *)strv;
-
-	g_assert(index>=0 && index < s->length);
-
-	s->strings[index].string = str;
-
-	return (struct _EStrv *)s;
-}
-
-/**
- * e_strv_set_ref_free:
- * @strv: 
- * @index: 
- * @str: 
- * 
- * Set a string by reference, similar to set_ref, but also
- * free the string when finished with it.  The string
- * is not copied until the strv is packed, and not at
- * all if the index is overwritten.
- * 
- * Return value: @strv if already unpacked, otherwise an packed
- * EStrv.
- **/
-struct _EStrv *
-e_strv_set_ref_free(struct _EStrv *strv, int index, char *str)
-{
-	struct _e_strvunpacked *s;
-
-	s(printf("set ref %d '%s'\nawkmeevenharder: %s\n ", index, str, str));
-
-	if (strv->length != STRV_UNPACKED)
-		s = strv_unpack(strv);
-	else
-		s = (struct _e_strvunpacked *)strv;
-
-	g_assert(index>=0 && index < s->length);
-
-	s->strings[index].string = str;
-	if (s->strings[index].free)
-		g_free(s->strings[index].free);
-	s->strings[index].free = str;
-
-	return (struct _EStrv *)s;
-}
-
-/**
- * e_strv_set:
- * @strv: 
- * @index: 
- * @str: 
- * 
- * Set a string array reference.  The string @str is copied
- * into the string array at location @index.
- * 
- * If @strv has been packed, then it is unpacked ready
- * for more inserts, and should be packed again once finished with.
- *
- * Return value: A new EStrv if the strv has already
- * been packed, otherwise @strv.
- **/
-struct _EStrv *
-e_strv_set(struct _EStrv *strv, int index, const char *str)
-{
-	struct _e_strvunpacked *s;
-
-	s(printf("set %d '%s'\n", index, str));
-
-	if (strv->length != STRV_UNPACKED)
-		s = strv_unpack(strv);
-	else
-		s = (struct _e_strvunpacked *)strv;
-
-	g_assert(index>=0 && index < s->length);
-
-	if (s->pool == NULL)
-		s->pool = e_mempool_new(1024, 512, E_MEMPOOL_ALIGN_BYTE);
-
-	s->strings[index].string = e_mempool_alloc(s->pool, strlen(str)+1);
-	strcpy(s->strings[index].string, str);
-
-	return (struct _EStrv *)s;
-}
-
-/**
- * e_strv_pack:
- * @strv: 
- * 
- * Pack the @strv into a space efficient structure for later lookup.
- *
- * All strings are packed into a single allocated block, separated
- * by single \0 characters, together with a count byte.
- * 
- * Return value: 
- **/
-struct _EStrv *
-e_strv_pack(struct _EStrv *strv)
-{
-	struct _e_strvunpacked *s;
-	int len, i;
-	register char *src, *dst;
-
-	if (strv->length == STRV_UNPACKED) {
-		s = (struct _e_strvunpacked *)strv;
-
-		s(printf("packing string\n"));
-
-		len = 0;
-		for (i=0;i<s->length;i++)
-			len += s->strings[i].string?strlen(s->strings[i].string)+1:1;
-
-		strv = g_malloc(sizeof(*strv) + len);
-		s(printf("allocating strv=%p, size = %d\n", strv, sizeof(*strv)+len));
-		strv->length = s->length;
-		dst = strv->data;
-		for (i=0;i<s->length;i++) {
-			if ((src = s->strings[i].string)) {
-				while ((*dst++ = *src++))
-					;
-			} else {
-				*dst++ = 0;
-			}
-		}
-		e_strv_destroy((struct _EStrv *)s);
-	}
-	return strv;
-}
-
-/**
- * e_strv_get:
- * @strv: 
- * @index: 
- * 
- * Retrieve a string by index.  This function works
- * identically on both packed and unpacked strv's, although
- * may be much slower on a packed strv.
- * 
- * Return value: 
- **/
-char *
-e_strv_get(struct _EStrv *strv, int index)
-{
-	struct _e_strvunpacked *s;
-	char *p;
-
-	if (strv->length != STRV_UNPACKED) {
-		g_assert(index>=0 && index < strv->length);
-		p = strv->data;
-		while (index > 0) {
-			while (*p++ != 0)
-				;
-			index--;
-		}
-		return p;
-	} else {
-		s = (struct _e_strvunpacked *)strv;
-		g_assert(index>=0 && index < s->length);
-		return s->strings[index].string?s->strings[index].string:"";
-	}
-}
-
-/**
- * e_strv_destroy:
- * @strv: 
- * 
- * Free a strv and all associated memory.  Works on packed
- * or unpacked strv's.
- **/
-void
-e_strv_destroy(struct _EStrv *strv)
-{
-	struct _e_strvunpacked *s;
-	int i;
-
-	s(printf("freeing strv\n"));
-
-	if (strv->length == STRV_UNPACKED) {
-		s = (struct _e_strvunpacked *)strv;
-		if (s->pool)
-			e_mempool_destroy(s->pool);
-		if (s->source)
-			e_strv_destroy(s->source);
-		for (i=0;i<s->length;i++) {
-			if (s->strings[i].free)
-				g_free(s->strings[i].free);
-		}
-	}
-
-	s(printf("freeing strv=%p\n", strv));
-
-	g_free(strv);
-}
-
-
-
-/* string pool stuff */
-
-/* TODO:
-    garbage collection, using the following technique:
-      Create a memchunk for each possible size of poolv, and allocate every poolv from those
-      To garbage collect, scan all memchunk internally, ignoring any free areas (or mark each
-        poolv when freeing it - set length 0?), and find out which strings are not anywhere,
-	then free them.
-
-    OR:
-       Just keep a refcount in the hashtable, instead of duplicating the key pointer.
-
-   either would also require a free for the mempool, so ignore it for now */
-
-/*#define POOLV_REFCNT*/ /* Define to enable refcounting code that does
-			automatic garbage collection of unused strings */
-
-static GHashTable *poolv_pool = NULL;
-static EMemPool *poolv_mempool = NULL;
-
-#ifdef MALLOC_CHECK
-static GPtrArray *poolv_table = NULL;
-#endif
-
-#ifdef PROFILE_POOLV
-static gulong poolv_hits = 0;
-static gulong poolv_misses = 0;
-static unsigned long poolv_mem, poolv_count;
-#endif
-
-#ifdef G_THREADS_ENABLED
-static GStaticMutex poolv_mutex = G_STATIC_MUTEX_INIT;
-#endif
-
-struct _EPoolv {
-	unsigned char length;
-	char *s[1];
-};
-
-/**
- * e_poolv_new: @size: The number of elements in the poolv, maximum of 254 elements.
- *
- * create a new poolv (string vector which shares a global string
- * pool).  poolv's can be used to work with arrays of strings which
- * save memory by eliminating duplicated allocations of the same
- * string.
- *
- * this is useful when you have a log of read-only strings that do not
- * go away and are duplicated a lot (such as email headers).
- *
- * we should probably in the future ref count the strings contained in
- * the hash table, but for now let's not.
- *
- * Return value: new pooled string vector
- **/
-EPoolv *
-e_poolv_new(unsigned int size)
-{
-	EPoolv *poolv;
-
-	g_assert(size < 255);
-
-	poolv = g_malloc0(sizeof (*poolv) + (size - 1) * sizeof (char *));
-	poolv->length = size;
-
-#ifdef G_THREADS_ENABLED
-	g_static_mutex_lock(&poolv_mutex);
-#endif
-	if (!poolv_pool)
-		poolv_pool = g_hash_table_new(g_str_hash, g_str_equal);
-
-	if (!poolv_mempool)
-		poolv_mempool = e_mempool_new(32 * 1024, 512, E_MEMPOOL_ALIGN_BYTE);
-
-#ifdef MALLOC_CHECK
-	{
-		int i;
-
-		if (poolv_table == NULL)
-			poolv_table = g_ptr_array_new();
-
-		for (i=0;i<poolv_table->len;i++)
-			MPROBE(poolv_table->pdata[i]);
-
-		g_ptr_array_add(poolv_table, poolv);
-	}
-#endif
-
-#ifdef G_THREADS_ENABLED
-	g_static_mutex_unlock(&poolv_mutex);
-#endif
-
-	p(printf("new poolv=%p\tsize=%d\n", poolv, sizeof(*poolv) + (size-1)*sizeof(char *)));
-
-#ifdef PROFILE_POOLV
-	poolv_count++;
-#endif
-	return poolv;
-}
-
-/**
- * e_poolv_cpy:
- * @dest: destination pooled string vector
- * @src: source pooled string vector
- *
- * Copy the contents of a pooled string vector
- *
- * Return value: @dest, which may be re-allocated if the strings
- * are different lengths.
- **/
-EPoolv *
-e_poolv_cpy(EPoolv *dest, const EPoolv *src)
-{
-#ifdef POOLV_REFCNT
-	int i;
-	unsigned int ref;
-	char *key;
-#endif
-
-	p2(g_return_val_if_fail (dest != NULL, NULL));
-	p2(g_return_val_if_fail (src != NULL, NULL));
-
-	MPROBE(dest);
-	MPROBE(src);
-
-	if (dest->length != src->length) {
-		e_poolv_destroy(dest);
-		dest = e_poolv_new(src->length);
-	}
-
-#ifdef POOLV_REFCNT
-#ifdef G_THREADS_ENABLED
-	g_static_mutex_lock(&poolv_mutex);
-#endif
-	/* ref new copies */
-	for (i=0;i<src->length;i++) {
-		if (src->s[i]) {
-			if (g_hash_table_lookup_extended(poolv_pool, src->s[i], (void **)&key, (void **)&ref)) {
-				g_hash_table_insert(poolv_pool, key, (void *)(ref+1));
-			} else {
-				g_assert_not_reached();
-			}
-		}
-	}
-
-	/* unref the old ones */
-	for (i=0;i<dest->length;i++) {
-		if (dest->s[i]) {
-			if (g_hash_table_lookup_extended(poolv_pool, dest->s[i], (void **)&key, (void **)&ref)) {
-				/* if ref == 1 free it */
-				g_assert(ref > 0);
-				g_hash_table_insert(poolv_pool, key, (void *)(ref-1));
-			} else {
-				g_assert_not_reached();
-			}
-		}
-	}
-#ifdef G_THREADS_ENABLED
-	g_static_mutex_unlock(&poolv_mutex);
-#endif
-#endif
-
-	memcpy(dest->s, src->s, src->length * sizeof (char *));
-
-	return dest;
-}
-
-#ifdef PROFILE_POOLV
-static void
-poolv_profile_update (void)
-{
-	static time_t last_time = 0;
-	time_t new_time;
-
-	new_time = time (NULL);
-	if (new_time - last_time < 5)
-		return;
-
-	printf("poolv profile: %lu hits, %lu misses: %d%% hit rate, memory: %lu, instances: %lu\n", 
-	       poolv_hits, poolv_misses, 
-	       (int)(100.0 * ((double) poolv_hits / (double) (poolv_hits + poolv_misses))),
-	       poolv_mem, poolv_count);
-
-	last_time = new_time;
-}
-#endif
-
-/**
- * e_poolv_set:
- * @poolv: pooled string vector
- * @index: index in vector of string
- * @str: string to set
- * @freeit: whether the caller is releasing its reference to the
- * string
- *
- * Set a string vector reference.  If the caller will no longer be
- * referencing the string, freeit should be TRUE.  Otherwise, this
- * will duplicate the string if it is not found in the pool.
- *
- * Return value: @poolv
- **/
-EPoolv *
-e_poolv_set (EPoolv *poolv, int index, char *str, int freeit)
-{
-#ifdef POOLV_REFCNT
-	unsigned int ref;
-	char *key;
-#endif
-
-	p2(g_return_val_if_fail (poolv != NULL, NULL));
-
-	g_assert(index >=0 && index < poolv->length);
-
-	MPROBE(poolv);
-
-	p(printf("setting %d `%s'\n", index, str));
-
-	if (!str) {
-#ifdef POOLV_REFCNT
-		if (poolv->s[index]) {
-			if (g_hash_table_lookup_extended(poolv_pool, poolv->s[index], (void **)&key, (void **)&ref)) {
-				g_assert(ref > 0);
-				g_hash_table_insert(poolv_pool, key, (void *)(ref-1));
-			} else {
-				g_assert_not_reached();
-			}
-		}
-#endif
-		poolv->s[index] = NULL;
-		return poolv;
-	}
-
-#ifdef G_THREADS_ENABLED
-	g_static_mutex_lock(&poolv_mutex);
-#endif
-
-#ifdef POOLV_REFCNT
-	if (g_hash_table_lookup_extended(poolv_pool, str, (void **)&key, (void **)&ref)) {
-		g_hash_table_insert(poolv_pool, key, (void *)(ref+1));
-		poolv->s[index] = key;
-# ifdef PROFILE_POOLV
-		poolv_hits++;
-		poolv_profile_update ();
-# endif
-	} else {
-# ifdef PROFILE_POOLV
-		poolv_misses++;
-		poolv_mem += strlen(str);
-		poolv_profile_update ();
-# endif
-		poolv->s[index] = e_mempool_strdup(poolv_mempool, str);
-		g_hash_table_insert(poolv_pool, poolv->s[index], (void *)1);
-	}
-
-#else  /* !POOLV_REFCNT */
-	if ((poolv->s[index] = g_hash_table_lookup(poolv_pool, str)) != NULL) {
-# ifdef PROFILE_POOLV
-		poolv_hits++;
-		poolv_profile_update ();
-# endif
-	} else {
-# ifdef PROFILE_POOLV
-		poolv_misses++;
-		poolv_mem += strlen(str);
-		poolv_profile_update ();
-# endif
-		poolv->s[index] = e_mempool_strdup(poolv_mempool, str);
-		g_hash_table_insert(poolv_pool, poolv->s[index], poolv->s[index]);
-	}
-#endif /* !POOLV_REFCNT */
-
-#ifdef G_THREADS_ENABLED
-	g_static_mutex_unlock(&poolv_mutex);
-#endif
-
-	if (freeit)
-		g_free(str);
-
-	return poolv;
-}
-
-/**
- * e_poolv_get:
- * @poolv: pooled string vector
- * @index: index in vector of string
- *
- * Retrieve a string by index.  This could possibly just be a macro.
- *
- * Since the pool is never freed, this string does not need to be
- * duplicated, but should not be modified.
- *
- * Return value: string at that index.
- **/
-const char *
-e_poolv_get(EPoolv *poolv, int index)
-{
-	g_assert(poolv != NULL);
-	g_assert(index>= 0 && index < poolv->length);
-
-	MPROBE(poolv);
-
-	p(printf("get %d = `%s'\n", index, poolv->s[index]));
-
-	return poolv->s[index]?poolv->s[index]:"";
-}
-
-/**
- * e_poolv_destroy:
- * @poolv: pooled string vector to free
- *
- * Free a pooled string vector.  This doesn't free the strings from
- * the vector, however.
- **/
-void
-e_poolv_destroy(EPoolv *poolv)
-{
-#ifdef POOLV_REFCNT
-	int i;
-	unsigned int ref;
-	char *key;
-
-	MPROBE(poolv);
-
-#ifdef G_THREADS_ENABLED
-	g_static_mutex_lock(&poolv_mutex);
-#endif
-
-#ifdef MALLOC_CHECK
-	for (i=0;i<poolv_table->len;i++)
-		MPROBE(poolv_table->pdata[i]);
-
-	g_ptr_array_remove_fast(poolv_table, poolv);
-#endif
-
-	for (i=0;i<poolv->length;i++) {
-		if (poolv->s[i]) {
-			if (g_hash_table_lookup_extended(poolv_pool, poolv->s[i], (void **)&key, (void **)&ref)) {
-				/* if ref == 1 free it */
-				g_assert(ref > 0);
-				g_hash_table_insert(poolv_pool, key, (void *)(ref-1));
-			} else {
-				g_assert_not_reached();
-			}
-		}
-	}
-#ifdef G_THREADS_ENABLED
-	g_static_mutex_unlock(&poolv_mutex);
-#endif
-#endif
-
-#ifdef PROFILE_POOLV
-	poolv_count++;
-#endif
-	g_free(poolv);
-}
-
 #if 0
 
 #define CHUNK_SIZE (20)
@@ -1217,45 +541,8 @@ main()
 	MemChunk *mc;
 	void *mem, *last;
 	GMemChunk *gmc;
-	struct _EStrv *s;
-
-	s = strv_new(8);
-	s = strv_set(s, 1, "Testing 1");
-	s = strv_set(s, 2, "Testing 2");
-	s = strv_set(s, 3, "Testing 3");
-	s = strv_set(s, 4, "Testing 4");
-	s = strv_set(s, 5, "Testing 5");
-	s = strv_set(s, 6, "Testing 7");
-
-	for (i=0;i<8;i++) {
-		printf("s[%d] = %s\n", i, strv_get(s, i));
-	}
 
 	s(sleep(5));
-
-	printf("packing ...\n");
-	s = strv_pack(s);
-
-	for (i=0;i<8;i++) {
-		printf("s[%d] = %s\n", i, strv_get(s, i));
-	}
-
-	printf("setting ...\n");
-
-	s = strv_set_ref(s, 1, "Testing 1 x");
-
-	for (i=0;i<8;i++) {
-		printf("s[%d] = %s\n", i, strv_get(s, i));
-	}
-
-	printf("packing ...\n");
-	s = strv_pack(s);
-
-	for (i=0;i<8;i++) {
-		printf("s[%d] = %s\n", i, strv_get(s, i));
-	}
-
-	strv_free(s);
 
 #if 0
 	time_start("Using memchunks");
Index: libedataserver/e-memory.h
===================================================================
RCS file: /cvs/gnome/evolution-data-server/libedataserver/e-memory.h,v
retrieving revision 1.4
diff -u -p -r1.4 e-memory.h
--- libedataserver/e-memory.h	31 Aug 2005 04:26:10 -0000	1.4
+++ libedataserver/e-memory.h	20 Oct 2006 17:40:26 -0000
@@ -54,27 +54,6 @@ char *e_mempool_strdup(EMemPool *pool, c
 void e_mempool_flush(EMemPool *pool, int freeall);
 void e_mempool_destroy(EMemPool *pool);
 
-/* strv's string arrays that can be efficiently modified and then compressed mainly for retrival */
-/* building is relatively fast, once compressed it takes the minimum amount of memory possible to store */
-typedef struct _EStrv EStrv;
-
-EStrv *e_strv_new(int size);
-EStrv *e_strv_set_ref(EStrv *strv, int index, char *str);
-EStrv *e_strv_set_ref_free(EStrv *strv, int index, char *str);
-EStrv *e_strv_set(EStrv *strv, int index, const char *str);
-EStrv *e_strv_pack(EStrv *strv);
-char *e_strv_get(EStrv *strv, int index);
-void e_strv_destroy(EStrv *strv);
-
-/* poolv's are similar to strv's, but they store common strings */
-typedef struct _EPoolv EPoolv;
-
-EPoolv *e_poolv_new(unsigned int size);
-EPoolv *e_poolv_cpy(EPoolv *dest, const EPoolv *src);
-EPoolv *e_poolv_set(EPoolv *poolv, int index, char *str, int freeit);
-const char *e_poolv_get(EPoolv *poolv, int index);
-void e_poolv_destroy(EPoolv *poolv);
-
 G_END_DECLS
 
 #endif /* ! _E_MEMORY_H */
