ferret 0.11.6 → 0.11.8.4

data/ext/hashset.c

@@ -1,170 +1,192 @@
 #include "hashset.h"
 #include <string.h>
+#include "internal.h"
 
 /*
  * The HashSet contains an array +elems+ of the elements that have been added.
  * It always has +size+ elements so +size+ ane +elems+ can be used to iterate
- * over all alements in the HashSet. It also uses a HashTable to keep track of
+ * over all alements in the HashSet. It also uses a Hash to keep track of
  * which elements have been added and their index in the +elems+ array.
  */
-static HashSet *hs_alloc(void (*free_elem) (void *p))
+static HashSet *hs_alloc(free_ft free_func)
 {
     HashSet *hs = ALLOC(HashSet);
     hs->size = 0;
-    hs->capa = HS_MIN_SIZE;
-    hs->elems = ALLOC_N(void *, HS_MIN_SIZE);
-    hs->free_elem_i = free_elem ? free_elem : &dummy_free;
+    hs->first = hs->last = NULL;
+    hs->free_elem_i = free_func ? free_func : &dummy_free;
     return hs;
 }
 
-HashSet *hs_new(unsigned long (*hash)(const void *p),
-                int (*eq)(const void *p1, const void *p2),
-                void (*free_elem)(void *p))
+HashSet *hs_new(hash_ft hash_func, eq_ft eq_func, free_ft free_func)
 {
-    HashSet *hs = hs_alloc(free_elem);
-    hs->ht = h_new(hash, eq, NULL, &free);
+    HashSet *hs = hs_alloc(free_func);
+    hs->ht = h_new(hash_func, eq_func, NULL, NULL);
     return hs;
 }
 
-HashSet *hs_new_str(void (*free_elem) (void *p))
+HashSet *hs_new_str(free_ft free_func)
 {
-    HashSet *hs = hs_alloc(free_elem);
-    hs->ht = h_new_str((free_ft) NULL, &free);
+    HashSet *hs = hs_alloc(free_func);
+    hs->ht = h_new_str((free_ft) NULL, NULL);
     return hs;
 }
 
-void hs_free(HashSet *hs)
+HashSet *hs_new_ptr(free_ft free_func)
 {
-    h_destroy(hs->ht);
-    free(hs->elems);
-    free(hs);
+    HashSet *hs = hs_alloc(free_func);
+    hs->ht = h_new_ptr(NULL);
+    return hs;
 }
 
-void hs_clear(HashSet *hs)
+static INLINE void clear(HashSet *hs, bool destroy)
 {
-    int i;
-    for (i = hs->size - 1; i >= 0; i--) {
-        hs_del(hs, hs->elems[i]);
+    HashSetEntry *curr, *next = hs->first;
+    free_ft do_free = destroy ? hs->free_elem_i : &dummy_free;
+    while (NULL != (curr = next)) {
+        next = curr->next;
+        do_free(curr->elem);
+        free(curr);
     }
+    hs->first = hs->last = NULL;
+    hs->size = 0;
+}
+
+void hs_clear(HashSet *hs)
+{
+    clear(hs, true);
+    h_clear(hs->ht);
+}
+
+void hs_free(HashSet *hs)
+{
+    clear(hs, false);
+    h_destroy(hs->ht);
+    free(hs);
 }
 
 void hs_destroy(HashSet *hs)
 {
-    int i;
-    if (hs->free_elem_i != &dummy_free) {
-        for (i = 0; i < hs->size; i++) {
-            hs->free_elem_i(hs->elems[i]);
-        }
-    }
+    clear(hs, true);
     h_destroy(hs->ht);
-    free(hs->elems);
     free(hs);
 }
 
-int hs_add(HashSet *hs, void *elem)
+static INLINE void append(HashSet *hs, void *elem)
 {
-    int has_elem = h_has_key(hs->ht, elem);
-    if (has_elem == HASH_KEY_EQUAL) {
-        /* We don't want to keep two of the same elem so free if necessary */
-        hs->free_elem_i(elem);
-    }
-    else if (has_elem == HASH_KEY_SAME) {
-        /* No need to do anything */
+    HashSetEntry *entry = ALLOC(HashSetEntry);
+    entry->elem = elem;
+    entry->prev = hs->last;
+    entry->next = NULL;
+    if (!hs->first) {
+        hs->first = hs->last = entry;
     }
     else {
+        hs->last->next = entry;
+        hs->last = entry;
+    }
+    h_set(hs->ht, elem, entry);
+    hs->size++;
+}
+
+HashKeyStatus hs_add(HashSet *hs, void *elem)
+{
+    HashKeyStatus has_elem = h_has_key(hs->ht, elem);
+    switch (has_elem)
+    {
+        /* We don't want to keep two of the same elem so free if necessary */
+        case HASH_KEY_EQUAL:
+            hs->free_elem_i(elem);
+            return has_elem;
+
+        /* No need to do anything */
+        case HASH_KEY_SAME:
+            return has_elem;
+
         /* add the elem to the array, resizing if necessary */
-        if (hs->size >= hs->capa) {
-            hs->capa *= 2;
-            REALLOC_N(hs->elems, void *, hs->capa);
-        }
-        hs->elems[hs->size] = elem;
-        h_set(hs->ht, elem, imalloc(hs->size));
-        hs->size++;
+        case HASH_KEY_DOES_NOT_EXIST:
+            break;
+
     }
+
+    append(hs, elem);
     return has_elem;
 }
 
 int hs_add_safe(HashSet *hs, void *elem)
 {
-    int has_elem = h_has_key(hs->ht, elem);
-    if (has_elem == HASH_KEY_EQUAL) {
+    switch(h_has_key(hs->ht, elem))
+    {
         /* element can't be added */
-        return false;
-    }
-    else if (has_elem == HASH_KEY_SAME) {
+        case HASH_KEY_EQUAL: return false;
+
         /* the exact same element has already been added */
-        return true;
-    }
-    else {
+        case HASH_KEY_SAME : return true;
+
         /* add the elem to the array, resizing if necessary */
-        if (hs->size >= hs->capa) {
-            hs->capa *= 2;
-            REALLOC_N(hs->elems, void *, hs->capa);
-        }
-        hs->elems[hs->size] = elem;
-        h_set(hs->ht, elem, imalloc(hs->size));
-        hs->size++;
-        return true;
+        case HASH_KEY_DOES_NOT_EXIST : break;
     }
+    append(hs, elem);
+    return true;
 }
 
-int hs_del(HashSet *hs, void *elem)
+void *hs_rem(HashSet *hs, const void *elem)
 {
-    void *tmp_elem = hs_rem(hs, elem);
-    if (tmp_elem != NULL) {
-        hs->free_elem_i(tmp_elem);
-        return 1;
+    void *return_elem;
+    HashSetEntry *entry = (HashSetEntry *)h_get(hs->ht, elem);
+    if (entry == NULL) return NULL;
+
+    if (hs->first == hs->last) {
+        hs->first = hs->last = NULL;
+    }
+    else if (hs->first == entry) {
+        hs->first = entry->next;
+        hs->first->prev = NULL;
+    }
+    else if (hs->last == entry) {
+        hs->last = entry->prev;
+        hs->last->next = NULL;
     }
     else {
-        return 0;
+        entry->prev->next = entry->next;
+        entry->next->prev = entry->prev;
     }
+    return_elem = entry->elem;
+    h_del(hs->ht, return_elem);
+    free(entry);
+    hs->size--;
+    return return_elem;
 }
 
-void *hs_rem(HashSet *hs, void *elem)
+int hs_del(HashSet *hs, const void *elem)
 {
-    void *ret_elem;
-    int *index = (int *)h_get(hs->ht, elem);
-    if (index == NULL) {
-        return NULL;
-    }
-    else {
-        int i = *index;
-        int j;
-        ret_elem = hs->elems[i];
-        h_del(hs->ht, elem);
-        hs->size--;
-        for (j = i; j < hs->size; j++) {
-            hs->elems[j] = hs->elems[j+1];
-            h_set(hs->ht, hs->elems[j], imalloc(j));
-        }
-        return ret_elem;
+    void *tmp_elem = hs_rem(hs, elem);
+    if (tmp_elem != NULL) {
+        hs->free_elem_i(tmp_elem);
+        return 1;
     }
+    return 0;
 }
 
-int hs_exists(HashSet *hs, void *elem)
+HashKeyStatus hs_exists(HashSet *hs, const void *elem)
 {
     return h_has_key(hs->ht, elem);
 }
 
 HashSet *hs_merge(HashSet *hs, HashSet * other)
 {
-    int i;
-    for (i = 0; i < other->size; i++) {
-        hs_add(hs, other->elems[i]);
+    HashSetEntry *entry = other->first;
+    for (; entry != NULL; entry = entry->next) {
+        hs_add(hs, entry->elem);
     }
-    /* Now free the other hashset. It is no longer needed. No need, however, to
-     * delete the elements as they're either destroyed or in the new hash set */
+    /* Now free the other hashset. It is no longer needed. No need, however,
+     * to delete the elements as they were either destroyed or added to the
+     * new hashset.  */
     hs_free(other);
     return hs;
 }
 
-void *hs_orig(HashSet *hs, void *elem)
+void *hs_orig(HashSet *hs, const void *elem)
 {
-    int *index = h_get(hs->ht, elem);
-    if (index) {
-        return hs->elems[*index];
-    }
-    else {
-        return NULL;
-    }
+    HashSetEntry *entry = (HashSetEntry *)h_get(hs->ht, elem);
+    return entry ? entry->elem : NULL;
 }

data/ext/hashset.h

@@ -1,187 +1,215 @@
 #ifndef FRT_HASHSET_H
 #define FRT_HASHSET_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "hash.h"
 #include "global.h"
 
-#define HS_MIN_SIZE 4
+#define FRT_HS_MIN_SIZE 4
+typedef struct FrtHashSetEntry {
+    void *elem;
+    struct FrtHashSetEntry *next;
+    struct FrtHashSetEntry *prev;
+} FrtHashSetEntry;
 
-typedef struct HashSet
+typedef struct FrtHashSet
 {
-    /* used internally to allocate space to elems */
-    int capa;
-
-    /* the number of elements in the HashSet */
+    /* the number of elements in the instance */
     int size;
 
-    /* the elements in the HashSet. The elements will be found in the order
-     * they were added and can be iterated over from 0 to .size */ 
-    void **elems;
+    /* the first element in the list of elements in the FrtHashSet. The elements
+     * will be listed in the order they were added and can be iterated over by
+     * following the ->next pointer */
+    FrtHashSetEntry *first;
 
-    /* HashTable used internally */
-    HashTable *ht;
+    /* the last element in the list of elements in the FrtHashSet. This is used
+     * internally to add elements to the list. */
+    FrtHashSetEntry *last;
 
-    /* Internal: Frees elements added to the HashSet. Should never be NULL */
-    void (*free_elem_i)(void *p);
-} HashSet;
+    /* Hash used internally */
+    FrtHash *ht;
+
+    /* Internal: Frees elements added to the FrtHashSet. Should never be NULL */
+    frt_free_ft free_elem_i;
+} FrtHashSet;
 
 /**
- * Create a new HashSet. The function will allocate a HashSet Struct setting
- * the functions used to hash the objects it will contain and the eq function.
- * This should be used for non-string types.
+ * Create a new FrtHashSet. The function will allocate a FrtHashSet Struct
+ * setting the functions used to hash the objects it will contain and the eq
+ * function. This should be used for non-string types.
  *
- * @param hash function to hash objects added to the HashSet
+ * @param hash function to hash objects added to the FrtHashSet
  * @param eq function to determine whether two items are equal
- * @param free_elem function used to free elements as added to the HashSet
- *   when the HashSet if destroyed or duplicate elements are added to the Set
- * @return a newly allocated HashSet structure
+ * @param free_elem function used to free elements as added to the FrtHashSet
+ *   when the FrtHashSet if destroyed or duplicate elements are added to the Set
+ * @return a newly allocated FrtHashSet structure
+ */
+extern FrtHashSet *frt_hs_new(frt_hash_ft hash_func,
+                                 frt_eq_ft eq_func,
+                                 frt_free_ft free_func);
+
+/**
+ * Create a new FrtHashSet specifically for strings. This will create a
+ * FrtHashSet as if you used frt_hs_new with the standard string hash and eq
+ * functions.
+ *
+ * @param free_elem function used to free elements as added to the FrtHashSet
+ *   when the FrtHashSet if destroyed or duplicate elements are added to the Set
+ * @return a newly allocated FrtHashSet structure
  */
-extern HashSet *hs_new(unsigned long (*hash)(const void *p),
-                       int (*eq)(const void *p1, const void *p2),
-                       void (*free_elem)(void *p));
+extern FrtHashSet *frt_hs_new_str(frt_free_ft free_func);
 
 /**
- * Create a new HashSet specifically for strings. This will create a HashSet
- * as if you used hs_new with the standard string hash and eq functions.
+ * Create a new FrtHashSet specifically for pointers. Note that the only way
+ * two pointers will be considered equal is if they have the same address. So
+ * you can add the string "key" twice if it is stored at two different
+ * addresses.
  *
- * @param free_elem function used to free elements as added to the HashSet
- *   when the HashSet if destroyed or duplicate elements are added to the Set
- * @return a newly allocated HashSet structure
+ * @param free_elem function used to free elements as added to the FrtHashSet
+ *   when the FrtHashSet if destroyed or duplicate elements are added to the Set
+ * @return a newly allocated FrtHashSet structure
  */
-extern HashSet *hs_new_str(void (*free_elem) (void *p));
+extern FrtHashSet *frt_hs_new_ptr(frt_free_ft free_func);
 
 /**
- * Free the memory allocated by the HashSet, but don't free the elements added
- * to the HashSet. If you'd like to free everything in the HashSet you should
- * use hs_destroy
+ * Free the memory allocated by the FrtHashSet, but don't free the elements added
+ * to the FrtHashSet. If you'd like to free everything in the FrtHashSet you should
+ * use frt_hs_destroy
  *
- * @param hs the HashSet to free
+ * @param hs the FrtHashSet to free
  */
-extern void hs_free(HashSet *self);
+extern void frt_hs_free(FrtHashSet *self);
 
 /**
- * Destroy the HashSet including all elements added to the HashSet. If you'd
- * like to free the memory allocated to the HashSet without touching the
- * elements in the HashSet then use hs_free
+ * Destroy the FrtHashSet including all elements added to the FrtHashSet. If you'd
+ * like to free the memory allocated to the FrtHashSet without touching the
+ * elements in the FrtHashSet then use frt_hs_free
  *
- * @param hs the HashSet to destroy
+ * @param hs the FrtHashSet to destroy
  */
-extern void hs_destroy(HashSet *self);
+extern void frt_hs_destroy(FrtHashSet *self);
 
 /**
  * WARNING: this function may destroy some elements if you add them to a
- * HashSet were equivalent elements already exist, depending on how free_elem
+ * FrtHashSet were equivalent elements already exist, depending on how free_elem
  * was set.
  *
- * Add the element to the HashSet whether or not it was already in the
- * HashSet.
+ * Add the element to the FrtHashSet whether or not it was already in the
+ * FrtHashSet.
  *
- * When a element is added to the HashTable where it already exists, free_elem
+ * When a element is added to the Hash where it already exists, free_elem
  * is called on it, ie the element you tried to add might get destroyed.
  *
- * @param hs the HashSet to add the element to
- * @param elem the element to add to the HashSet
+ * @param hs the FrtHashSet to add the element to
+ * @param elem the element to add to the FrtHashSet
  * @return one of three values;
  *   <pre>
- *     HASH_KEY_DOES_NOT_EXIST  the element was not already in the HashSet.
+ *     HASH_KEY_DOES_NOT_EXIST  the element was not already in the FrtHashSet.
  *                              This value is equal to 0 or false
  *     HASH_KEY_SAME            the element was identical (same memory
  *                              pointer) to an existing element so no freeing
  *                              was done
  *     HASH_KEY_EQUAL           the element was equal to an element already in
- *                              the HashSet so the new_elem was freed if
+ *                              the FrtHashSet so the new_elem was freed if
  *                              free_elem was set
  *   </pre>
  */
-extern int hs_add(HashSet *self, void *elem);
+extern FrtHashKeyStatus frt_hs_add(FrtHashSet *self, void *elem);
 
 /**
- * Add element to the HashSet. If the element already existed in the HashSet
+ * Add element to the FrtHashSet. If the element already existed in the FrtHashSet
  * and the new element was equal but not the same (same pointer/memory) then
  * don't add the element and return false, otherwise return true.
  *
- * @param hs the HashSet to add the element to
- * @param elem the element to add to the HashSet
+ * @param hs the FrtHashSet to add the element to
+ * @param elem the element to add to the FrtHashSet
  * @return true if the element was successfully added or false otherwise
  */
-extern int hs_add_safe(HashSet *self, void *elem);
+extern int frt_hs_add_safe(FrtHashSet *self, void *elem);
 
 /**
- * Delete the element from the HashSet. Returns true if the item was
+ * Delete the element from the FrtHashSet. Returns true if the item was
  * successfully deleted or false if the element never existed.
  *
- * @param hs the HashSet to delete from
+ * @param hs the FrtHashSet to delete from
  * @param elem the element to delete
  * @return true if the element was deleted or false if the element never
  *   existed
  */
-extern int hs_del(HashSet *self, void *elem);
+extern int frt_hs_del(FrtHashSet *self, const void *elem);
 
 /**
- * Remove an item from the HashSet without actually freeing the item. This
+ * Remove an item from the FrtHashSet without actually freeing the item. This
  * function should return the item itself so that it can be freed later if
  * necessary.
  *
- * @param hs the HashSet to remove the element from.
+ * @param hs the FrtHashSet to remove the element from.
  * @param elem the element to remove
  * @param the element that was removed or NULL otherwise
  */
-extern void *hs_rem(HashSet *self, void *elem);
+extern void *frt_hs_rem(FrtHashSet *self, const void *elem);
 
 /**
  * Check if the element exists and return the appropriate value described
  * bellow.
  *
- * @param hs the HashSet to check in
+ * @param hs the FrtHashSet to check in
  * @param elem the element to check for
  * @return one of the following values
  * <pre>
- *     HASH_KEY_DOES_NOT_EXIST  the element was not already in the HashSet.
+ *     HASH_KEY_DOES_NOT_EXIST  the element was not already in the FrtHashSet.
  *                              This value is equal to 0 or false
  *     HASH_KEY_SAME            the element was identical (same memory
  *                              pointer) to an existing element so no freeing
  *                              was done
  *     HASH_KEY_EQUAL           the element was equal to an element already in
- *                              the HashSet so the new_elem was freed if
+ *                              the FrtHashSet so the new_elem was freed if
  *                              free_elem was set
  *   </pre>
  */
-extern int hs_exists(HashSet *self, void *elem);
+extern FrtHashKeyStatus frt_hs_exists(FrtHashSet *self, const void *elem);
 
 /**
- * Merge two HashSets. When a merge is done the merger (self) HashTable is
+ * Merge two HashSets. When a merge is done the merger (self) Hash is
  * returned and the mergee is destroyed. All elements from mergee that were
  * not found in merger (self) will be added to self, otherwise they will be
  * destroyed.
- * 
- * @param self the HashSet to merge into
+ *
+ * @param self the FrtHashSet to merge into
  * @param other HastSet to be merged into self
- * @return the merged HashSet
+ * @return the merged FrtHashSet
  */
-extern HashSet *hs_merge(HashSet *self, HashSet *other);
+extern FrtHashSet *frt_hs_merge(FrtHashSet *self, FrtHashSet *other);
 
-/** 
+/**
  * Return the original version of +elem+. So if you allocate two elements
- * which are equal and add the first to the HashSet, calling this function
- * with the second element will return the first element from the HashSet.
+ * which are equal and add the first to the FrtHashSet, calling this function
+ * with the second element will return the first element from the FrtHashSet.
  */
-extern void *hs_orig(HashSet *self, void *elem);
+extern void *frt_hs_orig(FrtHashSet *self, const void *elem);
 
 /**
- * Clear all elements from the HashSet. If free_elem was set then use it to
+ * Clear all elements from the FrtHashSet. If free_elem was set then use it to
  * free all elements as they are cleared. After the method is called, the
  * HashSets size will be 0.
  *
- * @param self the HashSet to clear
+ * @param self the FrtHashSet to clear
  */
-extern void hs_clear(HashSet *self);
-
-/* TODO: finish these functions.
-int hs_osf(HashSet *hs, void *elem);
-HashSet hs_or(HashSet *hs1, HashSet *h2);
-HashSet hs_excl_or(HashSet *hs1, HashSet *h2);
-HashSet hs_and(HashSet *hs1, HashSet *h2);
-HashSet hs_mask(HashSet *hs1, HashSet *h2);
+extern void frt_hs_clear(FrtHashSet *self);
+
+/* TODO: finish implementing these functions FrtHashSet
+int hs_osf(FrtHashSet *hs, void *elem);
+FrtHashSet hs_or(FrtHashSet *hs1, FrtHashSet *h2);
+FrtHashSet hs_excl_or(FrtHashSet *hs1, FrtHashSet *h2);
+FrtHashSet hs_and(FrtHashSet *hs1, FrtHashSet *h2);
+FrtHashSet hs_mask(FrtHashSet *hs1, FrtHashSet *h2);
 */
 
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
 #endif