radix_tree 1.0.0 → 1.1.0.dev

data/README

@@ -7,17 +7,13 @@ to avoid DoS via Algorithmic Complexity Attacks.
 
 == Performance
 
-* 25 times slower for 10 bytes key, 100000 elements insertion
+* 20 times slower for 10 bytes key, 100000 elements insertion
 * 10 times slower for 10 bytes key, 100000 elements retrieval
 
 
 == TODO
 
-Implement following features for utilizing strength of Radix Tree.
-* find predecessor
-* find successor
-* find_all by start string
-* delete_all by start string
+See comments in lib/radix_tree.rb
 
 
 == Author

data/lib/radix_tree.rb

@@ -30,11 +30,16 @@ class RadixTree
   class Node
     UNDEFINED = Object.new
 
-    attr_reader :key, :value
+    attr_reader :key, :index
+    attr_reader :value
     attr_reader :children
 
-    def initialize(key, value = UNDEFINED, children = nil)
-      @key, @value, @children = key, value, children
+    def initialize(key, index, value = UNDEFINED, children = nil)
+      @key, @index, @value, @children = key, index, value, children
+    end
+
+    def label
+      @key[0, @index]
     end
 
     def undefined?
@@ -54,49 +59,63 @@ class RadixTree
       end
     end
 
-    def each(prefix, &block)
-      prefix += @key
+    def each(&block)
       if @value != UNDEFINED
-        block.call(prefix, @value)
+        block.call [label, @value]
       end
       if @children
-        @children.each do |key, child|
-          child.each(prefix, &block)
+        @children.each_value do |child|
+          child.each(&block)
         end
       end
     end
+    
+    def each_key
+      each do |k, v|
+        yield k
+      end
+    end
+    
+    def each_value
+      each do |k, v|
+        yield v
+      end
+    end
 
-    def keys(prefix)
-      collect(prefix) { |k, v| k }
+    def keys
+      collect { |k, v| k }
     end
 
-    def values(prefix)
-      collect(prefix) { |k, v| v }
+    def values
+      collect { |k, v| v }
     end
 
     def store(key, value)
-      if @key == key
+      if same_key?(key)
         @value = value
       else
-        index = head_match_length(key)
-        if index == @key.size
-          push(key[index..-1], value)
+        pos = head_match_length(key)
+        if pos == @index
+          push(key, value)
         else
-          split(index)
-          # search again after split the node
-          store(key, value)
+          split(pos)
+          if same_key?(key)
+            @value = value
+          else
+            push(key, value)
+          end
         end
       end
     end
 
     def retrieve(key)
-      if @key == key
+      if same_key?(key)
         @value
       elsif !@children
         UNDEFINED
       else
-        key = child_key(key)
-        if child = find_child(key)
+        pos = head_match_length(key)
+        if child = find_child(key[pos])
           child.retrieve(key)
         else
           UNDEFINED
@@ -105,14 +124,14 @@ class RadixTree
     end
 
     def delete(key)
-      if @key == key
+      if same_key?(key)
         value, @value = @value, UNDEFINED
         value
       elsif !@children
         nil
       else
-        key = child_key(key)
-        if child = find_child(key)
+        pos = head_match_length(key)
+        if child = find_child(key[pos])
           value = child.delete(key)
           if value and child.undefined?
             reap(child)
@@ -122,44 +141,46 @@ class RadixTree
       end
     end
 
-    def dump_tree(io, prefix = '', indent = '')
-      prefix += @key
+    def dump_tree(io, indent = '')
       indent += '  '
       if undefined?
-        io << sprintf("#<%s:0x%010x %s>", self.class.name, __id__, prefix.inspect)
+        io << sprintf("#<%s:0x%010x %s>", self.class.name, __id__, label.inspect)
       else
-        io << sprintf("#<%s:0x%010x %s> => %s", self.class.name, __id__, prefix.inspect, @value.inspect)
+        io << sprintf("#<%s:0x%010x %s> => %s", self.class.name, __id__, label.inspect, @value.inspect)
       end
       if @children
         @children.each do |k, v|
           io << $/ + indent
-          v.dump_tree(io, prefix, indent)
+          v.dump_tree(io, indent)
         end
       end
     end
 
     private
 
-    def collect(prefix)
+    def same_key?(key)
+      @index == key.size and @key.start_with?(key)
+    end
+
+    def collect
       pool = []
-      each(prefix) do |key, value|
+      each do |key, value|
         pool << yield(key, value)
       end
       pool
     end
 
     def push(key, value)
-      if child = find_child(key)
+      if @children && child = find_child(key[@index])
         child.store(key, value)
       else
-        add_child(Node.new(key, value))
+        add_child(Node.new(key, key.size, value))
       end
     end
 
-    def split(index)
-      @key, new_key = @key[0, index], @key[index..-1]
-      child = Node.new(new_key, @value, @children)
-      @value, @children = UNDEFINED, nil
+    def split(pos)
+      child = Node.new(@key, @index, @value, @children)
+      @index, @value, @children = pos, UNDEFINED, nil
       add_child(child)
     end
 
@@ -169,38 +190,32 @@ class RadixTree
       elsif child.children.size == 1
         # pull up the grand child as a child
         delete_child(child)
-        grand = child.children.values.first
-        add_child(Node.new(child.key + grand.key, grand.value, grand.children))
+        add_child(child.children.shift[1])
       end
     end
 
-    def child_key(key)
-      key[head_match_length(key)..-1]
-    end
-
-    # assert: check != @key
     def head_match_length(check)
-      0.upto(check.size) do |index|
-        if check[index] != @key[index]
-          return index
+      0.upto(@index) do |idx|
+        if check[idx] != @key[idx]
+          return idx
         end
       end
-      raise 'assert: check != @key'
+      @index
     end
 
-    def find_child(key)
-      if @children
-        @children[key[0]]
-      end
+    def find_child(char)
+      @children[char]
     end
 
     def add_child(child)
+      char = child.key[@index]
       @children ||= {}
-      @children[child.key[0]] = child
+      @children[char] = child
     end
 
     def delete_child(child)
-      @children.delete(child.key[0])
+      char = child.key[@index]
+      @children.delete(char)
       if @children.empty?
         @children = nil
       end
@@ -216,7 +231,7 @@ class RadixTree
     if block && default != DEFAULT
       raise ArgumentError, 'wrong number of arguments'
     end
-    @root = Node.new('')
+    @root = Node.new('', 0)
     @default = default
     @default_proc = block
   end
@@ -232,58 +247,46 @@ class RadixTree
 
   def each(&block)
     if block_given?
-      @root.each('', &block)
+      @root.each(&block)
       self
     else
-      Enumerator.new { |yielder|
-        @root.each('') do |k, v|
-          yielder << [k, v]
-        end
-      }
+      Enumerator.new(@root)
     end
   end
   alias each_pair each
 
   def each_key
     if block_given?
-      @root.each('') do |k, v|
+      @root.each do |k, v|
         yield k
       end
       self
     else
-      Enumerator.new { |yielder|
-        @root.each('') do |k, v|
-          yielder << k
-        end
-      }
+      Enumerator.new(@root, :each_key)
     end
   end
 
   def each_value
     if block_given?
-      @root.each('') do |k, v|
+      @root.each do |k, v|
         yield v
       end
       self
     else
-      Enumerator.new { |yielder|
-        @root.each('') do |k, v|
-          yielder << v
-        end
-      }
+      Enumerator.new(@root, :each_value)
     end
   end
 
   def keys
-    @root.keys('')
+    @root.keys
   end
 
   def values
-    @root.values('')
+    @root.values
   end
 
   def clear
-    @root = Node.new('')
+    @root = Node.new('', 0)
   end
 
   def []=(key, value)

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: radix_tree
 version: !ruby/object:Gem::Version
-  version: 1.0.0
-  prerelease: 
+  version: 1.1.0.dev
+  prerelease: 6
 platform: ruby
 authors:
 - Hiroshi Nakamura
@@ -33,18 +33,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -966188071225850011
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: -966188071225850011
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.11