tyler-trie 0.2.3 → 0.3.1

data/ext/trie/trie-private.h

@@ -0,0 +1,31 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * trie-private.h - Private utilities for trie implementation
+ * Created: 2007-08-25
+ * Author:  Theppitak Karoonboonyanan <thep@linux.thai.net>
+ */
+
+#ifndef __TRIE_PRIVATE_H
+#define __TRIE_PRIVATE_H
+
+#include <datrie/typedefs.h>
+
+/**
+ * @file trie-private.h
+ * @brief Private utilities for trie implementation
+ */
+
+/**
+ * @brief Minimum value macro
+ */
+#define MIN_VAL(a,b)  ((a)<(b)?(a):(b))
+/**
+ * @brief Maximum value macro
+ */
+#define MAX_VAL(a,b)  ((a)>(b)?(a):(b))
+
+#endif  /* __TRIE_PRIVATE_H */
+
+/*
+vi:ts=4:ai:expandtab
+*/

data/ext/trie/trie.c

@@ -1,393 +1,298 @@
 #include "ruby.h"
-#include <datrie/sb-trie.h>
+#include "trie.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 
 VALUE cTrie, cTrieNode;
 
-static TrieChar* stringToTrieChar(VALUE string) {
-    StringValue(string);
-    return (TrieChar*) RSTRING(string)->ptr;
+static VALUE rb_trie_alloc(VALUE klass) {
+	VALUE obj;
+	obj = Data_Wrap_Struct(klass, 0, trie_free, trie_new());
+	return obj;
 }
 
-static void trie_free(SBTrie *sb_trie) {
-    if(sb_trie)
-	sb_trie_close(sb_trie);
-}
-
-static VALUE trie_alloc(VALUE klass) {
-    SBTrie *sb_trie;
-    VALUE obj;
-    
-    obj = Data_Wrap_Struct(klass, 0, trie_free, sb_trie);
-    rb_iv_set(obj, "@open", Qfalse);
-
-    return obj;
-}
-
-static VALUE trie_initialize(VALUE self, VALUE path) {
-    SBTrie *sb_trie;
-
-    char *cpath = RSTRING(path)->ptr;
-    char *full_path = (char*)malloc(strlen(cpath) + 10);
-    sprintf(full_path, "%s/trie.sbm", cpath);
-
-    FILE *file;
-
-    file = fopen (full_path, "r");
-    if (!file) {
-        file = fopen (full_path, "w+");
-	fprintf(file,"[00,FF]\n");
-    }
-    fclose(file);
-    free (full_path);
-
-    // replace the pretend SBTrie created in alloc with a real one
-    RDATA(self)->data = sb_trie_open(cpath, "trie",
-				     TRIE_IO_READ | TRIE_IO_WRITE | TRIE_IO_CREATE);
-
-    rb_iv_set(self, "@open", Qtrue);
-    rb_iv_set(self, "@path", path);
-    return self;
-}
-
-static VALUE trie_close(VALUE self) {
-    SBTrie *sb_trie;
-    Data_Get_Struct(self, SBTrie, sb_trie);
+static VALUE rb_trie_has_key(VALUE self, VALUE key) {
+    Trie *trie;
+    Data_Get_Struct(self, Trie, trie);
 
-    rb_iv_set(self, "@open", Qfalse);
-
-    return self;
-}
-
-static VALUE trie_has_key(VALUE self, VALUE key) {
-    SBTrie *sb_trie;
-    Data_Get_Struct(self, SBTrie, sb_trie);
-
-    const TrieChar *sb_key = (const TrieChar *)RSTRING(key)->ptr;
-
-    if(sb_trie_retrieve(sb_trie, sb_key, NULL))
-	return Qtrue;
+    if(trie_retrieve(trie, (TrieChar*)RSTRING(key)->ptr, NULL))
+		return Qtrue;
     else
-	return Qnil;
+		return Qnil;
 }
 
-static VALUE trie_get(VALUE self, VALUE key) {
-    SBTrie *sb_trie;
-    TrieData trie_data;
-    Data_Get_Struct(self, SBTrie, sb_trie);
-
-    const TrieChar *sb_key = stringToTrieChar(key);
+static VALUE rb_trie_get(VALUE self, VALUE key) {
+    Trie *trie;
+    Data_Get_Struct(self, Trie, trie);
 
-    if(sb_trie_retrieve(sb_trie, sb_key, &trie_data)) {
-	return INT2FIX(trie_data);
-    } else
-	return Qnil;
+	TrieData data;
+    if(trie_retrieve(trie, (TrieChar*)RSTRING(key)->ptr, &data))
+		return INT2FIX(data);
+    else
+		return Qnil;
 }
 
-static VALUE trie_add(VALUE self, VALUE args) {
-    SBTrie *sb_trie;
-    Data_Get_Struct(self, SBTrie, sb_trie);
+static VALUE rb_trie_add(VALUE self, VALUE args) {
+	Trie *trie;
+    Data_Get_Struct(self, Trie, trie);
 
-    long size = RARRAY(args)->len;
+    int size = RARRAY(args)->len;
     if(size < 1 || size > 2)
-	return Qnil;
+		return Qnil;
 
     VALUE key;
     key = RARRAY(args)->ptr[0];
     TrieData value = size == 2 ? NUM2INT(RARRAY(args)->ptr[1]) : TRIE_DATA_ERROR;
     
-    const TrieChar *sb_key = stringToTrieChar(key);
-    
-    if(sb_trie_store(sb_trie, sb_key, value))
-	return Qtrue;
+    if(trie_store(trie, (TrieChar*)RSTRING(key)->ptr, value))
+		return Qtrue;
     else
-	return Qnil;
+		return Qnil;
 }
 
-static VALUE trie_delete(VALUE self, VALUE key) {
-    SBTrie *sb_trie;
-    Data_Get_Struct(self, SBTrie, sb_trie);
-
-    const TrieChar *sb_key = stringToTrieChar(key);
+static VALUE rb_trie_delete(VALUE self, VALUE key) {
+	Trie *trie;
+    Data_Get_Struct(self, Trie, trie);
 
-    if(sb_trie_delete(sb_trie, sb_key))
-	return Qtrue;
+    if(trie_delete(trie, (TrieChar*)RSTRING(key)->ptr))
+		return Qtrue;
     else
-	return Qnil;
+		return Qnil;
 }
 
-static VALUE trie_save(VALUE self) {
-    SBTrie *sb_trie;
-    Data_Get_Struct(self, SBTrie, sb_trie);
-    
-    if(sb_trie_save(sb_trie) == -1)
-	return Qnil;
-    else
-	return Qtrue;
+char* append_char(char* existing, int size, char c) {
+	char *new = (char*) malloc(size + 2);
+	memcpy(new, existing, size);
+	new[size] = c;
+	new[size + 1] = 0;
+	return new;
 }
 
-static VALUE walk_all_paths(VALUE children, SBTrieState *state, char *prefix) {
-    int c;
-    for(c = 1; c < TRIE_CHAR_MAX; c++) {
-	if(sb_trie_state_is_walkable(state,c)) {
-	    SBTrieState *next_state = sb_trie_state_clone(state);
-	    sb_trie_state_walk(next_state, (TrieChar)c);
-
-	    char *word = (char*)malloc(strlen(prefix) + 2);
-	    strcat(strcpy(word, prefix), (char*)&c);
-
-	    if(sb_trie_state_is_terminal(next_state))
-		rb_ary_push(children, rb_str_new2(word));
-
-	    walk_all_paths(children, next_state, word);
-
-	    sb_trie_state_free(next_state);
-	}
+static VALUE walk_all_paths(Trie *trie, VALUE children, TrieState *state, char *prefix, int prefix_size) {
+	int c;
+    for(c = 1; c < 256; c++) {
+		if(trie_state_is_walkable(state,c)) {
+			TrieState *next_state = trie_state_clone(state);
+			trie_state_walk(next_state, c);
+
+			prefix[prefix_size] = c;
+			prefix[prefix_size + 1] = 0;
+
+			if(trie_state_is_terminal(next_state)) {
+				char *word = (char*) malloc(prefix_size + 2);
+				memcpy(word, prefix, prefix_size + 2);
+				rb_ary_push(children, rb_str_new2(word));
+			}
+
+			walk_all_paths(trie, children, next_state, prefix, prefix_size + 1);
+			
+			prefix[prefix_size] = 0;
+			trie_state_free(next_state);
+		}
     }
 }
 
-static VALUE trie_children(VALUE self, VALUE prefix) {
+static VALUE rb_trie_children(VALUE self, VALUE prefix) {
     if(NIL_P(prefix))
-	return rb_ary_new();
+		return rb_ary_new();
 
-    SBTrie *sb_trie;
-    Data_Get_Struct(self, SBTrie, sb_trie);
+    Trie *trie;
+    Data_Get_Struct(self, Trie, trie);
 
-    const TrieChar *sb_prefix = stringToTrieChar(prefix);
-    
+	int prefix_size = RSTRING(prefix)->len;
+    TrieState *state = trie_root(trie);
     VALUE children = rb_ary_new();
-
-    SBTrieState *state = sb_trie_root(sb_trie);
+	TrieChar *char_prefix = (TrieChar*)RSTRING(prefix)->ptr;
     
-    TrieChar *iterator = (TrieChar*)sb_prefix;
-    while(*iterator != '\0') {
-	if(!sb_trie_state_is_walkable(state, *iterator))
-	    return rb_ary_new();
-	sb_trie_state_walk(state, *iterator);
-	iterator++;
+    const TrieChar *iterator = char_prefix;
+    while(*iterator != 0) {
+		if(!trie_state_is_walkable(state, *iterator))
+			return children;
+		trie_state_walk(state, *iterator);
+		iterator++;
     }
 
-    if(sb_trie_state_is_terminal(state))
-	rb_ary_push(children, prefix);
+    if(trie_state_is_terminal(state))
+		rb_ary_push(children, prefix);
+	
+	char prefix_buffer[1024];
+	memcpy(prefix_buffer, char_prefix, prefix_size);
+	prefix_buffer[prefix_size] = 0;
 
-    walk_all_paths(children, state, (char*)sb_prefix);
+    walk_all_paths(trie, children, state, prefix_buffer, prefix_size);
 
-    sb_trie_state_free(state);
+    trie_state_free(state);
     return children;
 }
-static VALUE walk_all_paths_with_values(VALUE children, SBTrieState *state, char *prefix) {
-    int c;
-    for(c = 1; c < TRIE_CHAR_MAX; c++) {
-	if(sb_trie_state_is_walkable(state,c)) {
-	    SBTrieState *next_state = sb_trie_state_clone(state);
-	    sb_trie_state_walk(next_state, (TrieChar)c);
 
-	    char *word = (char*)malloc(strlen(prefix) + 2);
-	    strcat(strcpy(word, prefix), (char*)&c);
 
-	    if(sb_trie_state_is_terminal(next_state)) {
-		SBTrieState *end_state = sb_trie_state_clone(next_state);
-		sb_trie_state_walk(end_state, '\0');
+static VALUE walk_all_paths_with_values(Trie *trie, VALUE children, TrieState *state, char *prefix, int prefix_size) {
+	int c;
+    for(c = 1; c < 256; c++) {
+		if(trie_state_is_walkable(state,c)) {
+			TrieState *next_state = trie_state_clone(state);
+			trie_state_walk(next_state, c);
 
-		VALUE tuple = rb_ary_new();
-		rb_ary_push(tuple, rb_str_new2(word));
-		TrieData trie_data = sb_trie_state_get_data(end_state);
-		rb_ary_push(tuple, INT2FIX(trie_data));
-		rb_ary_push(children, tuple);
+			prefix[prefix_size] = c;
+			prefix[prefix_size + 1] = 0;
 
-		sb_trie_state_free(end_state);
-	    }
+			if(trie_state_is_terminal(next_state)) {
+				TrieState *end_state = trie_state_clone(next_state);
+				trie_state_walk(end_state, '\0');
+ 
+				char *word = (char*) malloc(prefix_size + 2);
+				memcpy(word, prefix, prefix_size + 2);
 
-	    walk_all_paths_with_values(children, next_state, word);
+				VALUE tuple = rb_ary_new();
+				rb_ary_push(tuple, rb_str_new2(word));
 
-	    sb_trie_state_free(next_state);
-	}
+				TrieData trie_data = trie_state_get_data(end_state);
+				rb_ary_push(tuple, INT2FIX(trie_data));
+				rb_ary_push(children, tuple);
+ 
+				trie_state_free(end_state);
+			}
+
+			walk_all_paths_with_values(trie, children, next_state, prefix, prefix_size + 1);
+			
+			prefix[prefix_size] = 0;
+			trie_state_free(next_state);
+		}
     }
 }
 
-static VALUE trie_children_with_values(VALUE self, VALUE prefix) {
+
+
+
+static VALUE rb_trie_children_with_values(VALUE self, VALUE prefix) {
     if(NIL_P(prefix))
-	return rb_ary_new();
+		return rb_ary_new();
 
-    SBTrie *sb_trie;
-    Data_Get_Struct(self, SBTrie, sb_trie);
+    Trie *trie;
+    Data_Get_Struct(self, Trie, trie);
 
-    const TrieChar *sb_prefix = stringToTrieChar(prefix);
+	int prefix_size = RSTRING(prefix)->len;
+    TrieChar *char_prefix = (TrieChar*)RSTRING(prefix)->ptr;
     
     VALUE children = rb_ary_new();
 
-    SBTrieState *state = sb_trie_root(sb_trie);
+    TrieState *state = trie_root(trie);
     
-    TrieChar *iterator = (TrieChar*)sb_prefix;
-    while(*iterator != '\0') {
-	if(!sb_trie_state_is_walkable(state, *iterator))
-	    return rb_ary_new();
-	sb_trie_state_walk(state, *iterator);
-	iterator++;
-    }
-
-    if(sb_trie_state_is_terminal(state)) {
-	SBTrieState *end_state = sb_trie_state_clone(state);
-	sb_trie_state_walk(end_state, '\0');
-
-	VALUE tuple = rb_ary_new();
-	rb_ary_push(tuple, prefix);
-	TrieData trie_data = sb_trie_state_get_data(end_state);
-	rb_ary_push(tuple, INT2FIX(trie_data));
-	rb_ary_push(children, tuple);
-
-	sb_trie_state_free(end_state);
+    const TrieChar *iterator = char_prefix;
+    while(*iterator != 0) {
+		if(!trie_state_is_walkable(state, *iterator))
+			return rb_ary_new();
+		trie_state_walk(state, *iterator);
+		iterator++;
     }
 
-    walk_all_paths_with_values(children, state, (char*)sb_prefix);
-
-    sb_trie_state_free(state);
-    return children;
-}
-
-static VALUE trie_walk_to_terminal(VALUE self, VALUE args) {
-    SBTrie *sb_trie;
-    Data_Get_Struct(self, SBTrie, sb_trie);
+    if(trie_state_is_terminal(state)) {
+		TrieState *end_state = trie_state_clone(state);
+		trie_state_walk(end_state, '\0');
 
-    long size = RARRAY(args)->len;
-    if(size < 1 || size > 2)
-	return Qnil;
+		VALUE tuple = rb_ary_new();
+		rb_ary_push(tuple, prefix);
+		TrieData trie_data = trie_state_get_data(end_state);
+		rb_ary_push(tuple, INT2FIX(trie_data));
+		rb_ary_push(children, tuple);
 
-    VALUE rb_path;
-    rb_path = RARRAY(args)->ptr[0];
-    short include_value = size == 2 ? RTEST(RARRAY(args)->ptr[1]) : 0;
-    
-    SBTrieState *state = sb_trie_root(sb_trie);
-    
-    char *path = RSTRING(rb_path)->ptr;
-
-    TrieChar *iterator = (TrieChar*)path;
-    while(*iterator != '\0') {
-	if(sb_trie_state_is_terminal(state)) {
-	    int word_length = (int)iterator - (int)path;
-	    char *word = (char*)malloc(word_length + 1);
-	    strncpy(word, path, word_length);
-	    word[word_length] = '\0';
-	    VALUE rb_word = rb_str_new2((const char*)word);
-
-	    if(include_value) {
-		sb_trie_state_walk(state, (TrieChar)'\0');
-
-		VALUE return_ary = rb_ary_new();
-		rb_ary_push(return_ary, rb_word);
-		TrieData trie_data = sb_trie_state_get_data(state);
-		rb_ary_push(return_ary, INT2FIX(trie_data));
-		return return_ary;
-	    } else
-		return rb_word;
-	}
-
-	if(!sb_trie_state_is_walkable(state, *iterator))
-	   return Qnil;
-
-	sb_trie_state_walk(state, *iterator);
-	iterator++;
+		trie_state_free(end_state);
     }
 
-    sb_trie_state_free(state);
+	char prefix_buffer[1024];
+	memcpy(prefix_buffer, char_prefix, prefix_size);
+	prefix_buffer[prefix_size] = 0;
 
-    return Qnil;
-}
-
-static VALUE trie_get_path(VALUE self) {
-    return rb_iv_get(self, "@path");
-}
+    walk_all_paths_with_values(trie, children, state, prefix_buffer, prefix_size);
 
-static void trie_node_free(SBTrieState *state) {
-    if(state)
-	sb_trie_state_free(state);
+    trie_state_free(state);
+    return children;
 }
 
-static VALUE trie_node_alloc(VALUE klass) {
-    SBTrieState *state;
+static VALUE rb_trie_node_alloc(VALUE klass) {
     VALUE obj;
-    
-    obj = Data_Wrap_Struct(klass, 0, trie_node_free, state);
-
+    obj = Data_Wrap_Struct(klass, 0, trie_state_free, NULL);
     return obj;
 }
 
-static VALUE trie_root(VALUE self) {
-    SBTrie *sb_trie;
-    Data_Get_Struct(self, SBTrie, sb_trie);
+static VALUE rb_trie_root(VALUE self) {
+    Trie *trie;
+    Data_Get_Struct(self, Trie, trie);
 
-    VALUE trie_node = trie_node_alloc(cTrieNode);
+    VALUE trie_node = rb_trie_node_alloc(cTrieNode);
 
-    // replace the pretend SBTrieState created in TrieNode's alloc with a real one
-    RDATA(trie_node)->data = sb_trie_root(sb_trie);
+	TrieState *state = trie_root(trie);
+	RDATA(trie_node)->data = state;
     
     rb_iv_set(trie_node, "@state", Qnil);
     rb_iv_set(trie_node, "@full_state", rb_str_new2(""));
     return trie_node;
 }
 
-static VALUE trie_node_get_state(VALUE self) {
+static VALUE rb_trie_node_get_state(VALUE self) {
     return rb_iv_get(self, "@state");
 }
-static VALUE trie_node_get_full_state(VALUE self) {
+static VALUE rb_trie_node_get_full_state(VALUE self) {
     return rb_iv_get(self, "@full_state");
 }
 
-static VALUE trie_node_walk_bang(VALUE self, VALUE rchar) {
-    SBTrieState *state;
-    Data_Get_Struct(self, SBTrieState, state);
+static VALUE rb_trie_node_walk_bang(VALUE self, VALUE rchar) {
+    TrieState *state;
+    Data_Get_Struct(self, TrieState, state);
 
     if(RSTRING(rchar)->len != 1)
-	return Qnil;
+		return Qnil;
 
-    char ch = RSTRING(rchar)->ptr[0];
-    int result = sb_trie_state_walk(state, (TrieChar)ch);
+    Bool result = trie_state_walk(state, *RSTRING(rchar)->ptr);
     
     if(result) {
-	rb_iv_set(self, "@state", rchar);
-	VALUE full_state = rb_iv_get(self, "@full_state");
-	rb_str_append(full_state, rchar);
-	rb_iv_set(self, "@full_state", full_state);
-	return self;
+		rb_iv_set(self, "@state", rchar);
+		VALUE full_state = rb_iv_get(self, "@full_state");
+		rb_str_append(full_state, rchar);
+		rb_iv_set(self, "@full_state", full_state);
+		return self;
     } else
-	return Qnil;
+		return Qnil;
 }
 
-static VALUE trie_node_value(VALUE self) {
-    SBTrieState *state, *dup;
-    Data_Get_Struct(self, SBTrieState, state);
+static VALUE rb_trie_node_value(VALUE self) {
+    TrieState *state;
+	TrieState *dup;
+    Data_Get_Struct(self, TrieState, state);
     
-    dup = sb_trie_state_clone(state);
+    dup = trie_state_clone(state);
 
-    sb_trie_state_walk(dup, (TrieChar)'\0');
-    TrieData trie_data = sb_trie_state_get_data(dup);
-    sb_trie_state_free(dup);
+    trie_state_walk(dup, 0);
+    TrieData trie_data = trie_state_get_data(dup);
+    trie_state_free(dup);
 
     return TRIE_DATA_ERROR == trie_data ? Qnil : INT2FIX(trie_data);
 }
 
-static VALUE trie_node_terminal(VALUE self) {
-    SBTrieState *state;
-    Data_Get_Struct(self, SBTrieState, state);
+static VALUE rb_trie_node_terminal(VALUE self) {
+    TrieState *state;
+    Data_Get_Struct(self, TrieState, state);
     
-    return sb_trie_state_is_terminal(state) ? Qtrue : Qnil;
+    return trie_state_is_terminal(state) ? Qtrue : Qnil;
 }
 
-static VALUE trie_node_leaf(VALUE self) {
-    SBTrieState *state;
-    Data_Get_Struct(self, SBTrieState, state);
+static VALUE rb_trie_node_leaf(VALUE self) {
+    TrieState *state;
+    Data_Get_Struct(self, TrieState, state);
     
-    return sb_trie_state_is_leaf(state) ? Qtrue : Qnil;
+    return trie_state_is_leaf(state) ? Qtrue : Qnil;
 }
 
-static VALUE trie_node_clone(VALUE self) {
-    SBTrieState *state;
-    Data_Get_Struct(self, SBTrieState, state);
+static VALUE rb_trie_node_clone(VALUE self) {
+    TrieState *state;
+    Data_Get_Struct(self, TrieState, state);
     
-    VALUE new_node = trie_node_alloc(cTrieNode);
-    RDATA(new_node)->data = sb_trie_state_clone(state);
+    VALUE new_node = rb_trie_node_alloc(cTrieNode);
+
+	TrieState *new_state = trie_state_clone(state);
+
+    RDATA(new_node)->data = new_state;
     
     rb_iv_set(new_node, "@state", rb_iv_get(self, "@state"));
     rb_iv_set(new_node, "@full_state", rb_iv_get(self, "@full_state"));
@@ -398,27 +303,25 @@ static VALUE trie_node_clone(VALUE self) {
  
 void Init_trie() {
     cTrie = rb_define_class("Trie", rb_cObject);
-    rb_define_alloc_func(cTrie, trie_alloc);
-    rb_define_method(cTrie, "initialize", trie_initialize, 1);
-    rb_define_method(cTrie, "path", trie_get_path, 0);
-    rb_define_method(cTrie, "has_key?", trie_has_key, 1);
-    rb_define_method(cTrie, "get", trie_get, 1);
-    rb_define_method(cTrie, "add", trie_add, -2);
-    rb_define_method(cTrie, "delete", trie_delete, 1);
-    rb_define_method(cTrie, "close", trie_close, 0);
-    rb_define_method(cTrie, "children", trie_children, 1);
-    rb_define_method(cTrie, "children_with_values", trie_children_with_values, 1);
-    rb_define_method(cTrie, "walk_to_terminal", trie_walk_to_terminal, -2);
-    rb_define_method(cTrie, "root", trie_root, 0);
-    rb_define_method(cTrie, "save", trie_save, 0);
+    rb_define_alloc_func(cTrie, rb_trie_alloc);
+    //rb_define_method(cTrie, "initialize", rb_trie_initialize, -2);
+    //rb_define_method(cTrie, "path", rb_trie_get_path, 0);
+    rb_define_method(cTrie, "has_key?", rb_trie_has_key, 1);
+    rb_define_method(cTrie, "get", rb_trie_get, 1);
+    rb_define_method(cTrie, "add", rb_trie_add, -2);
+    rb_define_method(cTrie, "delete", rb_trie_delete, 1);
+    rb_define_method(cTrie, "children", rb_trie_children, 1);
+    rb_define_method(cTrie, "children_with_values", rb_trie_children_with_values, 1);
+    rb_define_method(cTrie, "root", rb_trie_root, 0);
+    //rb_define_method(cTrie, "save", rb_trie_save, 0);
 
     cTrieNode = rb_define_class("TrieNode", rb_cObject);
-    rb_define_alloc_func(cTrieNode, trie_node_alloc);
-    rb_define_method(cTrieNode, "state", trie_node_get_state, 0);
-    rb_define_method(cTrieNode, "full_state", trie_node_get_full_state, 0);
-    rb_define_method(cTrieNode, "walk!", trie_node_walk_bang, 1);
-    rb_define_method(cTrieNode, "value", trie_node_value, 0);
-    rb_define_method(cTrieNode, "terminal?", trie_node_terminal, 0);
-    rb_define_method(cTrieNode, "leaf?", trie_node_leaf, 0);
-    rb_define_method(cTrieNode, "clone", trie_node_clone, 0);
+    rb_define_alloc_func(cTrieNode, rb_trie_node_alloc);
+    rb_define_method(cTrieNode, "state", rb_trie_node_get_state, 0);
+    rb_define_method(cTrieNode, "full_state", rb_trie_node_get_full_state, 0);
+    rb_define_method(cTrieNode, "walk!", rb_trie_node_walk_bang, 1);
+    rb_define_method(cTrieNode, "value", rb_trie_node_value, 0);
+    rb_define_method(cTrieNode, "terminal?", rb_trie_node_terminal, 0);
+    rb_define_method(cTrieNode, "leaf?", rb_trie_node_leaf, 0);
+    rb_define_method(cTrieNode, "clone", rb_trie_node_clone, 0);
 }