rbtree 0.2.0 → 0.2.1

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2002-2004, 2007 OZAWA Takuma
+Copyright (c) 2002-2004, 2007, 2009 OZAWA Takuma
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/README

@@ -2,10 +2,10 @@
 
 = Ruby/RBTree
 
-RBTree is a sorted associative collection using Red-Black Tree as
-the internal data structure. The elements of RBTree are ordered and
-the interface is the almost same as Hash, so simply you can
-consider RBTree sorted Hash.
+RBTree is a sorted associative collection that is implemented with
+Red-Black Tree. The elements of RBTree are ordered and its interface
+is the almost same as Hash, so simply you can consider RBTree sorted
+Hash.
 
 Red-Black Tree is a kind of binary tree that automatically balances
 by itself when a node is inserted or deleted. Thus the complexity
@@ -14,28 +14,48 @@ case. On the other hand the complexity of Hash is O(1). Because
 Hash is unordered the data structure is more effective than
 Red-Black Tree as an associative collection.
 
-The interface of RBTree is the almost same as Hash although there
-are some limitations.
-
-  * While iterating (e.g. in RBTree#each block), RBTree is
-    unmodifiable.
-
-  * Comparison is done using <=> method of key objects. So all types
-    of keys in RBTree should be comparable each other or an arbitrary
-    Proc might be set by RBTree#readjust.
-
-RBTree has a few searching methods that Hash doesn't have. They are
-RBTree#lower_bound, RBTree#upper_bound and RBTree#bound. See document
-of each method for details.
-
-Pretty printing is available for RBTree by using pp.rb. The output
-of pp is easier than p to read. Just call Kernel#pp for the object.
-
-MultiRBTree that allows duplicates of keys is also available.
+The elements of RBTree are sorted with natural ordering (by <=>
+method) of its keys or by a comparator(Proc) set by readjust
+method. It means all keys in RBTree should be comparable with each
+other. Or a comparator that takes two arguments of a key should return
+negative, 0, or positive depending on the first argument is less than,
+equal to, or greater than the second one.
+
+The interface of RBTree is the almost same as Hash and there are a
+few methods to take advantage of the ordering:
+
+  * lower_bound, upper_bound, bound
+  * first, last
+  * shift, pop
+  * reverse_each
+
+Note: while iterating RBTree (e.g. in a block of each method), it is
+not modifiable, or TypeError is thrown.
+
+RBTree supoorts pretty printing using pp.
+
+This library contains two classes. One is RBTree and the other is
+MultiRBTree that is a parent class of RBTree. RBTree does not allow
+duplications of keys but MultiRBTree does.
+
+  require "rbtree"
+  
+  rbtree = RBTree["c", 10, "a", 20]
+  rbtree["b"] = 30
+  p rbtree["b"]              # => 30
+  rbtree.each do |k, v|
+    p [k, v]
+  end                        # => ["a", 20] ["b", 30] ["c", 10]
+    
+  mrbtree = MultiRBTree["c", 10, "a", 20, "e", 30, "a", 40]
+  p mrbtree.lower_bound("b") # => ["c", 10]
+  mrbtree.bound("a", "d") do |k, v|
+    p [k, v]
+  end                        # => ["a", 20] ["a", 40] ["c", 10]
 
 == Requirement
 
-  * Ruby 1.6.7 or higher
+  * Ruby 1.8.x
 
 == Install
 
@@ -43,7 +63,7 @@ MultiRBTree that allows duplicates of keys is also available.
 
 or download a tarball from the link below
 
-  * ((<"Ruby/RBTree 0.2.0"|URL:rbtree-0.2.0.tar.gz>))
+  * ((<"Ruby/RBTree 0.2.1"|URL:rbtree-0.2.1.tar.gz>))
 
 and then
 
@@ -57,13 +77,15 @@ and then
 
   $ ruby test.rb
 
-== Incomplete Document
+== Incomplete Documents
 
   $ rdoc rbtree.c
 
+or online documents at ((<URL:http://rbtree.rubyforge.org/>)).
+
 == License
 
-MIT License. Copyright (c) 2002-2004, 2007 OZAWA Takuma.
+MIT License. Copyright (c) 2002-2004, 2007, 2009 OZAWA Takuma.
 
 dict.c and dict.h are modified copies that are originally in Kazlib
 written by Kaz Kylheku. Copyright is held by Kaz Kylheku, see dict.c
@@ -75,4 +97,10 @@ and dict.h for the license. The web page of Kazlib is at
 Bug fixes, suggestions and other feedbacks are welcomed. Please mail
 me at burningdowntheopera at yahoo dot co dot jp.
 
+== Links
+
+  * ((<RAA - ruby-rbtree|URL:http://raa.ruby-lang.org/project/ruby-rbtree/>))
+  * ((<RubyForge: rbtree: Project Info|URL:http://rubyforge.org/projects/rbtree/>))
+  * ((<URL:http://www.geocities.co.jp/SiliconValley-PaloAlto/3388/rbtree/README.html>))
+
 =end

data/extconf.rb

@@ -1,34 +1,11 @@
 require 'mkmf'
-require 'rbconfig'
 
-if Config::CONFIG['CC'] =~ /gcc/
+if $DEBUG
   $CFLAGS << ' -std=c89 -pedantic -Wall -Wno-long-long'
-end
-
-$defs << '-DNDEBUG'
-
-print 'checking for allocation framework... '
-if Object.respond_to?(:allocate)
-  print "yes\n"
-  $defs << '-DHAVE_OBJECT_ALLOCATE'
+  $defs << ' -Dinline=__inline'
 else
-  print "no\n"
+  $defs << '-DNDEBUG'
 end
 
-have_func('rb_obj_init_copy')
-have_func('rb_block_proc')
-have_func('rb_yield_values')
-have_func('rb_marshal_dump')
-have_func('rb_marshal_load')
-
-print 'checking for inline keyword... '
-inline = ['inline', '__inline', '__inline__', ''].find {|e|
-  try_link(<<EOS)
-int main() { return 0; }
-#{e} void foo() {}
-EOS
-}
-print "#{inline}\n"
-$defs << "-Dinline=#{inline}"
-
+have_func('rb_enumeratorize')
 create_makefile('rbtree')

data/rbtree.c

@@ -1,6 +1,6 @@
 /*
  * MIT License
- * Copyright (c) 2002-2004, 2007 OZAWA Takuma
+ * Copyright (c) 2002-2004, 2007, 2009 OZAWA Takuma
  */
 #include <ruby.h>
 #include <version.h>
@@ -8,12 +8,11 @@
 #include <stdarg.h>
 #include "dict.h"
 
-#define RBTREE_IN_ITERATION FL_USER1
 #define RBTREE_PROC_DEFAULT FL_USER2
 #define HASH_PROC_DEFAULT   FL_USER2
 
-#ifndef ULONG2NUM
-#define ULONG2NUM UINT2NUM
+#ifndef HAVE_RB_ENUMERATORIZE
+#define RETURN_ENUMERATOR(obj, argc, argv) ((void)0)
 #endif
 
 VALUE RBTree;
@@ -24,12 +23,6 @@ static ID id_cmp;
 static ID id_call;
 static ID id_default;
 
-#ifndef HAVE_RB_MARSHAL_DUMP
-static VALUE rb_mMarshal;
-static ID id_dump;
-static ID id_load;
-#endif
-
 typedef struct {
     dict_t* dict;
     VALUE ifnone;
@@ -51,41 +44,12 @@ typedef struct {
 
 /*********************************************************************/
 
-#ifndef HAVE_RB_BLOCK_PROC
-static VALUE
-rb_block_proc()
-{
-    return rb_f_lambda();
-}
-#endif
-
-#ifndef HAVE_RB_YIELD_VALUES
-static VALUE
-rb_yield_values(int n, ...)
-{
-    int i;
-    va_list ap;
-    VALUE ary = rb_ary_new2(n);
-
-    va_start(ap, n);
-    for (i = 0; i < n; i++)
-        rb_ary_push(ary, va_arg(ap, VALUE));
-    va_end(ap);
-    return rb_yield(ary);
-}
-#endif
-
 static int
 cmpint(VALUE i, VALUE a, VALUE b)
 {
-#if RUBY_VERSION_CODE >= 180
     return rb_cmpint(i, a, b);
-#else
-    return rb_cmpint(i);
-#endif
 }
 
-
 static void
 rbtree_free(rbtree_t* rbtree)
 {
@@ -187,19 +151,6 @@ VALUE rbtree_update(VALUE, VALUE);
 
 /*********************************************************************/
 
-#ifndef HAVE_OBJECT_ALLOCATE
-/*
- *
- */
-VALUE
-rbtree_s_new(int argc, VALUE* argv, VALUE klass)
-{
-    VALUE rbtree = rbtree_alloc(klass);
-    rb_obj_call_init(rbtree, argc, argv);
-    return rbtree;
-}
-#endif
-
 static int
 hash_to_rbtree_i(VALUE key, VALUE value, VALUE rbtree)
 {
@@ -214,17 +165,48 @@ hash_to_rbtree_i(VALUE key, VALUE value, VALUE rbtree)
 VALUE
 rbtree_s_create(int argc, VALUE* argv, VALUE klass)
 {
-    int i;
+    long i;
     VALUE rbtree;
-
+    
     if (argc == 1) {
+        VALUE tmp;
+        
+        if (klass == RBTree && CLASS_OF(argv[0]) == MultiRBTree) {
+            rb_raise(rb_eTypeError, "can't convert MultiRBTree to RBTree");
+        }
+        
         if (rb_obj_is_kind_of(argv[0], klass)) {
             rbtree = rbtree_alloc(klass);
             rbtree_update(rbtree, argv[0]);
             return rbtree;
-        } else if (TYPE(argv[0]) == T_HASH) {
+        }
+        
+        tmp = rb_check_convert_type(argv[0], T_HASH, "Hash", "to_hash");
+        if (!NIL_P(tmp)) {
+            rbtree = rbtree_alloc(klass);
+            st_foreach(RHASH(tmp)->tbl, hash_to_rbtree_i, rbtree);
+            return rbtree;
+        }
+        
+        tmp = rb_check_array_type(argv[0]);
+        if (!NIL_P(tmp)) {
             rbtree = rbtree_alloc(klass);
-            st_foreach(RHASH(argv[0])->tbl, hash_to_rbtree_i, rbtree);
+            for (i = 0; i < RARRAY(tmp)->len; i++) {
+                VALUE v = rb_check_array_type(RARRAY(tmp)->ptr[i]);
+                if (NIL_P(v)) {
+                    continue;
+                }
+                switch(RARRAY(v)->len) {
+                case 1:
+                    rbtree_aset(rbtree, RARRAY(v)->ptr[0], Qnil);
+                    break;
+                case 2:
+                    rbtree_aset(rbtree, RARRAY(v)->ptr[0], RARRAY(v)->ptr[1]);
+                    break;
+                default:
+                    continue;
+                }
+            }
             return rbtree;
         }
     }
@@ -556,6 +538,7 @@ each_i(dnode_t* node, void* arg)
 VALUE
 rbtree_each(VALUE self)
 {
+    RETURN_ENUMERATOR(self, 0, NULL);
     return rbtree_for_each(self, each_i, NULL);
 }
 
@@ -576,6 +559,7 @@ each_pair_i(dnode_t* node, void* arg)
 VALUE
 rbtree_each_pair(VALUE self)
 {
+    RETURN_ENUMERATOR(self, 0, NULL);
     return rbtree_for_each(self, each_pair_i, NULL);
 }
 
@@ -596,6 +580,7 @@ each_key_i(dnode_t* node, void* arg)
 VALUE
 rbtree_each_key(VALUE self)
 {
+    RETURN_ENUMERATOR(self, 0, NULL);
     return rbtree_for_each(self, each_key_i, NULL);
 }
 
@@ -616,6 +601,7 @@ each_value_i(dnode_t* node, void* arg)
 VALUE
 rbtree_each_value(VALUE self)
 {
+    RETURN_ENUMERATOR(self, 0, NULL);
     return rbtree_for_each(self, each_value_i, NULL);
 }
 
@@ -629,6 +615,7 @@ rbtree_each_value(VALUE self)
 VALUE
 rbtree_reverse_each(VALUE self)
 {
+    RETURN_ENUMERATOR(self, 0, NULL);
     return rbtree_reverse_for_each(self, each_pair_i, NULL);
 }
 
@@ -679,26 +666,13 @@ rbtree_initialize_copy(VALUE self, VALUE other)
     return self;
 }
 
-#ifndef HAVE_RB_OBJ_INIT_COPY
-/*
- *
- */
-VALUE
-rbtree_clone(VALUE self)
-{
-    VALUE clone = rbtree_alloc(CLASS_OF(self));
-    rbtree_initialize_copy(clone, self);
-    return clone;
-}
-#endif
-
 /*
  *
  */
 VALUE
 rbtree_values_at(int argc, VALUE* argv, VALUE self)
 {
-    int i;
+    long i;
     VALUE ary = rb_ary_new();
     
     for (i = 0; i < argc; i++)
@@ -720,7 +694,10 @@ select_i(dnode_t* node, void* ary)
 VALUE
 rbtree_select(VALUE self)
 {
-    VALUE ary = rb_ary_new();
+    VALUE ary;
+    
+    RETURN_ENUMERATOR(self, 0, NULL);
+    ary = rb_ary_new();
     rbtree_for_each(self, select_i, (void*)ary);
     return ary;
 }
@@ -843,7 +820,8 @@ VALUE
 rbtree_delete_if(VALUE self)
 {
     rbtree_delete_if_arg_t arg;
-
+    
+    RETURN_ENUMERATOR(self, 0, NULL);
     rbtree_modify(self);
     arg.self = self;
     arg.list = NULL;
@@ -857,7 +835,10 @@ rbtree_delete_if(VALUE self)
 VALUE
 rbtree_reject_bang(VALUE self)
 {
-    const dictcount_t count = dict_count(DICT(self));
+    dictcount_t count;
+    
+    RETURN_ENUMERATOR(self, 0, NULL);
+    count = dict_count(DICT(self));
     rbtree_delete_if(self);
     if (count == dict_count(DICT(self)))
         return Qnil;
@@ -874,7 +855,7 @@ rbtree_reject(VALUE self)
 }
 
 static VALUE
-rbtree_shift_pop(VALUE self, const int mode)
+rbtree_shift_pop(VALUE self, const int shift)
 {
     dict_t* dict = DICT(self);
     dnode_t* node;
@@ -889,10 +870,10 @@ rbtree_shift_pop(VALUE self, const int mode)
         return IFNONE(self);
     }
 
-    if (mode == 0)
-        node = dict_first(dict);
-    else
+    if (shift)
         node = dict_last(dict);
+    else
+        node = dict_first(dict);
     ret = ASSOC(node);
     dict_delete_free(dict, node);
     return ret;
@@ -1088,7 +1069,12 @@ to_hash_i(dnode_t* node, void* hash)
 VALUE
 rbtree_to_hash(VALUE self)
 {
-    VALUE hash = rb_hash_new();
+    VALUE hash;
+    if (CLASS_OF(self) == MultiRBTree) {
+        rb_raise(rb_eTypeError, "can't convert MultiRBTree to Hash");
+    }
+    
+    hash = rb_hash_new();
     rbtree_for_each(self, to_hash_i, (void*)hash);
     RHASH(hash)->ifnone = IFNONE(self);
     if (FL_TEST(self, RBTREE_PROC_DEFAULT))
@@ -1307,7 +1293,7 @@ rbtree_bound(int argc, VALUE* argv, VALUE self)
 }
 
 static VALUE
-rbtree_first_last(VALUE self, const int mode)
+rbtree_first_last(VALUE self, const int first)
 {
     dict_t* dict = DICT(self);
     dnode_t* node;
@@ -1319,7 +1305,7 @@ rbtree_first_last(VALUE self, const int mode)
         return IFNONE(self);
     }
     
-    if (mode == 0)
+    if (first)
         node = dict_first(dict);
     else
         node = dict_last(dict);
@@ -1335,7 +1321,7 @@ rbtree_first_last(VALUE self, const int mode)
 VALUE
 rbtree_first(VALUE self)
 {
-    return rbtree_first_last(self, 0);
+    return rbtree_first_last(self, 1);
 }
 
 /*
@@ -1347,7 +1333,7 @@ rbtree_first(VALUE self)
 VALUE
 rbtree_last(VALUE self)
 {
-    return rbtree_first_last(self, 1);
+    return rbtree_first_last(self, 0);
 }
 
 /*
@@ -1359,11 +1345,11 @@ rbtree_last(VALUE self)
  *
  * Sets a proc to compare keys and readjusts elements using the given
  * block or a Proc object given as the argument. The block takes two
- * key arguments and returns negative, 0, or positive depending on the
- * first argument is less than, equal to, or greater than the second
- * one. If no block is given it just readjusts elements using current
- * comparison block. If nil is given as the argument it sets default
- * comparison block.
+ * arguments of a key and returns negative, 0, or positive depending
+ * on the first argument is less than, equal to, or greater than the
+ * second one. If no block is given it just readjusts elements using
+ * current comparison block. If nil is given as the argument it sets
+ * default comparison block.
  */
 VALUE
 rbtree_readjust(int argc, VALUE* argv, VALUE self)
@@ -1482,20 +1468,6 @@ rbtree_pretty_print_cycle(VALUE self, VALUE pp)
 
 /*********************************************************************/
 
-#ifndef HAVE_RB_MARSHAL_DUMP
-static VALUE
-rb_marshal_dump(VALUE obj, VALUE port)
-{
-    return rb_funcall(rb_mMarshal, id_dump, 2, obj, port);
-}
-
-static VALUE
-rb_marshal_load(VALUE port)
-{
-    return rb_funcall(rb_mMarshal, id_load, 1, port);
-}
-#endif
-
 static each_return_t
 to_flatten_ary_i(dnode_t* node, void* ary)
 {
@@ -1554,10 +1526,10 @@ rbtree_s_load(VALUE klass, VALUE str)
 /*********************************************************************/
 
 /*
- * RBTree is a sorted associative collection using Red-Black Tree as
- * the internal data structure. The elements of RBTree are ordered and
- * the interface is the almost same as Hash, so simply you can
- * consider RBTree sorted Hash.
+ * RBTree is a sorted associative collection that is implemented with
+ * Red-Black Tree. The elements of RBTree are ordered and its interface
+ * is the almost same as Hash, so simply you can consider RBTree sorted
+ * Hash.
  *
  * Red-Black Tree is a kind of binary tree that automatically balances
  * by itself when a node is inserted or deleted. Thus the complexity
@@ -1565,25 +1537,45 @@ rbtree_s_load(VALUE klass, VALUE str)
  * case. On the other hand the complexity of Hash is O(1). Because
  * Hash is unordered the data structure is more effective than
  * Red-Black Tree as an associative collection.
+ * 
+ * The elements of RBTree are sorted with natural ordering (by <=>
+ * method) of its keys or by a comparator(Proc) set by readjust
+ * method. It means all keys in RBTree should be comparable with each
+ * other. Or a comparator that takes two arguments of a key should return
+ * negative, 0, or positive depending on the first argument is less than,
+ * equal to, or greater than the second one.
+ * 
+ * The interface of RBTree is the almost same as Hash and there are a
+ * few methods to take advantage of the ordering:
+ * 
+ * * lower_bound, upper_bound, bound
+ * * first, last
+ * * shift, pop
+ * * reverse_each
+ * 
+ * Note: while iterating RBTree (e.g. in a block of each method), it is
+ * not modifiable, or TypeError is thrown.
+ * 
+ * RBTree supoorts pretty printing using pp.
+ * 
+ * This library contains two classes. One is RBTree and the other is
+ * MultiRBTree that is a parent class of RBTree. RBTree does not allow
+ * duplications of keys but MultiRBTree does.
  *
- * The interface of RBTree is the almost same as Hash although there
- * are some limitations.
- *
- * * While iterating (e.g. in RBTree#each block), RBTree is
- *   unmodifiable.
- *
- * * Comparison is done using <=> method of key objects. So all types
- *   of keys in RBTree should be comparable each other or an arbitrary
- *   Proc might be set by RBTree#readjust.
- *
- * RBTree has a few searching methods that Hash doesn't have. They are
- * RBTree#lower_bound, RBTree#upper_bound and RBTree#bound. See
- * document of each method for details.
- *
- * Pretty printing is available for RBTree by using pp.rb. The output
- * of pp is easier than p to read. Just call Kernel#pp for the object.
- *
- * MultiRBTree that allows duplicates of keys is also available.
+ *   require "rbtree"
+ *   
+ *   rbtree = RBTree["c", 10, "a", 20]
+ *   rbtree["b"] = 30
+ *   p rbtree["b"]              # => 30
+ *   rbtree.each do |k, v|
+ *     p [k, v]
+ *   end                        # => ["a", 20] ["b", 30] ["c", 10]
+ *   
+ *   mrbtree = MultiRBTree["c", 10, "a", 20, "e", 30, "a", 40]
+ *   p mrbtree.lower_bound("b") # => ["c", 10]
+ *   mrbtree.bound("a", "d") do |k, v|
+ *     p [k, v]
+ *   end                        # => ["a", 20] ["a", 40] ["c", 10]
  */
 void Init_rbtree()
 {
@@ -1591,21 +1583,13 @@ void Init_rbtree()
     RBTree = rb_define_class("RBTree", MultiRBTree);
 
     rb_include_module(MultiRBTree, rb_mEnumerable);
-    
-#ifdef HAVE_OBJECT_ALLOCATE
+
     rb_define_alloc_func(MultiRBTree, rbtree_alloc);
-#else
-    rb_define_singleton_method(MultiRBTree, "new", rbtree_s_new, -1);
-#endif
+
     rb_define_singleton_method(MultiRBTree, "[]", rbtree_s_create, -1);
 
     rb_define_method(MultiRBTree, "initialize", rbtree_initialize, -1);
-
-#ifdef HAVE_RB_OBJ_INIT_COPY
     rb_define_method(MultiRBTree, "initialize_copy", rbtree_initialize_copy, 1);
-#else
-    rb_define_method(MultiRBTree, "clone", rbtree_clone, 0);
-#endif
 
     rb_define_method(MultiRBTree, "to_a", rbtree_to_a, 0);
     rb_define_method(MultiRBTree, "to_s", rbtree_to_s, 0);
@@ -1667,11 +1651,6 @@ void Init_rbtree()
 
     rb_define_method(MultiRBTree, "_dump", rbtree_dump, 1);
     rb_define_singleton_method(MultiRBTree, "_load", rbtree_s_load, 1);
-#ifndef HAVE_RB_MARSHAL_DUMP
-    rb_mMarshal = rb_path2class("Marshal");
-    id_dump = rb_intern("dump");
-    id_load = rb_intern("load");
-#endif
     
     id_bound = rb_intern("bound");
     id_cmp = rb_intern("<=>");