fast_trie 0.3.5

data/ext/trie/tail.h

@@ -0,0 +1,207 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * tail.h - trie tail for keeping suffixes
+ * Created: 2006-08-12
+ * Author:  Theppitak Karoonboonyanan <thep@linux.thai.net>
+ */
+
+#ifndef __TAIL_H
+#define __TAIL_H
+
+#include "triedefs.h"
+
+/**
+ * @file tail.h
+ * @brief trie tail for keeping suffixes
+ */
+
+/**
+ * @brief Double-array structure type
+ */
+typedef struct _Tail  Tail;
+
+/**
+ * @brief Create a new tail object
+ *
+ * Create a new empty tail object.
+ */
+Tail *   tail_new ();
+
+/**
+ * @brief Read tail data from file
+ *
+ * @param file : the file to read
+ *
+ * @return a pointer to the openned tail data, NULL on failure
+ *
+ * Read tail data from the opened file, starting from the current
+ * file pointer until the end of tail data block. On return, the
+ * file pointer is left at the position after the read block.
+ */
+Tail *   tail_read (FILE *file);
+
+/**
+ * @brief Free tail data
+ *
+ * @param t : the tail data
+ *
+ * @return 0 on success, non-zero on failure
+ *
+ * Free the given tail data.
+ */
+void     tail_free (Tail *t);
+
+/**
+ * @brief Write tail data
+ *
+ * @param t     : the tail data
+ * @param file  : the file to write to
+ *
+ * @return 0 on success, non-zero on failure
+ *
+ * Write tail data to the given @a file, starting from the current file
+ * pointer. On return, the file pointer is left after the tail data block.
+ */
+int      tail_write (const Tail *t, FILE *file);
+
+
+/**
+ * @brief Get suffix
+ *
+ * @param t     : the tail data
+ * @param index : the index of the suffix
+ *
+ * @return an allocated string of the indexed suffix.
+ *
+ * Get suffix from tail with given @a index. The returned string is allocated.
+ * The caller should free it with free().
+ */
+const TrieChar *    tail_get_suffix (const Tail *t, TrieIndex index);
+
+/**
+ * @brief Set suffix of existing entry
+ *
+ * @param t      : the tail data
+ * @param index  : the index of the suffix
+ * @param suffix : the new suffix
+ *
+ * Set suffix of existing entry of given @a index in tail.
+ */
+Bool     tail_set_suffix (Tail *t, TrieIndex index, const TrieChar *suffix);
+
+/**
+ * @brief Add a new suffix
+ *
+ * @param t      : the tail data
+ * @param suffix : the new suffix
+ *
+ * @return the index of the newly added suffix.
+ *
+ * Add a new suffix entry to tail.
+ */
+TrieIndex tail_add_suffix (Tail *t, const TrieChar *suffix);
+
+/**
+ * @brief Get data associated to suffix entry
+ *
+ * @param t      : the tail data
+ * @param index  : the index of the suffix
+ *
+ * @return the data associated to the suffix entry
+ *
+ * Get data associated to suffix entry @a index in tail data.
+ */
+TrieData tail_get_data (const Tail *t, TrieIndex index);
+
+/**
+ * @brief Set data associated to suffix entry
+ *
+ * @param t      : the tail data
+ * @param index  : the index of the suffix
+ * @param data   : the data to set
+ *
+ * @return boolean indicating success
+ *
+ * Set data associated to suffix entry @a index in tail data.
+ */
+Bool     tail_set_data (Tail *t, TrieIndex index, TrieData data);
+
+/**
+ * @brief Delete suffix entry
+ *
+ * @param t      : the tail data
+ * @param index  : the index of the suffix to delete
+ *
+ * Delete suffix entry from the tail data.
+ */
+void     tail_delete (Tail *t, TrieIndex index);
+
+/**
+ * @brief Walk in tail with a string
+ *
+ * @param t          : the tail data
+ * @param s          : the tail data index
+ * @param suffix_idx : pointer to current character index in suffix
+ * @param str        : the string to use in walking
+ * @param len        : total characters in @a str to walk
+ *
+ * @return total number of characters successfully walked
+ *
+ * Walk in the tail data @a t at entry @a s, from given character position
+ * @a *suffix_idx, using @a len characters of given string @a str. On return,
+ * @a *suffix_idx is updated to the position after the last successful walk,
+ * and the function returns the total number of character succesfully walked.
+ */
+int      tail_walk_str  (const Tail      *t,
+                         TrieIndex        s,
+                         short           *suffix_idx,
+                         const TrieChar  *str,
+                         int              len);
+
+/**
+ * @brief Walk in tail with a character
+ *
+ * @param t          : the tail data
+ * @param s          : the tail data index
+ * @param suffix_idx : pointer to current character index in suffix
+ * @param c          : the character to use in walking
+ *
+ * @return boolean indicating success
+ *
+ * Walk in the tail data @a t at entry @a s, from given character position
+ * @a *suffix_idx, using given character @a c. If the walk is successful,
+ * it returns TRUE, and @a *suffix_idx is updated to the next character.
+ * Otherwise, it returns FALSE, and @a *suffix_idx is left unchanged.
+ */
+Bool     tail_walk_char (const Tail      *t,
+                         TrieIndex        s,
+                         short           *suffix_idx,
+                         TrieChar         c);
+
+/**
+ * @brief Test walkability in tail with a character
+ *
+ * @param t          : the tail data
+ * @param s          : the tail data index
+ * @param suffix_idx : current character index in suffix
+ * @param c          : the character to test walkability
+ *
+ * @return boolean indicating walkability
+ *
+ * Test if the character @a c can be used to walk from given character 
+ * position @a suffix_idx of entry @a s of the tail data @a t.
+ */
+/*
+Bool     tail_is_walkable_char (Tail            *t,
+                                TrieIndex        s,
+                                short            suffix_idx,
+                                const TrieChar   c);
+*/
+#define  tail_is_walkable_char(t,s,suffix_idx,c) \
+    (tail_get_suffix ((t), (s)) [suffix_idx] == (c))
+
+#endif  /* __TAIL_H */
+
+/*
+vi:ts=4:ai:expandtab
+*/

data/ext/trie/trie-private.c

@@ -0,0 +1,299 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "darray.h"
+#include "tail.h"
+#include "trie.h"
+
+Trie* trie_new() {
+	Trie *trie = (Trie*) malloc(sizeof(Trie));
+	trie->da = da_new();
+	trie->tail = tail_new();
+	return trie;
+}
+
+void trie_free(Trie *trie) {
+	da_free(trie->da);
+	tail_free(trie->tail);
+	free(trie);
+}
+
+static Bool trie_branch_in_branch (Trie *trie, TrieIndex sep_node, const TrieChar *suffix, TrieData data) {
+    TrieIndex new_da, new_tail;
+
+    new_da = da_insert_branch (trie->da, sep_node, *suffix);
+    if (TRIE_INDEX_ERROR == new_da)
+        return FALSE;
+
+    if ('\0' != *suffix)
+        ++suffix;
+
+    new_tail = tail_add_suffix (trie->tail, suffix);
+    tail_set_data (trie->tail, new_tail, data);
+    trie_da_set_tail_index (trie->da, new_da, new_tail);
+
+    // trie->is_dirty = TRUE;
+    return TRUE;
+}
+
+static Bool trie_branch_in_tail(Trie *trie, TrieIndex sep_node, const TrieChar *suffix, TrieData data) {
+    TrieIndex old_tail, old_da, s;
+    const TrieChar *old_suffix, *p;
+
+    /* adjust separate point in old path */
+    old_tail = trie_da_get_tail_index (trie->da, sep_node);
+    old_suffix = tail_get_suffix (trie->tail, old_tail);
+    if (!old_suffix)
+        return FALSE;
+
+    for (p = old_suffix, s = sep_node; *p == *suffix; p++, suffix++) {
+        TrieIndex t = da_insert_branch (trie->da, s, *p);
+        if (TRIE_INDEX_ERROR == t)
+            goto fail;
+        s = t;
+    }
+
+    old_da = da_insert_branch (trie->da, s, *p);
+    if (TRIE_INDEX_ERROR == old_da)
+        goto fail;
+
+    if ('\0' != *p)
+        ++p;
+    tail_set_suffix (trie->tail, old_tail, p);
+    trie_da_set_tail_index (trie->da, old_da, old_tail);
+
+    /* insert the new branch at the new separate point */
+    return trie_branch_in_branch (trie, s, suffix, data);
+
+fail:
+    /* failed, undo previous insertions and return error */
+    da_prune_upto (trie->da, sep_node, s);
+    trie_da_set_tail_index (trie->da, sep_node, old_tail);
+    return FALSE;
+}
+
+Bool trie_store (Trie *trie, const TrieChar *key, TrieData data) {
+    TrieIndex        s, t;
+    short            suffix_idx;
+    const TrieChar *p, *sep;
+	size_t len;
+
+    /* walk through branches */
+    s = da_get_root (trie->da);
+    for (p = key; !trie_da_is_separate (trie->da, s); p++) {
+        if (!da_walk (trie->da, &s, *p))
+            return trie_branch_in_branch (trie, s, p, data);
+        if (0 == *p)
+            break;
+    }
+
+    /* walk through tail */
+    sep = p;
+    t = trie_da_get_tail_index (trie->da, s);
+    suffix_idx = 0;
+    len = strlen ((const char *) p) + 1;    /* including null-terminator */
+    if (tail_walk_str (trie->tail, t, &suffix_idx, p, len) != len)
+        return trie_branch_in_tail (trie, s, p, data);
+
+    /* duplicated key, overwrite val */
+    tail_set_data (trie->tail, t, data);
+    // trie->is_dirty = TRUE;
+    return TRUE;
+}
+
+
+Bool trie_has_key (const Trie *trie, const TrieChar *key) {
+    TrieIndex        s;
+    short            suffix_idx;
+    const TrieChar *p;
+
+    /* walk through branches */
+    s = da_get_root (trie->da);
+    for (p = key; !trie_da_is_separate (trie->da, s); p++) {
+        if (!da_walk (trie->da, &s, *p))
+            return FALSE;
+        if (0 == *p)
+            break;
+    }
+
+    /* walk through tail */
+    s = trie_da_get_tail_index (trie->da, s);
+    suffix_idx = 0;
+    for ( ; ; p++) {
+        if (!tail_walk_char (trie->tail, s, &suffix_idx, *p))
+            return FALSE;
+        if (0 == *p)
+            break;
+    }
+
+    return TRUE;
+}
+
+
+Bool trie_retrieve (const Trie *trie, const TrieChar *key, TrieData *o_data) {
+    TrieIndex        s;
+    short            suffix_idx;
+    const TrieChar *p;
+
+    /* walk through branches */
+    s = da_get_root (trie->da);
+    for (p = key; !trie_da_is_separate (trie->da, s); p++) {
+        if (!da_walk (trie->da, &s, *p))
+            return FALSE;
+        if (0 == *p)
+            break;
+    }
+
+    /* walk through tail */
+    s = trie_da_get_tail_index (trie->da, s);
+    suffix_idx = 0;
+    for ( ; ; p++) {
+        if (!tail_walk_char (trie->tail, s, &suffix_idx, *p))
+            return FALSE;
+        if (0 == *p)
+            break;
+    }
+
+    /* found, set the val and return */
+    if (o_data)
+        *o_data = tail_get_data (trie->tail, s);
+    return TRUE;
+}
+
+Bool trie_delete (Trie *trie, const TrieChar *key) {
+    TrieIndex        s, t;
+    short            suffix_idx;
+    const TrieChar *p;
+
+    /* walk through branches */
+    s = da_get_root (trie->da);
+    for (p = key; !trie_da_is_separate (trie->da, s); p++) {
+        if (!da_walk (trie->da, &s, *p))
+            return FALSE;
+        if (0 == *p)
+            break;
+    }
+
+    /* walk through tail */
+    t = trie_da_get_tail_index (trie->da, s);
+    suffix_idx = 0;
+    for ( ; ; p++) {
+        if (!tail_walk_char (trie->tail, t, &suffix_idx, *p))
+            return FALSE;
+        if (0 == *p)
+            break;
+    }
+
+    tail_delete (trie->tail, t);
+    da_set_base (trie->da, s, TRIE_INDEX_ERROR);
+    da_prune (trie->da, s);
+
+    //trie->is_dirty = TRUE;
+    return TRUE;
+}
+
+/*-------------------------------*
+ *   STEPWISE QUERY OPERATIONS   *
+ *-------------------------------*/
+
+TrieState * trie_root (const Trie *trie) {
+    return trie_state_new (trie, da_get_root (trie->da), 0, FALSE);
+}
+
+/*----------------*
+ *   TRIE STATE   *
+ *----------------*/
+
+static TrieState * trie_state_new (const Trie *trie, TrieIndex index, short suffix_idx, short is_suffix) {
+    TrieState *s;
+
+    s = (TrieState *) malloc (sizeof (TrieState));
+    if (!s)
+        return NULL;
+
+    s->trie       = trie;
+    s->index      = index;
+    s->suffix_idx = suffix_idx;
+    s->is_suffix  = is_suffix;
+
+    return s;
+}
+
+TrieState * trie_state_clone (const TrieState *s) {
+    return trie_state_new (s->trie, s->index, s->suffix_idx, s->is_suffix);
+}
+
+void trie_state_free (TrieState *s) {
+    free (s);
+}
+
+void trie_state_rewind (TrieState *s) {
+    s->index      = da_get_root (s->trie->da);
+    s->is_suffix  = FALSE;
+}
+
+Bool trie_state_walk (TrieState *s, TrieChar c) {
+    if (!s->is_suffix) {
+        Bool ret;
+
+        ret = da_walk (s->trie->da, &s->index, c);
+
+        if (ret && trie_da_is_separate (s->trie->da, s->index)) {
+            s->index = trie_da_get_tail_index (s->trie->da, s->index);
+            s->suffix_idx = 0;
+            s->is_suffix = TRUE;
+        }
+
+        return ret;
+    } else {
+        return tail_walk_char (s->trie->tail, s->index, &s->suffix_idx, c);
+    }
+}
+
+Bool trie_state_is_walkable (const TrieState *s, TrieChar c) {
+    if (!s->is_suffix)
+        return da_is_walkable (s->trie->da, s->index, c);
+    else 
+        return tail_is_walkable_char (s->trie->tail, s->index, s->suffix_idx, c);
+}
+
+Bool trie_state_is_leaf (const TrieState *s) {
+    return s->is_suffix && trie_state_is_terminal (s);
+}
+
+TrieData trie_state_get_data (const TrieState *s) {
+    return s->is_suffix ? tail_get_data (s->trie->tail, s->index) : TRIE_DATA_ERROR;
+}
+
+int main(void) {
+	Bool res;
+	TrieData *data = (TrieData*)malloc(sizeof(TrieData));
+	Trie *trie = trie_new();
+
+
+	trie_store(trie, (const TrieChar*)"hello", 1);
+	trie_store(trie, (const TrieChar*)"he", 4);
+	trie_store(trie, (const TrieChar*)"hel", 3);
+	trie_store(trie, (const TrieChar*)"h", 5);
+	trie_store(trie, (const TrieChar*)"hell", 2);
+
+
+	res = trie_retrieve(trie, (const TrieChar*)"hello", data);
+	printf(res ? "Win!\n" : "Fail!\n");
+
+	res = trie_retrieve(trie, (const TrieChar*)"hell", data);
+	printf(res ? "Win!\n" : "Fail!\n");
+
+	res = trie_retrieve(trie, (const TrieChar*)"hel", data);
+	printf(res ? "Win!\n" : "Fail!\n");
+
+	res = trie_retrieve(trie, (const TrieChar*)"he", data);
+	printf(res ? "Win!\n" : "Fail!\n");
+
+	res = trie_retrieve(trie, (const TrieChar*)"h", data);
+	printf(res ? "Win!\n" : "Fail!\n");
+
+
+	trie_free(trie);
+	return 0;
+}