RubyTrie 1.0

data/ChangeLog

@@ -0,0 +1 @@
+1.0 added children and each methods

data/README

@@ -0,0 +1,55 @@
+A trie data structure implementation for ruby. Currently, it's a pretty minimal implementation. I've only implemented Trie#[], Trie#[]=, and Trie#delete so far. It's also fairly naive: There's plenty of room for optimization I'm sure, especially in key character sibling storage. (Currently a just linked list.) However, it does manage to be a bit faster than a native ruby Hash for similar keys.
+
+== Usage
+
+Compile the extension:
+
+ruby extconf.rb
+make
+
+Code:
+
+require 'trie'
+
+t = Trie.new
+t["key"] = "value"
+t["key"]            # => "value"
+
+t.children("partial key") will return all values for all keys that match the partial key
+
+t["go"] = 1
+t["goes"] = 2
+t["gone"] = 3
+t["other"] = 4
+
+t.children("go") => [1,2,3]
+
+t.each("partial key") will yield to the given block all values that are matched by the partial key
+t.each("go") {|v| puts v } => prints 1, 2 & 3 
+
+== Bugs
+
+I'm sure there are plenty!
+
+== License
+
+This software is copyright (c) 2008 Matt Freels
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/ext/trie/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+extension_name = 'trie'
+dir_config(extension_name)
+create_makefile(extension_name)

data/ext/trie/trie.c

@@ -0,0 +1,332 @@
+#include <stdlib.h>  /* for malloc, free */
+#include <string.h>  /* for memcmp, memmove */
+#include "ruby.h"
+
+// typdefs!
+typedef enum { false = 0, true} bool;
+
+typedef struct node {
+	char character;
+	VALUE value;
+	struct node * first_child;
+	struct node * next_sibling;
+} trie_node;
+
+static VALUE rb_cTrie;
+
+// =========================
+// = function declarations =
+// =========================
+
+//trie implementation
+static trie_node * trie_node_for_key(trie_node * root, char * key, bool create_missing_nodes);
+static trie_node * trie_sibling_for_char(trie_node * node, char ch);
+static trie_node * trie_add_sibling_for_char(trie_node * node, char ch);
+static trie_node * trie_new_node_with_char(char ch);
+static trie_node * trie_new_node();
+static VALUE rb_trie_find_children(VALUE self, VALUE key);
+static VALUE rb_trie_find_children_with_block(VALUE self, VALUE key);
+static void trie_collect_values(void * t, VALUE prary);
+static void trie_collect_values_with_yield(void * t);
+static void trie_traverse(trie_node * trie, void (*lambda_func)(void *));
+static void trie_traverse_with_context(trie_node * trie, VALUE context, void (*lambda_func)(void *, VALUE));
+static void free_trie(trie_node * trie);
+static void count_nodes_callback(void *n, VALUE accum);
+static VALUE rb_trie_count_nodes(VALUE self);
+
+
+// ========================
+// = function definitions =
+// ========================
+
+// instance methods
+static VALUE rb_trie_get_key(VALUE self, VALUE key) {
+	trie_node * root;
+	trie_node * node;
+	char * key_cstring;
+	
+	//Check_Type(key, T_STRING);
+	key_cstring = StringValuePtr(key);
+
+	Data_Get_Struct(self, trie_node, root);
+	
+	node = trie_node_for_key(root, key_cstring, false);
+	if (node == NULL) return Qnil;
+	return node->value;
+}
+
+static VALUE rb_trie_set_key_to_value(VALUE self, VALUE key, VALUE value) {
+	trie_node * root;
+	trie_node * node;
+	char * key_cstring;
+	
+	//Check_Type(key, T_STRING);
+	key_cstring = StringValuePtr(key);
+
+	Data_Get_Struct(self, trie_node, root);
+
+	node = trie_node_for_key(root, key_cstring, true);	
+	node->value = value;
+	
+	return Qnil;
+}
+
+static uint mem_count = 0;
+
+static void count_nodes_callback(void *n, VALUE accum) {
+  trie_node *node = (trie_node*)n;
+  // rb_big_plus(accum, rb_uint2big(sizeof(*node)));
+  mem_count+=sizeof(*node);
+}
+
+static VALUE rb_trie_count_nodes(VALUE self) {
+  trie_node *root;
+  Data_Get_Struct(self, trie_node, root);
+  VALUE accum = rb_uint2big(0);
+  mem_count = 0;
+  trie_traverse_with_context(root, accum, count_nodes_callback);
+  return rb_uint2big(mem_count);
+}
+
+static VALUE rb_trie_undef_key(VALUE self, VALUE key) {
+	trie_node * root, * node, * prev, * next;
+	VALUE return_value;	
+	char * key_cstring;
+	int steps;
+	int i;
+	
+	//Check_Type(key, T_STRING);
+	key_cstring = StringValuePtr(key);
+	
+	Data_Get_Struct(self, trie_node, root);
+	next = root;
+	node = NULL;
+	prev = NULL;
+
+	steps = strlen(key_cstring);
+	
+	for (i = 0; i < steps; i++) {
+		if (next == NULL) return Qnil;
+		
+		while(next->character != key_cstring[i]) {
+			if (next == NULL) return Qnil;
+			next = next->next_sibling;
+		}
+		prev = node;
+		node = next;
+		next = node->first_child;
+	}
+	
+	return_value = node->value;
+	node->value = Qnil;
+	
+	if (node->first_child == NULL) { //node has no children. we can delete it.
+		if (prev == NULL)  {
+			//printf("should delete root");
+		} else if (prev->first_child == node) {
+			prev->first_child = node->next_sibling;
+			free(node);
+		} else if (prev->next_sibling == node) {
+			prev->next_sibling = node->next_sibling;
+			free(node);
+		}
+	}
+	
+	return return_value;
+}
+
+// garbage collection and allocation
+static void trie_mark_value(void * t) {	
+	rb_gc_mark( ((trie_node *)t)->value );
+}
+
+static void rb_trie_mark(trie_node * t) {
+	trie_traverse(t, trie_mark_value);
+}
+
+static void rb_trie_free(trie_node * t) {
+	free_trie(t);
+}
+
+static VALUE rb_trie_allocate (VALUE klass) {
+	trie_node * t = trie_new_node();
+
+	return Data_Wrap_Struct(klass, rb_trie_mark, rb_trie_free, t);
+}
+
+// extension init
+void Init_trie() {
+	rb_cTrie = rb_define_class("Trie", rb_cObject);
+
+	rb_define_alloc_func (rb_cTrie, rb_trie_allocate);
+
+	int arg_count = 0;
+	//rb_define_method(rb_cTrie, "inspect", rb_trie_inspect, arg_count);
+	rb_define_method(rb_cTrie, "memory", rb_trie_count_nodes, arg_count);
+	
+	arg_count = 1;
+	rb_define_method(rb_cTrie, "[]", rb_trie_get_key, arg_count);
+	rb_define_method(rb_cTrie, "delete", rb_trie_undef_key, arg_count);
+	rb_define_method(rb_cTrie, "children", rb_trie_find_children, arg_count);
+	rb_define_method(rb_cTrie, "each", rb_trie_find_children_with_block, arg_count);
+
+	arg_count = 2;
+	rb_define_method(rb_cTrie, "[]=", rb_trie_set_key_to_value, arg_count);
+}
+
+
+// =======================
+// = trie implementation =
+// =======================
+
+static trie_node * trie_node_for_key(trie_node * root, char * key, bool create_missing_nodes) {		
+	int steps, i;
+	trie_node * next, * node;
+
+	steps = strlen(key);
+	next = root;
+
+	for (i = 0; i < steps; i++) {
+		if (next == NULL) {
+			if (create_missing_nodes) {
+				node->first_child = trie_new_node();
+				next = node->first_child;
+			}
+			else return NULL;
+		}
+
+		node = trie_sibling_for_char(next, key[i]);
+
+		if (node == NULL) {
+			if (create_missing_nodes) {
+				node = trie_add_sibling_for_char(next, key[i]);
+			}	
+			else return NULL;
+		}
+
+		next = node->first_child;
+	}	
+		
+	return node;    
+}
+
+static void trie_collect_values(void * t, VALUE rary) {	
+	trie_node *node = (trie_node*)t;
+	if (node->value != Qnil) {
+		rb_ary_push(rary, node->value);
+	}
+}
+
+static void trie_collect_values_with_yield(void * t) {	
+	trie_node *node = (trie_node*)t;
+	if (node->value != Qnil) {
+		// rb_ary_push(rary, node->value);
+		rb_yield(node->value);
+	}
+}
+
+static VALUE rb_trie_find_children(VALUE self, VALUE key) {
+	trie_node * root;
+	trie_node * node;
+	char * key_cstring;
+	VALUE rary = rb_ary_new();
+
+	key_cstring = StringValuePtr(key);
+	Data_Get_Struct(self, trie_node, root);
+
+	node = trie_node_for_key(root, key_cstring, false);
+	
+	if (node != NULL && node->value != Qnil) {
+		rb_ary_push(rary, node->value);
+	}
+	
+	if (node == NULL || node->first_child == NULL) return rary;
+
+	trie_traverse_with_context(node->first_child, rary, trie_collect_values);
+	return rary;
+}
+
+
+static VALUE rb_trie_find_children_with_block(VALUE self, VALUE key) {
+	trie_node * root;
+	trie_node * node;
+	char * key_cstring;
+	VALUE rary = rb_ary_new();
+
+	key_cstring = StringValuePtr(key);
+	Data_Get_Struct(self, trie_node, root);
+
+	node = trie_node_for_key(root, key_cstring, false);
+	
+	if (node != NULL && node->value != Qnil) {
+		rb_yield(node->value);
+	}
+	
+	if (node == NULL || node->first_child == NULL) return rary;
+
+	trie_traverse(node->first_child, trie_collect_values_with_yield);
+	return rary;
+}
+
+static trie_node * trie_sibling_for_char(trie_node * node, char ch) {
+	while(true) {
+		if (node == NULL) return NULL;
+
+		if (node->character == ch) return node;
+
+		node = node->next_sibling;
+	}
+	return node;
+}
+
+static trie_node * trie_add_sibling_for_char(trie_node * node, char ch) {
+	trie_node * current_next;
+
+	current_next = node->next_sibling;
+	node->next_sibling = trie_new_node_with_char(ch);
+	node->next_sibling->next_sibling = current_next;
+
+	return node->next_sibling;
+}
+
+static trie_node * trie_new_node_with_char(char ch) {
+	trie_node * trie;
+	trie = malloc(sizeof(trie_node));
+	trie->character = ch;
+	trie->value = Qnil;
+	trie->first_child = NULL;
+	trie->next_sibling = NULL;
+	return trie;
+}
+
+static trie_node * trie_new_node() {
+	return trie_new_node_with_char('s'); //insert most common starting letter here.
+}
+
+static void trie_traverse(trie_node * trie, void (* lambda_func)(void *)) {
+	if (trie->next_sibling != NULL) {
+		trie_traverse(trie->next_sibling, lambda_func);
+	}
+
+	if (trie->first_child != NULL) {
+		trie_traverse(trie->first_child, lambda_func);
+	}
+
+	lambda_func(trie);
+}
+
+static void trie_traverse_with_context(trie_node * trie, VALUE context, void (*lambda_func)(void *, VALUE)) {
+	if (trie->next_sibling != NULL) {
+		trie_traverse_with_context(trie->next_sibling, context, lambda_func);
+	}
+
+	if (trie->first_child != NULL) {
+		trie_traverse_with_context(trie->first_child, context, lambda_func);
+	}
+
+	lambda_func(trie, context);
+}
+
+static void free_trie(trie_node * trie) {
+	trie_traverse(trie, free);
+}

data/lib/ruby_trie.rb

@@ -0,0 +1 @@
+require 'trie'

data/test/rubytrie.rb

@@ -0,0 +1,78 @@
+class RubyTrie
+  def initialize(default = nil)
+    @first_child = nil
+    @default = default
+  end
+  
+  def [](key)
+    raise "key must be a string" unless key.is_a? String
+        
+    next_node = @first_child
+    node = nil
+    
+    0.upto(key.length - 1) do |i|
+      return nil if next_node.nil?
+      char = key[i]
+      node = next_node.sibling_for_char(char)
+      return nil if node.nil?
+      next_node = node.first_child
+    end
+    
+    return node.value
+  end
+  
+  def []=(key, val)
+    raise "key must be a string" unless key.is_a? String
+    
+    if @first_child.nil?
+      @first_child = TrieNode.new(key[0])
+    end
+    
+    next_node = @first_child
+    node = nil
+    
+    0.upto(key.length - 1) do |i|
+      char = key[i]
+      node = next_node.sibling_for_char(char)
+      node = next_node.add_sibling(char) if node.nil?
+      next_node = node.first_child
+      next_node = node.add_child(char) if next_node.nil? && i != key.length - 1
+    end
+    
+    node.value = val
+    return self
+  end
+end
+
+class TrieNode
+  attr_accessor :char, :next_sibling, :first_child, :value
+  
+  def initialize(char)
+    @next_sibling, @first_child, @value = nil
+    @char = char
+  end
+  
+  def sibling_for_char(char)
+    node = self
+    until node.nil?
+      return node if node.char == char
+      node = node.next_sibling
+    end
+    return nil
+  end
+  
+  def add_sibling(char)
+    node = self
+    
+    until node.next_sibling.nil?
+      node = node.next_sibling
+    end
+    node.next_sibling = TrieNode.new(char)
+    return node.next_sibling
+  end
+  
+  def add_child(char)
+    self.first_child = TrieNode.new(char)
+    return self.first_child
+  end
+end

data/test/trie_test.rb

@@ -0,0 +1,60 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+$:.unshift File.dirname(__FILE__) + '/../ext/trie'
+
+require 'trie'
+
+max = 1000000
+
+def time
+  starttime = Time.now
+  res = yield
+  endtime = Time.now
+  puts "Time elapsed: #{endtime - starttime} seconds"
+	res
+end
+
+puts "With a native Trie..."
+t = Trie.new
+time do
+  1.upto(max) do |i|
+    t["item #{i}"] = "sweet"
+  end
+
+  1.upto(max) do |i|
+    t["item #{i}"].class
+  end
+  
+  1.upto(max) do |i|
+    t.delete("item #{i}")
+  end
+end
+
+
+puts "With a Hash..."
+t = Hash.new
+time do
+  1.upto(max) do |i|
+    t["item #{i}"] = "sweet"
+  end
+
+  1.upto(max) do |i|
+    t["item #{i}"].class
+  end
+
+  1.upto(max) do |i|
+    t.delete("item #{i}")
+  end
+end
+
+# puts "With a Ruby Trie..."
+# t = RubyTrie.new
+# time do
+#   1.upto(max) do |i|
+#     t["item #{i}"] = "sweet"
+#   end
+# 
+#   1.upto(max) do |i|
+#     t["item #{i}"].class
+#   end
+# end
+

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: RubyTrie
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  version: "1.0"
+platform: ruby
+authors: 
+- Matt Freels
+- Petrica Ghiurca
+autorequire: trie
+bindir: bin
+cert_chain: []
+
+date: 2010-09-30 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+executables: []
+
+extensions: 
+- ext/trie/extconf.rb
+extra_rdoc_files: 
+- README
+files: 
+- README
+- ChangeLog
+- ext/trie/trie.c
+- ext/trie/extconf.rb
+- lib/ruby_trie.rb
+- test/rubytrie.rb
+- test/trie_test.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- RubyTrie
+- --main
+- README
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Set a Timeout based on signals, which are more reliable than Timeout. Timeout is based on green threads.
+test_files: 
+- test/trie_test.rb