isomorfeus-ferret 0.12.0

data/ext/isomorfeus_ferret_ext/frt_priorityqueue.c

@@ -0,0 +1,147 @@
+#include <string.h>
+#include "frt_priorityqueue.h"
+
+#define START_CAPA 127
+
+FrtPriorityQueue *frt_pq_new(int capa, frt_lt_ft less_than, frt_free_ft free_elem)
+{
+    FrtPriorityQueue *pq = FRT_ALLOC(FrtPriorityQueue);
+    pq->size = 0;
+    pq->capa = capa;
+    pq->mem_capa = (START_CAPA > capa ? capa : START_CAPA) + 1;
+    pq->heap = FRT_ALLOC_N(void *, pq->mem_capa);
+    memset(pq->heap, 0, (sizeof(void *))*(pq->mem_capa));
+    pq->less_than_i = less_than;
+
+    /* need to set this yourself if you want to change it */
+    pq->free_elem_i = free_elem ? free_elem : &frt_dummy_free;
+    return pq;
+}
+
+FrtPriorityQueue *frt_pq_clone(FrtPriorityQueue *pq)
+{
+    FrtPriorityQueue *new_pq = FRT_ALLOC(FrtPriorityQueue);
+    memcpy(new_pq, pq, sizeof(FrtPriorityQueue));
+    new_pq->heap = FRT_ALLOC_N(void *, new_pq->mem_capa);
+    memcpy(new_pq->heap, pq->heap, sizeof(void *) * (new_pq->size + 1));
+
+    return new_pq;
+}
+
+void frt_pq_clear(FrtPriorityQueue *pq)
+{
+    int i;
+    for (i = 1; i <= pq->size; i++) {
+        pq->free_elem_i(pq->heap[i]);
+        pq->heap[i] = NULL;
+    }
+    pq->size = 0;
+}
+
+void frt_pq_free(FrtPriorityQueue *pq)
+{
+    free(pq->heap);
+    free(pq);
+}
+
+void frt_pq_destroy(FrtPriorityQueue *pq)
+{
+    frt_pq_clear(pq);
+    frt_pq_free(pq);
+}
+
+/**
+ * This method is used internally by frt_pq_push. It is similar to frt_pq_down except
+ * that where frt_pq_down reorders the elements from the top, pq_up reorders from
+ * the bottom.
+ *
+ * @param pq the PriorityQueue to reorder
+ */
+static void frt_pq_up(FrtPriorityQueue *pq)
+{
+    void **heap = pq->heap;
+    void *node;
+    int i = pq->size;
+    int j = i >> 1;
+
+    node = heap[i];
+
+    while ((j > 0) && pq->less_than_i(node, heap[j])) {
+        heap[i] = heap[j];
+        i = j;
+        j = j >> 1;
+    }
+    heap[i] = node;
+}
+
+void frt_pq_down(FrtPriorityQueue *pq)
+{
+    register int i = 1;
+    register int j = 2;         /* i << 1; */
+    register int k = 3;         /* j + 1;  */
+    register int size = pq->size;
+    void **heap = pq->heap;
+    void *node = heap[i];       /* save top node */
+
+    if ((k <= size) && (pq->less_than_i(heap[k], heap[j]))) {
+        j = k;
+    }
+
+    while ((j <= size) && pq->less_than_i(heap[j], node)) {
+        heap[i] = heap[j];      /* shift up child */
+        i = j;
+        j = i << 1;
+        k = j + 1;
+        if ((k <= size) && pq->less_than_i(heap[k], heap[j])) {
+            j = k;
+        }
+    }
+    heap[i] = node;
+}
+
+void frt_pq_push(FrtPriorityQueue *pq, void *elem)
+{
+    pq->size++;
+    if (pq->size >= pq->mem_capa) {
+        pq->mem_capa <<= 1;
+        FRT_REALLOC_N(pq->heap, void *, pq->mem_capa);
+    }
+    pq->heap[pq->size] = elem;
+    frt_pq_up(pq);
+}
+
+FrtPriorityQueueInsertEnum frt_pq_insert(FrtPriorityQueue *pq, void *elem)
+{
+    if (pq->size < pq->capa) {
+        frt_pq_push(pq, elem);
+        return FRT_PQ_ADDED;
+    }
+
+    if (pq->size > 0 && pq->less_than_i(pq->heap[1], elem)) {
+        pq->free_elem_i(pq->heap[1]);
+        pq->heap[1] = elem;
+        frt_pq_down(pq);
+        return FRT_PQ_INSERTED;
+    }
+
+    pq->free_elem_i(elem);
+    return FRT_PQ_DROPPED;
+}
+
+void *frt_pq_top(FrtPriorityQueue *pq)
+{
+    return pq->size ? pq->heap[1] : NULL;
+}
+
+void *frt_pq_pop(FrtPriorityQueue *pq)
+{
+    if (pq->size > 0) {
+        void *result = pq->heap[1];       /* save first value */
+        pq->heap[1] = pq->heap[pq->size]; /* move last to first */
+        pq->heap[pq->size] = NULL;
+        pq->size--;
+        frt_pq_down(pq);                      /* adjust heap */
+        return result;
+    }
+    return NULL;
+}

data/ext/isomorfeus_ferret_ext/frt_priorityqueue.h

@@ -0,0 +1,147 @@
+#ifndef FRT_PRIORITYQUEUE_H
+#define FRT_PRIORITYQUEUE_H
+
+#include "frt_global.h"
+
+typedef bool (*frt_lt_ft)(const void *p1, const void *p2);
+
+/**
+ * A PriorityQueue has a fixed size and contains a less_than function and a
+ * free_elem function specific to the data type to be stored in the queue.
+ */
+typedef struct FrtPriorityQueue
+{
+    int size;
+    int capa;
+    int mem_capa;
+    void **heap;
+    frt_lt_ft less_than_i;
+    frt_free_ft free_elem_i;
+} FrtPriorityQueue;
+
+/**
+ * Create a new PriorityQueue setting the less_than and free_elem for this
+ * specific PriorityQueue.
+ *
+ * @param capa the capacity of the PriorityQueue. As more than the capacity is
+ *   added to the queue the least valued elements drop off the bottom.
+ * @param less_than the function to determine whether one value is less than
+ *   another for this particular PriorityQueue
+ * @param free_elem the function to free the elements in the PriorityQueue
+ *   when it is destroyed or there is insertion overflow
+ * @return a newly allocated PriorityQueue
+ */
+extern FrtPriorityQueue *frt_pq_new(int capa,
+                                       frt_lt_ft less_than,
+                                       frt_free_ft free_elem);
+
+/**
+ * Allocate a clone of the PriorityQueue. This can be used if you want to scan
+ * through all elements of the PriorityQueue but you don't want to have to
+ * remove the all and add them all again.
+ *
+ * @param pq the priority queue to clone
+ * @return a clone of the original priority queue
+ */
+extern FrtPriorityQueue *frt_pq_clone(FrtPriorityQueue *pq);
+
+/**
+ * Clear all elements from the PriorityQueue and reset the size to 0. When
+ * the elements are removed from the PriorityQueue, free_elem is used to free
+ * them, unless it was set to NULL in which case nothing will happen to them.
+ *
+ * @param self the PriorityQueue to clear
+ */
+extern void frt_pq_clear(FrtPriorityQueue *self);
+
+/**
+ * Free the memory allocated to the PriorityQueue. This function does nothing
+ * to the elements in the PriorityQueue itself. To destroy them also, use
+ * frt_pq_destroy.
+ *
+ * @param self the PriorityQueue to free
+ */
+extern void frt_pq_free(FrtPriorityQueue *self);
+
+/**
+ * Destroy the PriorityQueue, freeing all memory allocated to it and also
+ * destroying all the elements contained by it. This method is equivalent to
+ * calling frt_pq_clear followed by frt_pq_free.
+ *
+ * @param the PriorityQueue to destroy
+ */
+extern void frt_pq_destroy(FrtPriorityQueue *self);
+
+/**
+ * Reorder the PriorityQueue after the top element has been modified. This
+ * method is used especially when the PriorityQueue contains a queue of
+ * iterators. When the top iterator is incremented you should call this
+ * method.
+ *
+ * @param self the PriorityQueue to reorder
+ */
+extern void frt_pq_down(FrtPriorityQueue *self);
+
+/**
+ * Add another element to the PriorityQueue. This method should only be used
+ * when the PriorityQueue has enough space allocated to hold all elements
+ * added. If there is a chance that you will add more than the amount you have
+ * allocated then you should use frt_pq_insert. frt_pq_insert will handle insertion
+ * overflow.
+ *
+ * @param self the PriorityQueue to add the element to
+ * @param elem the element to add to the PriorityQueue
+ */
+extern void frt_pq_push(FrtPriorityQueue *self, void *elem);
+
+typedef enum {
+    FRT_PQ_DROPPED = 0,
+    FRT_PQ_ADDED,
+    FRT_PQ_INSERTED
+} FrtPriorityQueueInsertEnum;
+
+/**
+ * Add another element to the PriorityQueue. Unlike frt_pq_push, this method
+ * handles insertion overflow. That is, when you insert more elements than the
+ * capacity of the PriorityQueue, the elements are dropped off the bottom and
+ * freed using the free_elem function.
+ *
+ * @param self the PriorityQueue to add the element to
+ * @param elem the element to add to the PriorityQueue
+ * @returns one of three values;
+ *   <pre>
+ *     0 == FRT_PQ_DROPPED  the element was too small (according to the less_than
+ *                          function) so it was destroyed
+ *     1 == FRT_PQ_ADDED    the element was successfully added
+ *     2 == FRT_PQ_INSERTED the element was successfully added after another
+ *                          element was dropped and destroyed
+ *   </pre>
+ */
+extern FrtPriorityQueueInsertEnum frt_pq_insert(FrtPriorityQueue *self,
+                                                   void *elem);
+
+/**
+ * Get the top element in the PriorityQueue.
+ *
+ * @param self the PriorityQueue to get the top from
+ * @return the top element in the PriorityQueue
+ */
+extern void *frt_pq_top(FrtPriorityQueue *self);
+
+/**
+ * Remove and return the top element in the PriorityQueue.
+ *
+ * @param self the PriorityQueue to get the top from
+ * @return the top element in the PriorityQueue
+ */
+extern void *frt_pq_pop(FrtPriorityQueue *self);
+
+/**
+ * Return true if the PriorityQueue is full.
+ *
+ * @param self the PriorityQueue to test
+ * @return true if the PriorityQueue is full.
+ */
+#define frt_pq_full(pq) ((pq)->size == (pq)->capa)
+
+#endif