tyler-trie 0.1.0

data/ext/libdatrie/datrie/sb-trie.c

@@ -0,0 +1,331 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * sb-trie.c - Single-byte domain trie front end
+ * Created: 2006-08-19
+ * Author:  Theppitak Karoonboonyanan <thep@linux.thai.net>
+ */
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "sb-trie.h"
+#include "trie.h"
+#include "alpha-map.h"
+
+/*------------------------*
+ *   INTERNAL FUNCTIONS   *
+ *------------------------*/
+static TrieChar * sb_map_char_to_alphabet_str (const AlphaMap   *alpha_map,
+                                               const SBChar     *str);
+
+static SBChar * sb_map_alphabet_to_char_str (const AlphaMap     *alpha_map,
+                                             const TrieChar     *str);
+
+/* ==================== BEGIN IMPLEMENTATION PART ====================  */
+
+/*----------------------------------------*
+ *   INTERNAL FUNCTIONS IMPLEMENTATIONS   *
+ *----------------------------------------*/
+
+static TrieChar *
+sb_map_char_to_alphabet_str (const AlphaMap *alpha_map, const SBChar *str)
+{
+    TrieChar   *alphabet_str, *p;
+
+    alphabet_str = (TrieChar *) malloc (strlen (str) + 1);
+    for (p = alphabet_str; *str; p++, str++)
+        *p = alpha_map_char_to_alphabet (alpha_map, *str);
+    *p = '\0';
+
+    return alphabet_str;
+}
+
+static SBChar *
+sb_map_alphabet_to_char_str (const AlphaMap *alpha_map, const TrieChar *str)
+{
+    SBChar     *sb_str, *p;
+
+    sb_str = (SBChar *) malloc (strlen ((const char *)str) + 1);
+    for (p = sb_str; *str; p++, str++)
+        *p = (SBChar) alpha_map_alphabet_to_char (alpha_map, *str);
+    *p = '\0';
+
+    return sb_str;
+}
+
+/*------------------------------*
+ *    PRIVATE DATA DEFINITONS   *
+ *------------------------------*/
+struct _SBTrie {
+    Trie       *trie;
+    AlphaMap   *alpha_map;
+};
+
+struct _SBTrieState {
+    SBTrie         *sb_trie;
+    TrieState      *trie_state;
+};
+
+/*-----------------------------*
+ *    METHODS IMPLEMENTAIONS   *
+ *-----------------------------*/
+
+/*-----------------------*
+ *   GENERAL FUNCTIONS   *
+ *-----------------------*/
+
+SBTrie *
+sb_trie_open (const char *path, const char *name, TrieIOMode mode)
+{
+    SBTrie *sb_trie;
+
+    sb_trie = (SBTrie *) malloc (sizeof (SBTrie));
+    if (!sb_trie)
+        return NULL;
+
+    sb_trie->trie = trie_open (path, name, mode);
+    if (!sb_trie->trie)
+        goto exit1;
+
+    sb_trie->alpha_map = alpha_map_open (path, name, ".sbm");
+    if (!sb_trie->alpha_map)
+        goto exit2;
+
+    return sb_trie;
+
+exit2:
+    trie_close (sb_trie->trie);
+exit1:
+    free (sb_trie);
+    return NULL;
+}
+
+int
+sb_trie_close (SBTrie *sb_trie)
+{
+    if (!sb_trie)
+        return -1;
+
+    alpha_map_free (sb_trie->alpha_map);
+    return trie_close (sb_trie->trie);
+}
+
+int
+sb_trie_save (SBTrie *sb_trie)
+{
+    if (!sb_trie)
+        return -1;
+
+    return trie_save (sb_trie->trie);
+}
+
+
+/*------------------------------*
+ *   GENERAL QUERY OPERATIONS   *
+ *------------------------------*/
+
+Bool
+sb_trie_retrieve (SBTrie *sb_trie, const SBChar *key, TrieData *o_data)
+{
+    TrieChar   *trie_key;
+    Bool        ret;
+
+    if (!sb_trie)
+        return FALSE;
+
+    trie_key = sb_map_char_to_alphabet_str (sb_trie->alpha_map, key);
+    ret = trie_retrieve (sb_trie->trie, trie_key, o_data);
+    free (trie_key);
+
+    return ret;
+}
+
+Bool
+sb_trie_store (SBTrie *sb_trie, const SBChar *key, TrieData data)
+{
+    TrieChar   *trie_key;
+    Bool        ret;
+
+    if (!sb_trie)
+        return FALSE;
+
+    trie_key = sb_map_char_to_alphabet_str (sb_trie->alpha_map, key);
+    ret = trie_store (sb_trie->trie, trie_key, data);
+    free (trie_key);
+
+    return ret;
+}
+
+Bool
+sb_trie_delete (SBTrie *sb_trie, const SBChar *key)
+{
+    TrieChar   *trie_key;
+    Bool        ret;
+
+    if (!sb_trie)
+        return FALSE;
+
+    trie_key = sb_map_char_to_alphabet_str (sb_trie->alpha_map, key);
+    ret = trie_delete (sb_trie->trie, trie_key);
+    free (trie_key);
+
+    return ret;
+}
+
+typedef struct {
+    SBTrie         *sb_trie;
+    SBTrieEnumFunc  enum_func;
+    void           *user_data;
+} _SBTrieEnumData;
+
+static Bool
+sb_trie_enum_func (const TrieChar *key, TrieData key_data, void *user_data)
+{
+    _SBTrieEnumData *enum_data;
+    SBChar          *sb_key;
+    Bool             ret;
+
+    enum_data = (_SBTrieEnumData *) user_data;
+
+    sb_key = sb_map_alphabet_to_char_str (enum_data->sb_trie->alpha_map, key);
+    ret = (*enum_data->enum_func) (sb_key, key_data, enum_data->user_data);
+    free (sb_key);
+
+    return ret;
+}
+
+Bool
+sb_trie_enumerate (SBTrie         *sb_trie,
+                   SBTrieEnumFunc  enum_func,
+                   void           *user_data)
+{
+    _SBTrieEnumData enum_data;
+
+    if (!sb_trie)
+        return FALSE;
+
+    enum_data.sb_trie   = sb_trie;
+    enum_data.enum_func = enum_func;
+    enum_data.user_data = user_data;
+
+    return trie_enumerate (sb_trie->trie, sb_trie_enum_func, &enum_data);
+}
+
+
+/*-------------------------------*
+ *   STEPWISE QUERY OPERATIONS   *
+ *-------------------------------*/
+
+SBTrieState *
+sb_trie_root (SBTrie *sb_trie)
+{
+    SBTrieState *sb_state;
+
+    if (!sb_trie)
+        return NULL;
+
+    sb_state = (SBTrieState *) malloc (sizeof (SBTrieState));
+    if (!sb_state)
+        return NULL;
+
+    sb_state->sb_trie    = sb_trie;
+    sb_state->trie_state = trie_root (sb_trie->trie);
+
+    return sb_state;
+}
+
+
+/*----------------*
+ *   TRIE STATE   *
+ *----------------*/
+
+SBTrieState *
+sb_trie_state_clone (const SBTrieState *s)
+{
+    SBTrieState *new_state;
+
+    if (!s)
+        return NULL;
+
+    new_state = (SBTrieState *) malloc (sizeof (SBTrieState));
+    if (!new_state)
+        return NULL;
+
+    new_state->sb_trie    = s->sb_trie;
+    new_state->trie_state = trie_state_clone (s->trie_state);
+
+    return new_state;
+}
+
+void
+sb_trie_state_free (SBTrieState *s)
+{
+    if (!s)
+        return;
+
+    trie_state_free (s->trie_state);
+    free (s);
+}
+
+void
+sb_trie_state_rewind (SBTrieState *s)
+{
+    if (!s)
+        return;
+
+    trie_state_rewind (s->trie_state);
+}
+
+Bool
+sb_trie_state_walk (SBTrieState *s, SBChar c)
+{
+    if (!s)
+        return FALSE;
+
+    return trie_state_walk (s->trie_state,
+                            alpha_map_char_to_alphabet (s->sb_trie->alpha_map,
+                                                        (UniChar) c));
+}
+
+Bool
+sb_trie_state_is_walkable (const SBTrieState *s, SBChar c)
+{
+    if (!s)
+        return FALSE;
+
+    return trie_state_is_walkable (
+               s->trie_state,
+               alpha_map_char_to_alphabet (s->sb_trie->alpha_map, (UniChar) c)
+           );
+}
+
+Bool
+sb_trie_state_is_terminal (const SBTrieState *s)
+{
+    if (!s)
+        return FALSE;
+
+    return trie_state_is_terminal (s->trie_state);
+}
+
+Bool
+sb_trie_state_is_leaf (const SBTrieState *s)
+{
+    if (!s)
+        return FALSE;
+
+    return trie_state_is_leaf (s->trie_state);
+}
+
+TrieData
+sb_trie_state_get_data (const SBTrieState *s)
+{
+    if (!s)
+        return TRIE_DATA_ERROR;
+
+    return trie_state_get_data (s->trie_state);
+}
+
+/*
+vi:ts=4:ai:expandtab
+*/

data/ext/libdatrie/datrie/sb-trie.h

@@ -0,0 +1,279 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * sb-trie.h - Single-byte domain trie front end
+ * Created: 2006-08-19
+ * Author:  Theppitak Karoonboonyanan <thep@linux.thai.net>
+ */
+
+#ifndef __SB_TRIE_H
+#define __SB_TRIE_H
+
+#include <datrie/triedefs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file sb-trie.h
+ * @brief Trie data type and functions
+ */
+
+/**
+ * @brief Single-byte domain trie data type
+ */
+typedef struct _SBTrie   SBTrie;
+
+/**
+ * @brief Single-byte character type
+ */
+typedef unsigned char    SBChar;
+
+/**
+ * @brief Single-byte domain trie enumeration function
+ *
+ * @param key  : the key of the entry
+ * @param data : the data of the entry
+ *
+ * @return TRUE to continue enumeration, FALSE to stop
+ */
+typedef Bool (*SBTrieEnumFunc) (const SBChar   *key,
+                                TrieData        key_data,
+                                void           *user_data);
+
+/**
+ * @brief Single-byte domain trie walking state
+ */
+typedef struct _SBTrieState SBTrieState;
+
+/*-----------------------*
+ *   GENERAL FUNCTIONS   *
+ *-----------------------*/
+
+/**
+ * @brief Open a single-byte domain trie
+ *
+ * @param path : the path that stores the trie files
+ * @param name : the name of the trie (not actual file name)
+ * @param mode : openning mode, read or write
+ *
+ * @return a pointer to the openned trie, NULL on failure
+ *
+ * Open a trie of given name. Note that @a name here does not mean the
+ * actual file name. Rather, the file name will be inferred by the name.
+ */
+SBTrie * sb_trie_open (const char *path, const char *name, TrieIOMode mode);
+
+/**
+ * @brief Close a single-byte domain trie
+ *
+ * @param sb_trie: the single-byte domain trie
+ *
+ * @return 0 on success, non-zero on failure
+ *
+ * Close the given trie. If @a trie was openned for writing, all pending
+ * changes will be saved to file.
+ */
+int      sb_trie_close (SBTrie *sb_trie);
+
+/**
+ * @brief Save a single-byte domain trie
+ *
+ * @param sb_trie: the single-byte domain trie
+ *
+ * @return 0 on success, non-zero on failure
+ *
+ * If @a trie was openned for writing, save all pending data to file.
+ */
+int      sb_trie_save (SBTrie *sb_trie);
+
+
+/*------------------------------*
+ *   GENERAL QUERY OPERATIONS   *
+ *------------------------------*/
+
+/**
+ * @brief Retrieve an entry from single-byte domain trie
+ *
+ * @param sb_trie : the single-byte domain trie
+ * @param key     : the key for the entry to retrieve
+ * @param o_data  : the storage for storing the entry data on return
+ *
+ * @return boolean value indicating the existence of the entry.
+ *
+ * Retrieve an entry for the given @a key from @a trie. On return,
+ * if @a key is found and @a o_val is not NULL, @a *o_val is set
+ * to the data associated to @a key.
+ */
+Bool     sb_trie_retrieve (SBTrie       *sb_trie,
+                           const SBChar *key,
+                           TrieData     *o_data);
+
+/**
+ * @brief Store a value for an entry to single-byte domain trie
+ *
+ * @param sb_trie : the single-byte domain trie
+ * @param key     : the key for the entry to retrieve
+ * @param data    : the data associated to the entry
+ *
+ * @return boolean value indicating the success of the process
+ *
+ * Store a data @a data for the given @a key in @a trie. If @a key does not 
+ * exist in @a trie, it will be appended.
+ */
+Bool     sb_trie_store (SBTrie *sb_trie, const SBChar *key, TrieData data);
+
+/**
+ * @brief Delete an entry from single-byte domain trie
+ *
+ * @param sb_trie : the single-byte domain trie
+ * @param key     : the key for the entry to delete
+ *
+ * @return boolean value indicating whether the key exists and is removed
+ *
+ * Delete an entry for the given @a key from @a trie.
+ */
+Bool     sb_trie_delete (SBTrie *sb_trie, const SBChar *key);
+
+/**
+ * @brief Enumerate entries in single-byte domain trie
+ *
+ * @param sb_trie    : the single-byte domain trie
+ * @param enum_func  : the callback function to be called on each key
+ * @param user_data  : user-supplied data to send as an argument to @a enum_func
+ *
+ * @return boolean value indicating whether all the keys are visited
+ *
+ * Enumerate all entries in trie. For each entry, the user-supplied 
+ * @a enum_func callback function is called, with the entry key and data.
+ * Returning FALSE from such callback will stop enumeration and return FALSE.
+ */
+Bool     sb_trie_enumerate (SBTrie         *sb_trie,
+                            SBTrieEnumFunc  enum_func,
+                            void           *user_data);
+
+
+/*-------------------------------*
+ *   STEPWISE QUERY OPERATIONS   *
+ *-------------------------------*/
+
+/**
+ * @brief Get root state of a single-byte domain trie
+ *
+ * @param sb_trie : the single-byte domain trie
+ *
+ * @return the root state of the trie
+ *
+ * Get root state of @a trie, for stepwise walking.
+ *
+ * The returned state is allocated and must be freed with trie_state_free()
+ */
+SBTrieState * sb_trie_root (SBTrie *sb_trie);
+
+
+/*----------------*
+ *   TRIE STATE   *
+ *----------------*/
+
+/**
+ * @brief Clone a single-byte domain trie state
+ *
+ * @param s    : the state to clone
+ *
+ * @return an duplicated instance of @a s
+ *
+ * Make a copy of trie state.
+ *
+ * The returned state is allocated and must be freed with trie_state_free()
+ */
+SBTrieState * sb_trie_state_clone (const SBTrieState *s);
+
+/**
+ * @brief Free a single-byte trie state
+ *
+ * @param s    : the state to free
+ *
+ * Free the trie state.
+ */
+void     sb_trie_state_free (SBTrieState *s);
+
+/**
+ * @brief Rewind a single-byte trie state
+ *
+ * @param s    : the state to rewind
+ *
+ * Put the state at root.
+ */
+void     sb_trie_state_rewind (SBTrieState *s);
+
+/**
+ * @brief Walk the single-byte domain trie from the state
+ *
+ * @param s    : current state
+ * @param c    : key character for walking
+ *
+ * @return boolean value indicating the success of the walk
+ *
+ * Walk the trie stepwise, using a given character @a c.
+ * On return, the state @a s is updated to the new state if successfully walked.
+ */
+Bool     sb_trie_state_walk (SBTrieState *s, SBChar c);
+
+/**
+ * @brief Test walkability of character from state
+ *
+ * @param s    : the state to check
+ * @param c    : the input character
+ *
+ * @return boolean indicating walkability
+ *
+ * Test if there is a transition from state @a s with input character @a c.
+ */
+Bool     sb_trie_state_is_walkable (const SBTrieState *s, SBChar c);
+
+/**
+ * @brief Check for terminal state
+ *
+ * @param s    : the state to check
+ *
+ * @return boolean value indicating whether it is a terminal state
+ *
+ * Check if the given state is a terminal state. A leaf state is a trie state 
+ * that terminates a key, and stores a value associated with the key.
+ */
+Bool     sb_trie_state_is_terminal (const SBTrieState *s);
+
+/**
+ * @brief Check for leaf state
+ *
+ * @param s    : the state to check
+ *
+ * @return boolean value indicating whether it is a leaf state
+ *
+ * Check if the given state is a leaf state. A leaf state is a terminal state 
+ * that has no other branch.
+ */
+Bool     sb_trie_state_is_leaf (const SBTrieState *s);
+
+/**
+ * @brief Get data from leaf state
+ *
+ * @param s    : the leaf state
+ *
+ * @return the data associated with the leaf state @a s,
+ *         or TRIE_DATA_ERROR if @a s is not a leaf state
+ *
+ * Get value from a leaf state of trie. Getting the value from leaf state 
+ * will result in TRIE_DATA_ERROR.
+ */
+TrieData sb_trie_state_get_data (const SBTrieState *s);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* __SB_TRIE_H */
+
+/*
+vi:ts=4:ai:expandtab
+*/