triez 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8624d508bf82330cf354730f21341f21c7e0989b
-  data.tar.gz: cc9e500bf179457d77361acef1c399da936b0375
+  metadata.gz: 88f05351da6b711cefe44c0e5060f5c04380e5b6
+  data.tar.gz: 41ff89af13fd30d8def221fa396d1097816f39c1
 SHA512:
-  metadata.gz: c73e070211b80ceb0c50fb0af6c09bc726b9ffe1a396d4faf104a74bad75d4a2484606444636c9d5c9390a0d1b28f6eca4c656aef422411e2c8c83984ff4894c
-  data.tar.gz: bdf8cc170ce95ba7370b2d163730ce42b78a2a84de823cfdcfe220f07898aa8a08385819acd01e217ce829fc44ca662845776f4de33297c69ef7a5daf4cf7b4a
+  metadata.gz: b8047e6c017a559b9916dfcdf235f39b560e486d190a14963a32c2cf565725f128e26c2b3f07d83273fe79ab566349220cc048a1eec347f35aa6308832887124
+  data.tar.gz: 8f64787cd1db06201d18e5ddc235d960a5ab6d08a63c212e13619094c47bc688feb59ababc950ec4e70bc8382ff89a255154a03913eb16ac784690aeb2d6f787

data/changes

@@ -1,3 +1,10 @@
+1.0.2
+
+2013-06-01
+  add #walk
+2013-05-31
+  fix rb_gc_mark() stuck for value_type: :object
+
 1.0.1
 
 2013-05-30

data/ext/hat-trie/hat-trie.c

@@ -408,6 +408,60 @@ value_t* hattrie_tryget(hattrie_t* T, const char* key, size_t len)
 }
 
 
+void hattrie_walk (hattrie_t* T, const char* key, size_t len, void* user_data, hattrie_walk_cb cb) {
+    unsigned char* k = (unsigned char*)key;
+    node_ptr node = T->root;
+    size_t i, j;
+    ahtable_iter_t* it;
+
+    /* go down until a bucket is reached */
+    for (i = 0; i < len; i++, k++) {
+        if (!(*node.flag & NODE_TYPE_TRIE))
+            break;
+        node = node.t->xs[*k];
+        if (*node.flag & NODE_HAS_VAL) {
+            if (hattrie_walk_stop == cb(key, i, &node.t->val, user_data))
+                return;
+        }
+    }
+    if (i == len)
+        return;
+
+    assert(i);
+    if (*node.flag & NODE_TYPE_HYBRID_BUCKET) {
+        i--;
+        k--;
+    } else {
+        assert(*node.flag & NODE_TYPE_PURE_BUCKET);
+    }
+
+    /* dict order ensured short => long */
+    it = ahtable_iter_begin(node.b, true);
+    for(; !ahtable_iter_finished(it); ahtable_iter_next(it)) {
+        size_t stored_len;
+        unsigned char* stored_key = (unsigned char*)ahtable_iter_key(it, &stored_len);
+        int matched = 1;
+        if (stored_len + i > len) {
+            continue;
+        }
+        for (j = 0; j < stored_len; j++) {
+            if (stored_key[j] != k[j]) {
+                matched = 0;
+                break;
+            }
+        }
+        if (matched) {
+            value_t* val = ahtable_iter_val(it);
+            if (hattrie_walk_stop == cb(key, i + stored_len, val, user_data)) {
+                ahtable_iter_free(it);
+                return;
+            }
+        }
+    }
+    ahtable_iter_free(it);
+}
+
+
 int hattrie_del(hattrie_t* T, const char* key, size_t len)
 {
     node_ptr parent = T->root;
@@ -545,7 +599,9 @@ static void hattrie_iter_nextnode(hattrie_iter_t* i)
 }
 
 
-// TODO pick a better name
+/** next non-nil-key node
+ * TODO pick a better name
+ */
 static void hattrie_iter_step(hattrie_iter_t* i)
 {
     while (((i->i == NULL || ahtable_iter_finished(i->i)) && !i->has_nil_key) &&

data/ext/hat-trie/hat-trie.h

@@ -46,11 +46,22 @@ size_t hattrie_size (hattrie_t*);
  */
 value_t* hattrie_get (hattrie_t*, const char* key, size_t len);
 
-
 /** Find a given key in the table, returning a NULL pointer if it does not
  * exist. */
 value_t* hattrie_tryget (hattrie_t*, const char* key, size_t len);
 
+/** hattrie_walk callback signature */
+typedef int (*hattrie_walk_cb)(const char* key, size_t len, value_t* val, void* user_data);
+
+/** hattrie_walk callback return values, controls whether should stop the walk or not */
+#define hattrie_walk_stop 0
+#define hattrie_walk_continue 1
+
+/** Find stored keys which are prefices of key, and invoke callback for every found key and val.
+ *  The invocation order is: short key to long key.
+ */
+void hattrie_walk (hattrie_t*, const char* key, size_t len, void* user_data, hattrie_walk_cb);
+
 /** Delete a given key from trie. Returns 0 if successful or -1 if not found.
  */
 int hattrie_del(hattrie_t* T, const char* key, size_t len);
@@ -64,6 +75,8 @@ void            hattrie_iter_free      (hattrie_iter_t*);
 const char*     hattrie_iter_key       (hattrie_iter_t*, size_t* len);
 value_t*        hattrie_iter_val       (hattrie_iter_t*);
 
+/** Note the hattrie_iter_key() for prefixed search gets the suffix instead of the whole key
+ */
 hattrie_iter_t* hattrie_iter_with_prefix(const hattrie_t*, bool sorted, const char* prefix, size_t prefix_len);
 
 #ifdef __cplusplus
@@ -71,5 +84,3 @@ hattrie_iter_t* hattrie_iter_with_prefix(const hattrie_t*, bool sorted, const ch
 #endif
 
 #endif
-
-

data/ext/triez.cc

@@ -62,6 +62,7 @@ static void hat_mark(void* p_ht) {
         if (!IMMEDIATE_P(*v)) {
             rb_gc_mark(*v);
         }
+        hattrie_iter_next(it);
     }
     hattrie_iter_free(it);
 }
@@ -247,6 +248,30 @@ static VALUE hat_search(VALUE self, VALUE key, VALUE vlimit, VALUE vsort, VALUE
     return self;
 }
 
+typedef struct {
+    bool obj_value;
+    VALUE arr;
+} HatWalkData;
+
+static int hat_walk_cb(const char* key, size_t len, value_t* v, void* data_p) {
+    HatWalkData* data = (HatWalkData*)data_p;
+    volatile VALUE r = rb_ary_new();
+    rb_ary_push(r, rb_str_new(key, len));
+    rb_ary_push(r, data->obj_value ? (*v) : LL2NUM(*v));
+    rb_ary_push(data->arr, r);
+    return hattrie_walk_continue;
+}
+
+static VALUE hat_walk(VALUE self, VALUE key) {
+    PRE_HAT;
+    size_t len = (size_t)RSTRING_LEN(key);
+    volatile HatWalkData data = {ht->obj_value, rb_ary_new()};
+
+    // to prevent leak by break/next, we have to collect the array first
+    hattrie_walk(p, RSTRING_PTR(key), len, (void*)&data, hat_walk_cb);
+    return data.arr;
+}
+
 #define DEF(k,n,f,c) rb_define_method(k,n,RUBY_METHOD_FUNC(f),c)
 
 extern "C"
@@ -266,4 +291,5 @@ void Init_triez() {
     DEF(hat_class, "has_key?", hat_check, 1);
     DEF(hat_class, "delete", hat_del, 1);
     DEF(hat_class, "_internal_search", hat_search, 4);
+    DEF(hat_class, "_internal_walk", hat_walk, 1);
 }

data/lib/triez.rb

@@ -1,10 +1,11 @@
 require_relative "../ext/triez"
 
 class Triez
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 
   private :_internal_set_type
   private :_internal_search
+  private :_internal_walk
 
   def initialize opts={}
     opts = opts.dup
@@ -36,6 +37,10 @@ class Triez
     _internal_search '', nil, true, p
   end
 
+  def walk s, &p
+    _internal_walk(s).each &p
+  end
+
   def search_with_prefix prefix, opts={}, &p
     opts  = opts.dup
 

data/readme.md

@@ -74,6 +74,11 @@ t.search_with_prefix('prefix')
 t.each do |key, value|
   ...
 end
+
+# iterate stored keys which are prefices of a given string, from shallow to deep
+t.walk string do |k, v|
+  ...
+end
 ```
 
 \* Note: By default, *triez* store signed integers within 64bits, you can use them as weights, counts or database IDs. In case you need to store arbitrary object in a node, use `value_type: :object`:
@@ -206,6 +211,13 @@ rake glob_src
 rake
 ```
 
+To update vendor lib and re-compile:
+
+``` bash
+rake glob_src
+rake
+```
+
 ## Note
 
 Although HAT trie uses MurMurHash3 instead of SipHash in Ruby, It is still safe under hashDoS because bucket size is limited.

data/test/triez_test.rb

@@ -157,6 +157,34 @@ class TriezTest < Test::Unit::TestCase
     assert_equal %w[a b c ab bc abc].sort, keys.sort
   end
 
+  def test_walk
+    urls = %w[
+      /users/
+      /users/12/edit
+      /posts
+    ]
+    t = Triez.new value_type: :object
+    urls.each_with_index do |url, i|
+      t[url] = i.to_s
+    end
+
+    assert_equal [%w'/users/ 0'], t.walk('/users/12/delete').to_a
+    assert_equal [%w'/users/ 0', %w'/users/12/edit 1'], t.walk('/users/12/edit').to_a
+    assert_equal [%w'/users/ 0', %w'/users/12/edit 1'], t.walk('/users/12/edit/3').to_a
+
+    assert_raise TypeError do
+      t.walk :'/post' do
+      end
+    end
+
+    t.walk '' do |k, v|
+      assert_equal [nil, nil], [k, v]
+    end
+
+    # try to trigger rb_gc_mark(), it can stuck if hattrie_iter_next() not called properly
+    100000.times{ 'a' + 'b' }
+  end
+
   def test_solve_longest_common_substring
     sentences = %w[
       万塘路一锅鸡

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: triez
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Zete Lui
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-29 00:00:00.000000000 Z
+date: 2013-05-31 00:00:00.000000000 Z
 dependencies: []
 description: fast, efficient, unicode aware HAT trie with prefix / suffix support.
 email: