rbtree 0.3.0 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b2c9450418c5e8acbcf6dfe359cbd7f5495558ea
+  data.tar.gz: 3cc9df43495129924dc06ef7571309dc604b99d9
+SHA512:
+  metadata.gz: aba578f329b5ceb9dd07de643671d97ff16110bab46b1fbceec28424ec10a69898129f137bcfa382412f6d8580a31008fbb309e7e3098d50821b12881826937d
+  data.tar.gz: 6cbef7d7032c04e4a2183c4346418ebe2220de66309b5e3d41c275eee9e091a542a8c51ebd81948e8fa39a5aeb71ad81b2ae1fe81c9f4e6b88f619836a82500d

data/LICENSE

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

data/MANIFEST

@@ -1,4 +1,3 @@
-ChangeLog
 LICENSE
 MANIFEST
 README

data/README

@@ -1,42 +1,37 @@
-=begin
-
 = Ruby/RBTree
 
-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.
+== Description
 
-Red-Black Tree is a kind of binary tree that automatically balances
-by itself when a node is inserted or deleted. Thus the complexity
-for insert, search and delete is O(log N) in expected and worst
-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.
+A RBTree is a sorted associative collection that is implemented with a
+Red-Black Tree. It maps keys to values like a Hash, but maintains its
+elements in ascending key order. The interface is the almost identical
+to that of Hash.
 
-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.
+A Red-Black Tree is a kind of binary tree that automatically balances
+by itself when a node is inserted or deleted. Lookup, insertion, and
+deletion are performed in O(log N) time in the expected and worst
+cases. On the other hand, the average case complexity of
+lookup/insertion/deletion on a Hash is constant time. A Hash is
+usually faster than a RBTree where ordering is unimportant.
 
-The interface of RBTree is the almost same as Hash and there are a
-few methods to take advantage of the ordering:
+The elements of a RBTree are sorted using the <=> method of their keys
+or a Proc set by the readjust method. It means all keys should be
+comparable with each other or a Proc that takes two keys should return
+a negative integer, 0, or a positive integer as the first argument is
+less than, equal to, or greater than the second one.
 
-  * lower_bound, upper_bound, bound
-  * first, last
-  * shift, pop
-  * reverse_each
+RBTree also provides a few additional methods to take advantage of the
+ordering:
 
-Note: while iterating RBTree (e.g. in a block of each method), it is
-not modifiable, or TypeError is thrown.
+* lower_bound, upper_bound, bound
+* first, last
+* shift, pop
+* reverse_each
 
-RBTree supoorts pretty printing using pp.
+== Example
 
-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.
+A RBTree cannot contain duplicate keys. Use MultiRBTree that is the
+parent class of RBTree to store duplicate keys.
 
   require "rbtree"
   
@@ -46,61 +41,43 @@ duplications of keys but MultiRBTree does.
   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
+Note: a RBTree cannot be modified during iteration.
 
-  * Ruby 1.8.x, 1.9.1
+== Installation
 
-== Install
+Run the following command.
 
   $ sudo gem install rbtree
 
-or download a tarball from the link below
-
-  * ((<"Ruby/RBTree 0.3.0"|URL:rbtree-0.3.0.tar.gz>))
-
-and then
-
-  $ tar xzf rbtree-x.x.x.tar.gz
-  $ cd rbtree-x.x.x.tar.gz
-  $ ruby extconf.rb
-  $ make
-  $ sudo make site-install
-
-== Test
+== Changes
+=== 0.4.0
 
-  $ ruby test.rb
-
-== Incomplete Documents
-
-  $ rdoc rbtree.c
-
-or online documents at ((<URL:http://rbtree.rubyforge.org/>)).
+* Fixed build failure with Ruby 2.0.0.
+* \#bound now returns an enumerator if no block is given.
+* \#select now returns a new MultiRBTree / RBTree.
+* Fixed a bug where \#reject could return nil.
+* \#to_s is now equivalent to \#inspect.
+* \#each now passes a two elements array as an argument to the given block.
+* Added new methods: \#default_proc=, \#flatten, \#keep_if, \#key, \#select! and \#to_h.
 
 == License
 
-MIT License. Copyright (c) 2002-2004, 2007, 2009-2010 OZAWA Takuma.
+MIT License. Copyright (c) 2002-2013 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
-and dict.h for the license. The web page of Kazlib is at
-((<URL:http://users.footprints.net/~kaz/kazlib.html>)).
-
-== Support
-
-Bug fixes, suggestions and other feedbacks are welcomed. Please mail
-me at burningdowntheopera at yahoo dot co dot jp.
+1.20 written by Kaz Kylheku. Its license is similar to the MIT
+license. See dict.c and dict.h for the details. The web page of Kazlib
+is at http://www.kylheku.com/~kaz/kazlib.html.
 
-== Links
+== Contact
 
-  * ((<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>))
+Run the following command.
 
-=end
+  $ ruby -e "puts 'YnVybmluZ2Rvd250aGVvcGVyYUB5YWhvby5jby5qcA==\n'.unpack('m')"

data/dict.c

@@ -25,10 +25,9 @@
 #include <stdlib.h>
 #include <stddef.h>
 #include <assert.h>
+#define DICT_IMPLEMENTATION
 #include "dict.h"
 
-#include <ruby.h>
-
 #ifdef KAZLIB_RCSID
 static const char rcsid[] = "$Id: dict.c,v 1.15 2005/10/06 05:16:35 kuma Exp $";
 #endif
@@ -66,8 +65,6 @@ static const char rcsid[] = "$Id: dict.c,v 1.15 2005/10/06 05:16:35 kuma Exp $";
 #define dict_nil(D) (&(D)->nilnode)
 #define DICT_DEPTH_MAX 64
 
-#define COMPARE(dict, key1, key2) dict->compare(key1, key2, dict->context)
-
 static dnode_t *dnode_alloc(void *context);
 static void dnode_free(dnode_t *node, void *context);
 
@@ -158,17 +155,17 @@ static int verify_bintree(dict_t *dict)
     first = dict_first(dict);
 
     if (dict->dupes) {
-        while (first && (next = dict_next(dict, first))) {
-            if (COMPARE(dict, first->key, next->key) > 0)
-                return 0;
-            first = next;
-        }
+	while (first && (next = dict_next(dict, first))) {
+	    if (dict->compare(first->key, next->key, dict->context) > 0)
+		return 0;
+	    first = next;
+	}
     } else {
-        while (first && (next = dict_next(dict, first))) {
-            if (COMPARE(dict, first->key, next->key) >= 0)
-                return 0;
-            first = next;
-        }
+	while (first && (next = dict_next(dict, first))) {
+	    if (dict->compare(first->key, next->key, dict->context) >= 0)
+		return 0;
+	    first = next;
+	}
     }
     return 1;
 }
@@ -251,8 +248,8 @@ static int verify_dict_has_node(dnode_t *nil, dnode_t *root, dnode_t *node)
 
 dict_t *dict_create(dict_comp_t comp)
 {
-    dict_t* new = ALLOC(dict_t);
-    
+    dict_t *new = malloc(sizeof *new);
+
     if (new) {
 	new->compare = comp;
 	new->allocnode = dnode_alloc;
@@ -263,7 +260,7 @@ dict_t *dict_create(dict_comp_t comp)
 	new->nilnode.right = &new->nilnode;
 	new->nilnode.parent = &new->nilnode;
 	new->nilnode.color = dnode_black;
-        new->dupes = 0;
+	new->dupes = 0;
     }
     return new;
 }
@@ -291,7 +288,7 @@ void dict_set_allocator(dict_t *dict, dnode_alloc_t al,
 void dict_destroy(dict_t *dict)
 {
     assert (dict_isempty(dict));
-    xfree(dict);
+    free(dict);
 }
 
 /*
@@ -424,9 +421,6 @@ int dict_similar(const dict_t *left, const dict_t *right)
     if (left->context != right->context)
 	return 0;
 
-/*     if (left->dupes != right->dupes) */
-/*         return 0; */
-
     return 1;
 }
 
@@ -447,24 +441,24 @@ dnode_t *dict_lookup(dict_t *dict, const void *key)
     /* simple binary search adapted for trees that contain duplicate keys */
 
     while (root != nil) {
-	result = COMPARE(dict, key, root->key);
+	result = dict->compare(key, root->key, dict->context);
 	if (result < 0)
 	    root = root->left;
 	else if (result > 0)
 	    root = root->right;
 	else {
-            if (!dict->dupes) { /* no duplicates, return match          */
-                return root;
-            } else {            /* could be dupes, find leftmost one    */
-                do {
-                    saved = root;
-                    root = root->left;
-                    while (root != nil && COMPARE(dict, key, root->key))
-                        root = root->right;
-                } while (root != nil);
-                return saved;
-            }
-        }
+	    if (!dict->dupes) {	/* no duplicates, return match		*/
+		return root;
+	    } else {		/* could be dupes, find leftmost one	*/
+		do {
+		    saved = root;
+		    root = root->left;
+		    while (root != nil && dict->compare(key, root->key, dict->context))
+			root = root->right;
+		} while (root != nil);
+		return saved;
+	    }
+	}
     }
 
     return NULL;
@@ -482,21 +476,21 @@ dnode_t *dict_lower_bound(dict_t *dict, const void *key)
     dnode_t *tentative = 0;
 
     while (root != nil) {
-	int result = COMPARE(dict, key, root->key);
-        
+	int result = dict->compare(key, root->key, dict->context);
+
 	if (result > 0) {
 	    root = root->right;
 	} else if (result < 0) {
 	    tentative = root;
 	    root = root->left;
 	} else {
-            if (!dict->dupes) {
-                return root;
-            } else {
-                tentative = root;
-                root = root->left;
-            }
-        }
+	    if (!dict->dupes) {
+	    	return root;
+	    } else {
+		tentative = root;
+		root = root->left;
+	    }
+	} 
     }
     
     return tentative;
@@ -514,7 +508,7 @@ dnode_t *dict_upper_bound(dict_t *dict, const void *key)
     dnode_t *tentative = 0;
 
     while (root != nil) {
-	int result = COMPARE(dict, key, root->key);
+	int result = dict->compare(key, root->key, dict->context);
 
 	if (result < 0) {
 	    root = root->left;
@@ -522,13 +516,13 @@ dnode_t *dict_upper_bound(dict_t *dict, const void *key)
 	    tentative = root;
 	    root = root->right;
 	} else {
-            if (!dict->dupes) {
-                return root;
-            } else {
-                tentative = root;
-                root = root->right;
-            }
-        }
+	    if (!dict->dupes) {
+	    	return root;
+	    } else {
+		tentative = root;
+		root = root->right;
+	    }
+	} 
     }
     
     return tentative;
@@ -555,12 +549,10 @@ int dict_insert(dict_t *dict, dnode_t *node, const void *key)
     assert (!dnode_is_in_a_dict(node));
 
     /* basic binary tree insert */
-    
+
     while (where != nil) {
 	parent = where;
-	result = COMPARE(dict, key, where->key);
-	/* trap attempts at duplicate key insertion unless it's explicitly allowed */
-
+	result = dict->compare(key, where->key, dict->context);
         if (!dict->dupes && result == 0) {
             where->data = node->data;
             return 0;
@@ -928,6 +920,13 @@ void dict_allow_dupes(dict_t *dict)
     dict->dupes = 1;
 }
 
+#undef dict_count
+#undef dict_isempty
+#undef dict_isfull
+#undef dnode_get
+#undef dnode_put
+#undef dnode_getkey
+
 dictcount_t dict_count(dict_t *dict)
 {
     return dict->nodecount;
@@ -1036,16 +1035,16 @@ void dict_load_next(dict_load_t *load, dnode_t *newnode, const void *key)
 {
     dict_t *dict = load->dictptr;
     dnode_t *nil = &load->nilnode;
-    
+   
     assert (!dnode_is_in_a_dict(newnode));
     assert (dict->nodecount < DICTCOUNT_T_MAX);
 
     #ifndef NDEBUG
     if (dict->nodecount > 0) {
-        if (dict->dupes)
-            assert (COMPARE(dict, nil->left->key, key) <= 0);
-        else
-            assert (COMPARE(dict, nil->left->key, key) < 0);
+	if (dict->dupes)
+	    assert (dict->compare(nil->left->key, key, dict->context) <= 0);
+	else
+	    assert (dict->compare(nil->left->key, key, dict->context) < 0);
     }
     #endif
 
@@ -1152,7 +1151,7 @@ void dict_merge(dict_t *dest, dict_t *source)
 
     for (;;) {
 	if (leftnode != NULL && rightnode != NULL) {
-	    if (COMPARE(dest, leftnode->key, rightnode->key) < 0)
+	    if (dest->compare(leftnode->key, rightnode->key, dest->context) < 0)
 		goto copyleft;
 	    else
 		goto copyright;
@@ -1191,26 +1190,3 @@ void dict_merge(dict_t *dest, dict_t *source)
     dict_clear(source);
     dict_load_end(&load);
 }
-
-int dict_equal(dict_t* dict1, dict_t* dict2,
-               dict_value_eql_t value_eql)
-{
-    dnode_t* node1;
-    dnode_t* node2;
-
-    if (dict_count(dict1) != dict_count(dict2))
-        return 0; 
-    if (!dict_similar(dict1, dict2))
-        return 0;
-    
-    for (node1 = dict_first(dict1), node2 = dict_first(dict2);
-         node1 != NULL && node2 != NULL;
-         node1 = dict_next(dict1, node1), node2 = dict_next(dict2, node2)) {
-        
-        if (COMPARE(dict1, node1->key, node2->key) != 0)
-            return 0;
-        if (!value_eql(node1->data, node2->data))
-            return 0;
-    }
-    return 1;
-}

data/dict.h

@@ -26,6 +26,9 @@
 #define DICT_H
 
 #include <limits.h>
+#ifdef KAZLIB_SIDEEFFECT_DEBUG
+#include "sfx.h"
+#endif
 
 /*
  * Blurb for inclusion into C++ translation units
@@ -45,21 +48,24 @@ typedef unsigned long dictcount_t;
 typedef enum { dnode_red, dnode_black } dnode_color_t;
 
 typedef struct dnode_t {
+    #if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
     struct dnode_t *dict_left;
     struct dnode_t *dict_right;
     struct dnode_t *dict_parent;
     dnode_color_t dict_color;
     const void *dict_key;
     void *dict_data;
+    #else
+    int dict_dummy;
+    #endif
 } dnode_t;
 
 typedef int (*dict_comp_t)(const void *, const void *, void *);
 typedef dnode_t *(*dnode_alloc_t)(void *);
 typedef void (*dnode_free_t)(dnode_t *, void *);
 
-typedef int (*dict_value_eql_t)(const void *, const void *);
-
 typedef struct dict_t {
+    #if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
     dnode_t dict_nilnode;
     dictcount_t dict_nodecount;
     dict_comp_t dict_compare;
@@ -67,13 +73,20 @@ typedef struct dict_t {
     dnode_free_t dict_freenode;
     void *dict_context;
     int dict_dupes;
+    #else
+    int dict_dummmy;
+    #endif
 } dict_t;
 
 typedef void (*dnode_process_t)(dict_t *, dnode_t *, void *);
 
 typedef struct dict_load_t {
+    #if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
     dict_t *dict_dictptr;
     dnode_t dict_nilnode;
+    #else
+    int dict_dummmy;
+    #endif
 } dict_load_t;
 
 extern dict_t *dict_create(dict_comp_t);
@@ -114,7 +127,18 @@ extern void dict_load_next(dict_load_t *, dnode_t *, const void *);
 extern void dict_load_end(dict_load_t *);
 extern void dict_merge(dict_t *, dict_t *);
 
-int dict_equal(dict_t*, dict_t*, dict_value_eql_t);
+#if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
+#ifdef KAZLIB_SIDEEFFECT_DEBUG
+#define dict_isfull(D) (SFX_CHECK(D)->dict_nodecount == (D)->dict_maxcount)
+#else
+#define dict_isfull(D) ((D)->dict_nodecount == DICTCOUNT_T_MAX)
+#endif
+#define dict_count(D) ((D)->dict_nodecount)
+#define dict_isempty(D) ((D)->dict_nodecount == 0)
+#define dnode_get(N) ((N)->dict_data)
+#define dnode_getkey(N) ((N)->dict_key)
+#define dnode_put(N, X) ((N)->dict_data = (X))
+#endif
 
 #ifdef __cplusplus
 }