critbit 0.5.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4a9cf126486194ddb19ade53ae5d7f6ee8236e54
+  data.tar.gz: 157dca8040f2d55f98a98928af6c39b716a770f3
+SHA512:
+  metadata.gz: 5236e06a4c9a09e054dd6b4d5eb92eb8d756f690db8015f0ddfed0019d585022bda53108306cad1b8798a132baed1f2873d165b617424eb81566e2ba93104ab3
+  data.tar.gz: 7850a8a2add0fe4ea6c43e57859832e09f6a7ecd99e2f8f87e11d5a64ddb63736b05a10e385c0ae8e0d14de359d9e5e88f495bd9ff66ce75ad96064eec3903f9

data/LICENSE.txt

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Rodrigo Botafogo 
+
+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/README.md

@@ -0,0 +1,153 @@
+Announcement
+============
+
+Critbit version 0.5 has been realeased.  A crit bit tree, also known as a Binary Patricia
+Trie is a trie (https://en.wikipedia.org/wiki/Trie), also called digital tree and sometimes
+radix tree or prefix tree (as they
+can be searched by prefixes), is an ordered tree data structure that is used to store a
+dynamic set or associative array where the keys are usually strings. Unlike a binary search
+tree, no node in the tree stores the key associated with that node; instead, its position
+in the tree defines the key with which it is associated. All the descendants of a node have
+a common prefix of the string associated with that node, and the root is associated with
+the empty string. Values are normally not associated with every node, only with leaves and
+some inner nodes that correspond to keys of interest. For the space-optimized presentation
+of prefix tree, see compact prefix tree.
+
+[The following is from: http://cr.yp.to/critbit.html]
+
+A crit-bit tree supports the following operations (and more!) at high speed:
+
+  + See whether a string x is in the tree.
+  + Add x to the tree.
+  + Remove x from the tree.
+  + Find the lexicographically smallest string in the tree larger than x, if there is one.
+  + Find all suffixes of x in the tree, i.e., all strings in the tree that have x as a prefix. Of course, this can take a long time if there are many such strings, but each string is found quickly.
+  
+A crit-bit tree can be used as a high-speed associative array. For example, an array mapping
+54 to 1, 19 to 2, 99 to 3, 85 to 4, and 88 to 5 can be stored as a crit-bit tree containing
+54=1, 19=2, 99=3, 85=4, and 88=5. The smallest string in the crit-bit tree larger than 85= is
+85=4.
+
+The standard strategy for many years has been to store searchable data sets as hash tables,
+in applications that need exact searches but not lexicographic searches; or as heaps, in
+applications that need to search for the minimum; or as AVL trees, red-black trees, etc. in
+applications that do not fit the restrictions of hash tables and heaps.
+
+In Python, for example, the built-in "dict" data type is a hash table. Hash tables don't
+provide fast access to the smallest entry, so there's also a standard "heapq" library
+providing heaps. Heaps don't provide fast lookups of other entries, so there are various
+add-on libraries providing AVL trees and so on. A programmer who's happy creating a "dict"
+will simply do so, but then another programmer who wants fancier operations on the resulting
+database has to do an expensive conversion of the "dict" to a fancier data structure.
+
+I (D. J. Bernstein) have become convinced that this strategy should change. The revised
+strategy is much simpler: there should be one fundamental set-storage type, namely a crit-bit
+tree. Here's how a crit-bit tree stacks up against the competition:
+
+A hash table supports insertion, deletion, and exact searches. A crit-bit tree supports
+insertion, deletion, exact searches, and ordered operations such as finding the minimum.
+Another advantage is that a crit-bit tree guarantees good performance: it doesn't have any
+tricky slowdowns for unusual (or malicious) data.
+
+A heap supports insertion, deletion, and finding the minimum. A crit-bit tree supports
+insertion, deletion, finding the minimum, and exact searches, and general suffix searches.
+
+General-purpose comparison-based structures such as AVL trees and B-trees support exactly the
+same operations as a crit-bit tree. However, crit-bit trees are faster and simpler, especially
+for variable-length strings. B-trees advertise a memory layout that's friendly to your disk,
+but with less effort one can use a similar "clustering" organization for nodes in a crit-bit
+tree.
+
+If you're designing a programming language, imagine how much happier your programmers will be
+if your basic built-in data type allows not just looking up x, but also enumerating the
+strings after x in sorted order. You can't do this with hash tables. You could do it with an
+AVL tree, but your operations will be simpler and faster if you use a crit-bit tree.
+
+Critbit Interface
+=================
+
+This version of Critbit implements a very similar interface as the Hash interface with minor
+modifications when it makes sense to do so.  Besides implementing the Hash interface it also
+provides features for searching for keys that have a common prefix that are not possible
+with hashes.
+
+Here is an example of using Critbit:
+
+      crit = Critbit.new
+
+      # crit is space efficient and stores prefixes only once and can be used to
+      # find only strings that match a certain prefix
+      items = ["u", "un", "unh", "uni", "unj", "unim", "unin", "unio",
+               "uninc", "unind", "unine", "unindd", "uninde", "unindf",
+               "unindew", "unindex", "unindey", "a", "z"]
+
+      # add items to the container
+      items.each do |item|
+        crit[item] = item
+      end
+
+      # Does each for all elements in the critbit
+      print "["
+      crit.each do |key, value|
+        print "[#{key}, #{value}] "
+      end
+      print "]"
+
+Prints:
+
+      [[a, a] [u, u] [un, un] [unh, unh] [uni, uni] [unim, unim] [unin, unin] [uninc, uninc]
+      [unind, unind] [unindd, unindd] [uninde, uninde] [unindew, unindew] [unindex, unindex]
+      [unindey, unindey] [unindf, unindf] [unine, unine] [unio, unio] [unj, unj] [z, z] ].
+
+Observe that all elements are printed in sorted order, this is because critbit is
+naturally sorted.  This is one of the benefits of critbit over hashes.
+
+Critbits also allow for doing prefix traversal. In the next code example the critbit is
+traversed by only selecting strings that have "unin" as prefix, by passing the prefix as
+argument to 'each':
+
+      # Does each for all elements in the critbit
+      print "["
+      crit.each("unin") do |key, value|
+        print "[#{key}, #{value}] "
+      end
+      print "]"
+
+      [[unin, unin] [uninc, uninc] [unind, unind] [unindd, unindd] [uninde, uninde]
+       [unindew, unindew] [unindex, unindex] [unindey, unindey] [unindf, unindf]
+       [unine, unine] ].
+
+A critbit prefix can also be set by using method 'prefix=':
+
+      crit.prefix = "unin"
+
+      # Does each for all elements in the critbit
+      print "["
+      crit.each do |key, value|
+        print "[#{key}, #{value}] "
+      end
+      print "]"
+
+
+Critbit installation and download:
+==================================
+
+  + Install Jruby
+  + jruby –S gem install critbit
+
+Critbit Homepages:
+==================
+
+  + http://rubygems.org/gems/critbit
+  + https://github.com/rbotafogo/critbit/wiki
+
+Contributors:
+=============
+
+Contributors are welcome.
+
+Critbit History:
+================
+
+  + 05/04/2013: Version 0.5.0 – Initial release.
+

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rake/testtask'
+require_relative 'version'
+
+name = "#{$gem_name}-#{$version}.gem"
+
+rule '.class' => '.java' do |t|
+  sh "javac #{t.source}"
+end
+
+desc 'default task'
+task :default => [:install_gem]
+
+desc 'Makes a Gem'
+task :make_gem do
+  sh "gem build #{$gem_name}.gemspec"
+end
+
+desc 'Install the gem in the standard location'
+task :install_gem => [:make_gem] do
+  sh "gem install #{$gem_name}-#{$version}-java.gem"
+end
+
+desc 'Make documentation'
+task :make_doc do
+  sh "yard doc lib/*.rb lib/**/*.rb"
+end
+
+desc 'Push project to github'
+task :push do
+  sh "git push origin master"
+end
+
+desc 'Push gem to rubygem'
+task :push_gem do
+  sh "push #{name} -p $http_proxy"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/complete.rb']
+  t.ruby_opts = ["--server", "-Xinvokedynamic.constants=true", "-J-Xmn512m", 
+                 "-J-Xms1024m", "-J-Xmx1024m"]
+  t.verbose = true
+  t.warning = true
+end
+

data/config.rb

@@ -0,0 +1,173 @@
+require 'rbconfig'
+
+##########################################################################################
+# Configuration. Remove setting before publishing Gem.
+##########################################################################################
+
+# set to true if development environment
+# $DVLP = true
+
+# Set development dependency: those are gems that are also in development and thus not
+# installed in the gem directory.  Need a way of accessing them
+# $DVLP_DEPEND=["critbit"]
+
+# Set dependencies from other local gems provided in the vendor directory. 
+# $VENDOR_DEPEND=[]
+
+##########################################################################################
+
+# the platform
+@platform = 
+  case RUBY_PLATFORM
+  when /mswin/ then 'windows'
+  when /mingw/ then 'windows'
+  when /bccwin/ then 'windows'
+  when /cygwin/ then 'windows-cygwin'
+  when /java/
+    require 'java' #:nodoc:
+    if java.lang.System.getProperty("os.name") =~ /[Ww]indows/
+      'windows-java'
+    else
+      'default-java'
+    end
+  else 'default'
+  end
+
+#---------------------------------------------------------------------------------------
+# Add path to load path
+#---------------------------------------------------------------------------------------
+
+def mklib(path, home_path = true)
+  
+  if (home_path)
+    lib = path + "/lib"
+  else
+    lib = path
+  end
+  
+  $LOAD_PATH.insert(0, lib)
+
+end
+
+##########################################################################################
+# Prepare environment to work inside Cygwin
+##########################################################################################
+
+if @platform == 'windows-cygwin'
+  
+  #---------------------------------------------------------------------------------------
+  # Return the cygpath of a path
+  #---------------------------------------------------------------------------------------
+  
+  def set_path(path)
+    `cygpath -a -p -m #{path}`.tr("\n", "")
+  end
+  
+else
+  
+  #---------------------------------------------------------------------------------------
+  # Return  the path
+  #---------------------------------------------------------------------------------------
+  
+  def set_path(path)
+    path
+  end
+  
+end
+
+#---------------------------------------------------------------------------------------
+# Set the project directories
+#---------------------------------------------------------------------------------------
+
+class CritbitRB
+
+  @home_dir = File.expand_path File.dirname(__FILE__)
+
+  class << self
+    attr_reader :home_dir
+  end
+
+  @project_dir = CritbitRB.home_dir + "/.."
+  @doc_dir = CritbitRB.home_dir + "/doc"
+  @lib_dir = CritbitRB.home_dir + "/lib"
+  @src_dir = CritbitRB.home_dir + "/src"
+  @target_dir = CritbitRB.home_dir + "/target"
+  @test_dir = CritbitRB.home_dir + "/test"
+  @vendor_dir = CritbitRB.home_dir + "/vendor"
+  
+  class << self
+    attr_reader :project_dir
+    attr_reader :doc_dir
+    attr_reader :lib_dir
+    attr_reader :src_dir
+    attr_reader :target_dir
+    attr_reader :test_dir
+    attr_reader :vendor_dir
+  end
+
+  @build_dir = CritbitRB.src_dir + "/build"
+
+  class << self
+    attr_reader :build_dir
+  end
+
+  @classes_dir = CritbitRB.build_dir + "/classes"
+
+  class << self
+    attr_reader :classes_dir
+  end
+
+end
+
+#---------------------------------------------------------------------------------------
+# Set dependencies
+#---------------------------------------------------------------------------------------
+
+def depend(name)
+  
+  dependency_dir = CritbitRB.project_dir + "/" + name
+  mklib(dependency_dir)
+  
+end
+
+$VENDOR_DEPEND.each do |dep|
+  vendor_depend(dep)
+end if $VENDOR_DEPEND
+
+##########################################################################################
+# Config gem
+##########################################################################################
+
+if ($DVLP == true)
+
+  #---------------------------------------------------------------------------------------
+  # Set development dependencies
+  #---------------------------------------------------------------------------------------
+  
+  def depend(name)
+    dependency_dir = CritbitRB.project_dir + "/" + name
+    mklib(dependency_dir)
+  end
+
+  # Add dependencies here
+  # depend(<other_gems>)
+  $DVLP_DEPEND.each do |dep|
+    depend(dep)
+  end if $DVLP_DEPEND
+
+  #----------------------------------------------------------------------------------------
+  # If we need to test for coverage
+  #----------------------------------------------------------------------------------------
+  
+  if $COVERAGE == 'true'
+  
+    require 'simplecov'
+    
+    SimpleCov.start do
+      @filters = []
+      add_group "CritbitRB", "lib/mdarray"
+    end
+    
+  end
+
+end

data/lib/critbit.rb

@@ -0,0 +1,726 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# @author Rodrigo Botafogo
+#
+# Copyright © 2013 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation, without fee and without a signed 
+# licensing agreement, is hereby granted, provided that the above copyright notice, this 
+# paragraph and the following two paragraphs appear in all copies, modifications, and 
+# distributions.
+#
+# IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
+# THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
+# SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
+# RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
+# OR MODIFICATIONS.
+##########################################################################################
+
+require 'java'
+require_relative 'env'
+
+
+##########################################################################################
+#
+##########################################################################################
+
+class Critbit
+  include_package "io.prelink.critbit"
+  include_package "org.ardverk.collection"
+  include Enumerable
+  
+  attr_reader :java_critbit
+  attr_reader :default
+  attr_reader :default_proc
+  attr_reader :prefix
+  
+  # Critbit[ key, value, ... ] → new_hash
+  #
+  # Critbit[ [ [key, value], ... ] ] → new_hash
+  #
+  # Critbit[ object ] → new_hash
+  #
+  # Creates a new critbit populated with the given objects.
+  #
+  # Similar to the literal hash { key => value, ... }. In the first form, keys and values
+  # occur in pairs, so there must be an even number of arguments.
+  # 
+  # The second and third form take a single argument which is either an array of
+  # key-value pairs or an object convertible to a hash.
+  #
+  # @param args [Args] list of arguments in any of the above formats
+  # @return a new Critbit
+
+  def self.[](*args)
+
+    crit = Critbit.new
+    
+    if args.size == 1
+      
+      if ((args[0].is_a? Hash) || (args[0].is_a? Critbit))
+        args[0].each do |k, v|
+          crit[k] = v
+        end
+      elsif (args[0].is_a? Array)
+        args[0].each do |key_pair|
+          if ((key_pair.is_a? Array) && (key_pair.size == 2))
+            crit[key_pair[0]] = key_pair[1]
+          else
+            raise "Illegal argument for Critbit #{key_pair}"
+          end
+        end
+      else
+        raise "illegal argument for Critbit"
+      end
+      
+      return crit
+      
+    end
+    
+    if (args.size % 2 != 0)
+      raise "odd number of arguments for Critbit"
+    else
+      i = 0
+      begin
+        crit[args[i]] = args[i+1]
+        i += 2
+      end while i < args.size
+    end
+
+    return crit
+    
+  end
+  
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def self.try_convert(arg)
+    
+  end
+  
+  # new → new_critbit
+  #
+  # new(obj) → new_critbit
+  #
+  # new {|critbit, key| block } → new_critbit
+  #
+  # Returns a new, empty critbit. If this critbit is subsequently accessed by a key
+  # that doesn’t correspond to a critbit entry, the value returned depends on the
+  # style of new used to create the critbit. In the first form, the access returns
+  # nil. If obj is specified, this single object will be used for all default values.
+  # If a block is specified, it will be called with the critbit object and the key,
+  # and should return the default value. It is the block’s responsibility to store
+  # the value in the critbit if required.
+  # @param default [Default] the default return value if the key is not found
+  # @param block [Block] the default block to be executed if key is not found
+  # @return a new critbit
+  
+  def initialize(default = nil, &block)
+    @default = default
+    @default_proc = block
+    @prefix = nil
+    @java_critbit =  MCritBitTree.new(StringKeyAnalyzer.new)
+  end
+
+  # Element Reference—Retrieves the value object corresponding to the key object. If
+  # not found, returns the default value (see Hash::new for details).
+  # @param key (key) the key to be retrieved
+  # @return the value reference by this key or the default value or result of executing
+  # the default_proc
+
+  def[](key)
+    
+    val = retrieve(key)
+    if (val == nil)
+      val = @default
+      val = @default_proc.call(self, key, val) if @default_proc
+    end
+    val
+    
+  end
+
+  # Associates the value given by value with the key given by key.
+  # @param key [Key] the key element
+  # @param val [Value] the value associated with the key
+  # @return the value associated with the key
+
+  def[]=(key, val)
+    key = key.to_s if key.is_a? Symbol
+    @java_critbit.put(key, val)
+  end
+
+  alias store :[]=
+  
+  # Searches through the critbit comparing obj with the key using ==. Returns the
+  # key-value pair (two elements array) or nil if no match is found. See
+  # Array#assoc.
+  # @param key [Key] the key to search for
+  # @return Array with two elements [key, value]
+
+  def assoc(key)
+    [key, retrieve(key)]
+  end
+
+  # Removes all key-value pairs from critbit
+
+  def clear
+    @java_critbit.clear
+  end
+
+  # Returns the default value, the value that would be returned by critbit if key did
+  # not exist in critbit. See also Critbit::new and Critbit#default=
+  # @param val [Value] the default value to return
+
+  def default=(val)
+    @default = val
+  end
+  
+  # Sets the default proc to be executed on each failed key lookup.
+  # @param proc [Proc] the Proc to set as default_proc
+
+  def default_proc=(proc)
+    @default_proc = proc
+  end
+  
+  # Deletes the key-value pair and returns the value from critbit whose key is equal to
+  # key. If the key is not found, returns the default value. If the optional code block
+  # is given and the key is not found, pass in the key and return the result of block.
+  # @param key [Key]
+  # @return the value, the default value, or the result of applying the default block
+  # to key
+
+  def delete(key)
+
+    val = @java_critbit.remove(key)
+    # key not found
+    if (val == nil)
+      if block_given?
+        yield key
+      end
+      @default
+    end
+    val
+    
+  end
+
+  # Deletes every key-value pair from hsh for which block evaluates to true.
+  # 
+  # If no block is given, an enumerator is returned instead.
+
+  def delete_if(prefix = nil, &block)
+    
+    if block_given?
+      cursor = Critbit::DeleteCursor.new(self, true, &block)
+      _get(cursor, prefix)
+    else
+      to_enum(:each, prefix)
+    end
+    
+  end
+
+  alias reject! :delete_if
+    
+  # Calls block once for each key in critbit, passing the key-value pair as parameters.
+  #
+  # If no block is given, an enumerator is returned instead.
+
+  def each(prefix = nil, &block)
+
+    if block_given?
+      cursor = Critbit::EachCursor.new(&block)
+      _get(cursor, prefix)
+    else
+      to_enum(:each, prefix)
+    end
+    
+  end
+
+  alias each_pair :each
+
+  
+  # Calls block once for each key in critbit, passing the key as a parameter.
+  #
+  # If no block is given, an enumerator is returned instead.
+                     
+  def each_key(prefix = nil, &block)
+    
+    if block_given?
+      cursor = Critbit::EachKeyCursor.new(&block)
+      _get(cursor, prefix)
+    else
+      to_enum(:each, prefix)
+    end
+
+  end
+
+  # Calls block once for each value in critbit, passing the value as a parameter.
+  #
+  # If no block is given, an enumerator is returned instead.
+                     
+  def each_value(prefix = nil, &block)
+    
+    if block_given?
+      cursor = Critbit::EachValueCursor.new(&block)
+      _get(cursor, prefix)
+    else
+      to_enum(:each, prefix)
+    end
+
+  end
+
+  # Returns true if critbit contains no key-value pairs.
+  
+  def empty?
+    @size == 0
+  end
+
+  
+  def eql?(other)
+
+    cr1 = each
+    cr2 = other.each
+    
+    begin
+      p1 = cr1.next
+      p2 = cr2.next
+      if ((p1[0] != p2[0]) || (p1[1] != p2[1]))
+        return false
+      end
+    rescue StopIteration
+      break
+    end while true
+
+    i = 0
+    begin
+      cr1.next
+    rescue StopIteration
+      i += 1
+    end
+
+    begin
+      cr2.next
+    rescue StopIteration
+      i += 1
+    end
+
+    return false if i != 2
+    
+    return true
+    
+  end
+  
+  # Returns a value from the critbit for the given key. If the key can’t be found,
+  # there are several options: With no other arguments, it will raise an KeyError exception;
+  # if default is given, then that will be returned; if the optional code block is
+  # specified, then that will be run and its result returned.
+
+  def fetch(key, default = nil, &block)
+    
+    key = key.to_s if key.is_a? Symbol
+    res = @java_critbit.get(key)
+
+    if (res == nil)
+      if (default != nil)
+        return default
+      elsif (block_given?)
+        block.call(key)
+      else
+        raise KeyError, "key '#{key}' not found"
+      end
+    end
+    res
+    
+  end
+
+  # Returns a new array that is a one-dimensional flattening of this critbit. That is, for
+  # every key or value that is an array, extract its elements into the new array.  The
+  # optional level argument determines the level of recursion to flatten if the value is
+  # a hash.  If value is an Array it will call array.flatten
+  
+  def flatten(level = nil)
+
+    res = Array.new
+    each do |key, value|
+      res << key
+      case value
+      when (Array || Hash || Critbit)
+        (level)? res.concat(value.flatten(level)) : res.concat(value.flatten)
+      else
+        (value.respond_to?(:flatten))? res << value.flatten : res << value
+      end
+    end
+    res
+    
+  end
+  
+  # Returns true if the given key is present in critbit
+
+  def has_key?(key)
+    @java_critbit.containsKey(key)
+  end
+
+  # Returns true if the given key is present in critbit. Identical to has_key?
+
+  alias include? :has_key?
+  alias member? :has_key?
+  alias key? :has_key?
+  
+  # Returns true if the given value is present for some key in critbit.
+
+  def has_value?(val)
+    @java_critbit.containsValue(val)
+  end
+
+  # Return the contents of this critbit as a string.
+  
+  def inspect
+    
+    res = "{"
+    each do |key, value|
+      res << "\"#{key}\"=>#{value},"
+    end
+    res[-1] = "}"
+    return res
+    
+  end
+
+  # Return the contents of this critbit as a string.
+
+  alias to_s :inspect
+
+  # Returns a new critbit created by using critbit’s values as keys, and the keys as
+  # values.
+  
+  def invert
+    
+    crit = Critbit.new
+    each do |key, value|
+      crit[value.to_s] = key
+    end
+    crit
+    
+  end
+
+  # Deletes every key-value pair from critbit for which block evaluates to false.
+  
+  def keep_if(prefix = nil, &block)
+
+    if block_given?
+      cursor = Critbit::DeleteCursor.new(self, false, &block)
+      _get(cursor, prefix)
+    else
+      to_enum(:each, prefix)
+    end
+    
+  end
+
+  alias select! :keep_if
+  
+  # Returns the key of an occurrence of a given value. If the value is not found,
+  # returns nil.
+
+  def key(val)
+    
+    each do |key, value|
+      return key if (value == val)
+    end
+    return nil
+    
+  end
+
+  # Returns a new array populated with the keys from this critbit
+
+  def keys(prefix = nil)
+    cursor = Critbit::ListCursor.new(:key)
+    _get(cursor, prefix).list
+  end
+
+  # Returns a new critbit containing the contents of other_critbit and the contents
+  # of critbit. If no block is specified, the value for entries with duplicate keys will be
+  # that of other_critbit. Otherwise the value for each duplicate key is determined by
+  # calling the block with the key, its value in critbit and its value in other_critbit.
+
+  def merge(other_critbit, &block)
+
+    crit = Critbit[self]
+    if (block_given?)
+      other_critbit.each do |key, value|
+        value = block.call(key, self[key], value) if has_key?(key)
+        crit[key] = value
+      end
+    else
+      other_critbit.each do |key, value|
+        crit[key] = value
+      end
+    end
+    crit
+      
+  end
+
+  alias update :merge
+  
+  # Returns a new critbit containing the contents of other_critbit and the contents
+  # of critbit. If no block is specified, the value for entries with duplicate keys will be
+  # that of other_critbit. Otherwise the value for each duplicate key is determined by
+  # calling the block with the key, its value in critbit and its value in other_critbit.
+
+  def merge!(other_critbit, &block)
+
+    if (block_given?)
+      other_critbit.each do |key, value|
+        value = block.call(key, self[key], value) if has_key?(key)
+        self[key] = value
+      end
+    else
+      other_critbit.each do |key, value|
+        self[key] = value
+      end
+    end
+    self
+      
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def prefix=(pre)
+    @prefix = pre
+  end
+  
+  # Searches through the critbit comparing obj with the value using ==. Returns the first
+  # key-value pair (two-element array) that matches. See also Array#rassoc.
+
+  def rassoc(obj)
+
+    each do |key, value|
+      return [key, value] if obj == value
+    end
+    nil
+    
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def size
+    @java_critbit.size()
+  end
+
+  alias length :size
+  
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def values(prefix = nil)
+    cursor = Critbit::ListCursor.new(:value)
+    _get(cursor, prefix).list
+  end
+  
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  # Methods that are not in Hash interface
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def min
+    @java_critbit.min
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def max
+    @java_critbit.max
+  end
+
+  #------------------------------------------------------------------------------------
+  # Merges the two critbits. Should be significantly faster than method merge.
+  #------------------------------------------------------------------------------------
+
+  def put_all(other_critbit)
+    @java_critbit.putAll(other_critbit.java_critbit)
+  end
+  
+  #------------------------------------------------------------------------------------
+  # Removes the key value pair from the critbit.  If no key is found, nil is returned.
+  #------------------------------------------------------------------------------------
+
+  def remove(key)
+    @java_critbit.remove(key)
+  end
+  
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  private
+  
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def retrieve(key)
+    key = key.to_s if key.is_a? Symbol
+    @java_critbit.get(key)
+  end
+  
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def _get(cursor, prefix = nil)
+    prefix ||= @prefix
+    (prefix)? @java_critbit.traverseWithPrefix(prefix, cursor) :
+      @java_critbit.traverse(cursor)
+    cursor
+  end
+
+  ##########################################################################################
+  #
+  ##########################################################################################
+
+  class Cursor
+    include org.ardverk.collection.Cursor
+    
+    attr_reader :key
+    attr_reader :value
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+    
+    def initialize(&block)
+      @block = block
+    end
+
+  end
+
+  ##########################################################################################
+  #
+  ##########################################################################################
+  
+  class EachCursor < Cursor
+    
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+    
+    def select(entry)
+      @block.call(entry.getKey(), entry.getValue())
+      Decision::CONTINUE
+    end
+    
+  end
+
+  ##########################################################################################
+  #
+  ##########################################################################################
+  
+  class EachKeyCursor < Cursor
+    
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+    
+    def select(entry)
+      @block.call(entry.getKey())
+      Decision::CONTINUE
+    end
+    
+  end
+
+  ##########################################################################################
+  #
+  ##########################################################################################
+  
+  class EachValueCursor < Cursor
+    
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+    
+    def select(entry)
+      @block.call(entry.getValue())
+      Decision::CONTINUE
+    end
+    
+  end
+  
+  ##########################################################################################
+  #
+  ##########################################################################################
+  
+  class DeleteCursor < Cursor
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+    
+    def initialize(critbit, t_val = true, &block)
+      @critbit = critbit
+      @t_val = t_val
+      super(&block)
+    end
+    
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+    
+    def select(entry)
+      @critbit.delete(entry.getKey()) if (@block.call(entry.getKey(),
+                                                      entry.getValue()) == @t_val)
+      Decision::CONTINUE
+    end
+    
+  end
+
+  ##########################################################################################
+  #
+  ##########################################################################################
+  
+  class ListCursor < Cursor
+    
+    attr_reader :list
+    attr_reader :type
+    
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+    
+    def initialize(type)
+      
+      if (type != :key && type != :value)
+        raise "Illegal type #{type}"
+      end
+      
+      @type = type
+      @list = Array.new
+      
+    end
+    
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+    
+    def select(entry)
+      @list << ((@type == :key)? entry.getKey() : entry.getValue())
+      Decision::CONTINUE
+    end
+    
+  end
+  
+end