rpatricia 0.05 → 0.06

data/Changes

@@ -1,3 +1,19 @@
+0.06 2010/09/14
+  - rely on Ruby GC for allocations/free
+    no need to explicitly destroy objects anymore
+  - Ruby 1.9.2 C API compatibility
+  - allow creation of subclasses of Patricia class
+  - non-String objects may be stored as node-data
+  - Patricia::Node objects are returned when match succeeds
+    It's no longer possible to call tree methods on node
+    objects and cause segfaults.
+  - Patricia#show_nodes may be given a custom IO-like object
+  - sync docs with remove, match_best and match_exact behavior
+  - ArgumentError is raised for invalid addresses
+    no more assertion failures for bad addresses
+  - Patricia#show_nodes and Patricia#num_nodes no longer
+    segfaults on empty trees
+
 0.05 2010/03/12
  - reorganized directory layout
    no chance of accidentally having 'extconf' in the require path

data/README

@@ -60,10 +60,9 @@ new:
 
       pt = Patricia.new
 
-    This is the class' constructor - it returns a Patricia object upon
-    success or nil on failure. For now, the constructor takes no
-    arguments, and defaults to creating a tree which uses AF_INET IPv4
-    address and mask values as keys. 
+    This is the class' constructor - it returns a Patricia object.  For
+    now, the constructor takes no arguments, and defaults to creating a
+    tree which uses AF_INET IPv4 address and mask values as keys.
 
     The Patricia object will be destroyed automatically when there are
     no longer any references to it.
@@ -124,6 +123,14 @@ search_exact:
 
 match_exact:	An alias of search_exact.
 
+include?:
+
+      pt.include?(key_string);
+
+    This method behaves like match_best, but returns true on success
+    and false on failure.  This method is more efficient than match_best
+    as it does not allocate a new object.
+
 remove:
 
       pt.remove(key_string);
@@ -132,7 +139,7 @@ remove:
     and mask specified from the Patricia Trie.
 
     If the matching node is found in the Patricia Trie, it is removed,
-    and this method returns the true. This method returns nil on
+    and this method returns the true. This method returns false on
     failure. 
 
 remove_node:	 An alias of remove

data/ext/rpatricia/extconf.rb

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby 
 require "mkmf"
 
+have_func("ruby_xcalloc")
+have_func("rb_str_set_len", "ruby.h")
 create_makefile("rpatricia")
-

data/ext/rpatricia/patricia.c

@@ -31,7 +31,13 @@ static char copyright[] =
 
 #include "patricia.h"
 
-#define Delete free
+#if defined(HAVE_RUBY_XCALLOC)
+#  include <ruby.h>
+#  define calloc xcalloc
+#  define Delete xfree
+#else
+#  define Delete free
+#endif
 
 /* { from prefix.c */
 

data/ext/rpatricia/rpatricia.c

@@ -4,28 +4,57 @@
  */
 
 #include "ruby.h"
-#include <stdio.h> /* printf */
 #include <stdlib.h>
 #include "patricia.h"
+#include <assert.h>
 
-VALUE cPatricia;
+static VALUE cPatricia, cNode;
 
-void dummy(void) {}
+static void dummy(void) {}
 
 static VALUE
 p_destroy (VALUE self)
 {
   patricia_tree_t *tree;
+
   Data_Get_Struct(self, patricia_tree_t, tree);
-  Destroy_Patricia(tree, free);
+  Clear_Patricia(tree, dummy);
+  tree->head = NULL; /* Clear_Patricia() should do this, actually */
+
   return Qtrue;
 }
 
-VALUE
+static void
+p_node_mark (void *ptr)
+{
+  patricia_node_t *node = ptr;
+
+  rb_gc_mark((VALUE)node->data);
+}
+
+static VALUE
+wrap_node(patricia_node_t *node)
+{
+  /* node will be freed when parent is freed */
+  return Data_Wrap_Struct(cNode, p_node_mark, 0, node);
+}
+
+static prefix_t *
+my_ascii2prefix(int family, VALUE str)
+{
+  char *cstr = StringValuePtr(str);
+  prefix_t *prefix = ascii2prefix(family, cstr);
+
+  if (!prefix)
+    rb_raise(rb_eArgError, "invalid prefix: %s", cstr);
+
+  return prefix;
+}
+
+static VALUE
 p_add (int argc, VALUE *argv, VALUE self)
 {
-  int str_len;
-  char *user_data;
+  VALUE user_data;
   patricia_tree_t *tree;
   patricia_node_t *node;
   prefix_t *prefix;
@@ -34,33 +63,34 @@ p_add (int argc, VALUE *argv, VALUE self)
     return Qnil;
 
   Data_Get_Struct(self, patricia_tree_t, tree);
-  prefix = ascii2prefix(AF_INET, STR2CSTR(argv[0]));
+  prefix = my_ascii2prefix(AF_INET, argv[0]);
   node = patricia_lookup(tree, prefix);
   Deref_Prefix(prefix);
 
   if (argc == 2) {
-    user_data = STR2CSTR(argv[1]);
-    str_len = strlen(user_data);
-    node->data = (char *) malloc((str_len + 1) * sizeof(char));
-    sprintf((char *)node->data, user_data);
+    user_data = argv[1];
+
+    /* for backwards compatibility, we always dup and return new strings */
+    if (TYPE(user_data) == T_STRING)
+      user_data = rb_str_dup(user_data);
   } else {
-    node->data = (char *) malloc(sizeof(char));
-    sprintf((char *)node->data, "");
+    user_data = rb_str_new(NULL, 0);
   }
-  return Data_Wrap_Struct(cPatricia, 0, 0, node);
+  PATRICIA_DATA_SET(node, user_data);
+
+  /* node will be freed when parent is freed */
+  return wrap_node(node);
 }
 
 static VALUE
 p_remove (VALUE self, VALUE r_key)
 {
-  char *c_key;
   patricia_tree_t *tree;
   patricia_node_t *node;
   prefix_t *prefix;
 
   Data_Get_Struct(self, patricia_tree_t, tree);
-  c_key = STR2CSTR(r_key);
-  prefix = ascii2prefix (AF_INET, c_key);
+  prefix = my_ascii2prefix (AF_INET, r_key);
   node = patricia_search_exact(tree, prefix);
   Deref_Prefix (prefix);
 
@@ -80,15 +110,26 @@ p_match (VALUE self, VALUE r_key)
   prefix_t *prefix;
   
   Data_Get_Struct(self, patricia_tree_t, tree);
-  prefix = ascii2prefix (AF_INET, STR2CSTR(r_key));
+  prefix = my_ascii2prefix (AF_INET, r_key);
   node = patricia_search_best(tree, prefix);
   Deref_Prefix (prefix);
 
-  if (node)
-    return Data_Wrap_Struct(cPatricia, 0, 0, node);
-  else 
-    return Qfalse;
+  return node ? wrap_node(node) : Qnil;
+}
+
+static VALUE
+p_include (VALUE self, VALUE r_key)
+{
+  patricia_tree_t *tree;
+  patricia_node_t *node;
+  prefix_t *prefix;
+
+  Data_Get_Struct(self, patricia_tree_t, tree);
+  prefix = my_ascii2prefix (AF_INET, r_key);
+  node = patricia_search_best(tree, prefix);
+  Deref_Prefix (prefix);
 
+  return node ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -99,14 +140,11 @@ p_match_exact (VALUE self, VALUE r_key)
   prefix_t *prefix;
 
   Data_Get_Struct(self, patricia_tree_t, tree);
-  prefix = ascii2prefix (AF_INET, STR2CSTR(r_key));
+  prefix = my_ascii2prefix (AF_INET, r_key);
   node = patricia_search_exact(tree, prefix);
   Deref_Prefix (prefix);
 
-  if (node)
-    return Data_Wrap_Struct(cPatricia, 0, 0, node);
-  else 
-    return Qfalse;
+  return node ? wrap_node(node) : Qnil;
 }
 
 static VALUE
@@ -116,33 +154,63 @@ p_num_nodes (VALUE self)
   patricia_tree_t *tree;
 
   Data_Get_Struct(self, patricia_tree_t, tree);
-  n = patricia_walk_inorder(tree->head, dummy);
+  n = tree->head ? patricia_walk_inorder(tree->head, dummy) : 0;
 
   return INT2NUM(n);
 }
 
+/* needed for Ruby 1.8.6, in 1.8.7 and later */
+#ifndef HAVE_RB_STR_SET_LEN
+static void
+rb_str_set_len(VALUE str, long len)
+{
+  RSTRING(str)->len = len;
+  RSTRING(str)->ptr[len] = '\0';
+}
+#endif
+
 static VALUE
-p_print_nodes (VALUE self)
+p_print_nodes (int argc, VALUE *argv, VALUE self)
 {
-  int n;
-  char buff[32];
+  ID id_printf = rb_intern("printf");
+  VALUE fmt = rb_str_new2("node: %s\n");
+  VALUE buf = rb_str_buf_new(128);
+  char *cbuf;
   patricia_tree_t *tree;
   patricia_node_t *node;
+  VALUE out;
   Data_Get_Struct(self, patricia_tree_t, tree);
 
-  PATRICIA_WALK(tree->head, node) {
-    prefix_toa2x(node->prefix, buff, 1);
-    printf("node: %s\n", buff);
-  } PATRICIA_WALK_END;
+  rb_scan_args(argc, argv, "01", &out);
+  if (NIL_P(out))
+    out = rb_stdout;
+
+  if (tree->head) {
+    PATRICIA_WALK(tree->head, node) {
+      rb_str_resize(buf, 128);
+      cbuf = RSTRING_PTR(buf);
+      prefix_toa2x(node->prefix, cbuf, 1);
+      rb_str_set_len(buf, strlen(cbuf));
+      rb_funcall(out, id_printf, 2, fmt, buf);
+    } PATRICIA_WALK_END;
+  }
   return Qtrue;
 }
 
 static VALUE
 p_data (VALUE self)
 {
+  VALUE user_data;
   patricia_node_t *node;
   Data_Get_Struct(self, patricia_node_t, node);
-  return rb_str_new2((char *)node->data);
+
+  user_data = (VALUE)node->data;
+
+  /* for backwards compatibility, we always dup and return new strings */
+  if (TYPE(user_data) == T_STRING)
+    user_data = rb_str_dup(user_data);
+
+  return user_data;
 }
 
 static VALUE
@@ -173,21 +241,75 @@ p_prefixlen (VALUE self)
   return INT2NUM(node->prefix->bitlen);
 }
 
+/* called during GC for each node->data attached to a Patricia tree */
+static void
+p_tree_mark_each(prefix_t *prefix, void *data)
+{
+  VALUE user_data = (VALUE)data;
+
+  rb_gc_mark(user_data);
+}
+
+static void
+p_tree_mark (void *ptr)
+{
+  patricia_tree_t *tree = ptr;
+
+  patricia_process(tree, p_tree_mark_each);
+}
+
+static void
+p_tree_free (void *ptr)
+{
+  patricia_tree_t *tree = ptr;
+
+  /* no need to explicitly free each node->data, GC will do it for us */
+  Destroy_Patricia(tree, NULL);
+}
+
 static VALUE
-p_new (VALUE self) 
+p_alloc(VALUE klass)
 {
   patricia_tree_t *tree;
   tree = New_Patricia(32); /* assuming only IPv4 */
-  return Data_Wrap_Struct(cPatricia, 0, 0, tree);
+
+  return Data_Wrap_Struct(klass, p_tree_mark, p_tree_free, tree);
+}
+
+static VALUE
+p_init_copy(VALUE self, VALUE orig)
+{
+  patricia_tree_t *orig_tree;
+
+  Data_Get_Struct(orig, patricia_tree_t, orig_tree);
+  if (orig_tree->head) {
+    patricia_tree_t *tree;
+    patricia_node_t *orig_node, *node;
+    prefix_t prefix;
+    VALUE user_data;
+
+    Data_Get_Struct(self, patricia_tree_t, tree);
+    PATRICIA_WALK(orig_tree->head, orig_node) {
+      node = patricia_lookup(tree, orig_node->prefix);
+      assert(node->prefix == orig_node->prefix);
+
+      user_data = (VALUE)(orig_node->data);
+      if (T_STRING == TYPE(user_data))
+        user_data = rb_str_dup(user_data);
+      PATRICIA_DATA_SET(node, user_data);
+    } PATRICIA_WALK_END;
+  }
 }
 
 void
 Init_rpatricia (void)
 {
   cPatricia = rb_define_class("Patricia", rb_cObject);
+  cNode = rb_define_class_under(cPatricia, "Node", rb_cObject);
 
-  /* create new Patricia object */
-  rb_define_singleton_method(cPatricia, "new", p_new, 0);
+  /* allocate new Patricia object, called before initialize  */
+  rb_define_alloc_func(cPatricia, p_alloc);
+  rb_define_method(cPatricia, "initialize_copy", p_init_copy, 1);
 
   /*---------- methods to tree ----------*/
   /* add string */
@@ -202,24 +324,27 @@ Init_rpatricia (void)
   rb_define_method(cPatricia, "match_exact", p_match_exact, 1); 
   rb_define_method(cPatricia, "search_exact", p_match_exact, 1); 
 
+  /* check existence */
+  rb_define_method(cPatricia, "include?", p_include, 1);
+
   /* removal */
   rb_define_method(cPatricia, "remove", p_remove, 1); 
   rb_define_method(cPatricia, "remove_node", p_remove, 1); 
 
   /* derivatives of climb */
   rb_define_method(cPatricia, "num_nodes", p_num_nodes, 0);
-  rb_define_method(cPatricia, "show_nodes", p_print_nodes, 0); 
+  rb_define_method(cPatricia, "show_nodes", p_print_nodes, -1);
 
   /* destroy tree */
   rb_define_method(cPatricia, "destroy", p_destroy, 0); 
   rb_define_method(cPatricia, "clear", p_destroy, 0); 
 
   /*---------- methods to node ----------*/
-  rb_define_method(cPatricia, "data", p_data, 0);
-  rb_define_method(cPatricia, "show_data", p_data, 0);
-  rb_define_method(cPatricia, "network", p_network, 0);
-  rb_define_method(cPatricia, "prefix", p_prefix, 0);
-  rb_define_method(cPatricia, "prefixlen", p_prefixlen, 0);
+  rb_define_method(cNode, "data", p_data, 0);
+  rb_define_method(cNode, "show_data", p_data, 0);
+  rb_define_method(cNode, "network", p_network, 0);
+  rb_define_method(cNode, "prefix", p_prefix, 0);
+  rb_define_method(cNode, "prefixlen", p_prefixlen, 0);
   //  rb_define_method(cPatricia, "family", p_family, 0); 
 
 }

data/rpatricia.gemspec

@@ -3,7 +3,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rpatricia}
-  s.version = %q{0.05} # remember to update Changes if this is changed
+  s.version = %q{0.06} # remember to update Changes if this is changed
 
   s.homepage = "http://www.goto.info.waseda.ac.jp/~tatsuya/rpatricia/"
 

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: rpatricia
 version: !ruby/object:Gem::Version 
-  version: "0.05"
+  hash: 7
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  version: "0.06"
 platform: ruby
 authors: 
 - Tatsuya Mori
@@ -10,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-15 00:00:00 +00:00
+date: 2010-09-15 00:00:00 +00:00
 default_executable: 
 dependencies: []
 
@@ -51,21 +56,27 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: module for fast IP address/prefix lookups