rbtree 0.2.0 → 0.4.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '068088a72443fb756ebedf00226f9e628552528fdb6a02a904bd984a9ab961b5'
+  data.tar.gz: 58c816a9433efa6680e7469db60810b6c9754949463143787bcc0979ad54a86a
+SHA512:
+  metadata.gz: 562b5482ebab8b47f3357e01f76abaa2f480c76a0316033704e783441b90234b4bb0933165204f421592efcf9c0376255c33fb14ce31cb96e82cb61b045ecafd
+  data.tar.gz: 81ff68b66a15597981ffdcecab5b1c49db8f73aa8b93e8b5f354d0072bd28282a4bce7fd0cacc90649006c9cc41c800abc03131b60bdae5c3b5ab3f783ea620c

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2002-2004, 2007 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,78 +1,73 @@
-=begin
-
 = 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.
-
-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.
-
-The interface of RBTree is the almost same as Hash although there
-are some limitations.
+== Description
 
-  * While iterating (e.g. in RBTree#each block), RBTree is
-    unmodifiable.
+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.
 
-  * 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.
+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.
 
-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.
+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.
 
-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.
+RBTree also provides a few additional methods to take advantage of the
+ordering:
 
-MultiRBTree that allows duplicates of keys is also available.
+* lower_bound, upper_bound, bound
+* first, last
+* shift, pop
+* reverse_each
 
-== Requirement
+== Example
 
-  * Ruby 1.6.7 or higher
-
-== Install
-
-  $ sudo gem install rbtree
+A RBTree cannot contain duplicate keys. Use MultiRBTree that is the
+parent class of RBTree to store duplicate keys.
 
-or download a tarball from the link below
+  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]
 
-  * ((<"Ruby/RBTree 0.2.0"|URL:rbtree-0.2.0.tar.gz>))
+Note: a RBTree cannot be modified during iteration.
 
-and then
+== Installation
 
-  $ tar xzf rbtree-x.x.x.tar.gz
-  $ cd rbtree-x.x.x.tar.gz
-  $ ruby extconf.rb
-  $ make
-  $ sudo make site-install
+Run the following command.
 
-== Test
-
-  $ ruby test.rb
+  $ sudo gem install rbtree
 
-== Incomplete Document
+== Changes
+=== 0.4.4
+* Remove the rb_safe_level warning on Ruby 2.7.
 
-  $ rdoc rbtree.c
+=== 0.4.3
+* Quick bug fixes for Ruby 3.
 
 == License
 
-MIT License. Copyright (c) 2002-2004, 2007 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.
-
-=end
+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.

data/dict.c

@@ -14,23 +14,22 @@
  * into proprietary software; there is no requirement for such software to
  * contain a copyright notice related to this source.
  *
- * $Id: dict.c,v 1.15 2005/10/06 05:16:35 kuma Exp $
- * $Name:  $
+ * $Id: dict.c,v 1.40.2.7 2000/11/13 01:36:44 kaz Exp $
+ * $Name: kazlib_1_20 $
  */
 
 /*
- * Modified for Ruby/RBTree by OZAWA Takuma.
+ * Modified for Ruby/RBTree.
  */
 
 #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 $";
+static const char rcsid[] = "$Id: dict.c,v 1.40.2.7 2000/11/13 01:36:44 kaz 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;
@@ -1192,25 +1191,307 @@ void dict_merge(dict_t *dest, dict_t *source)
     dict_load_end(&load);
 }
 
-int dict_equal(dict_t* dict1, dict_t* dict2,
-               dict_value_eql_t value_eql)
+#ifdef KAZLIB_TEST_MAIN
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdarg.h>
+
+typedef char input_t[256];
+
+static int tokenize(char *string, ...)
+{
+    char **tokptr; 
+    va_list arglist;
+    int tokcount = 0;
+
+    va_start(arglist, string);
+    tokptr = va_arg(arglist, char **);
+    while (tokptr) {
+	while (*string && isspace((unsigned char) *string))
+	    string++;
+	if (!*string)
+	    break;
+	*tokptr = string;
+	while (*string && !isspace((unsigned char) *string))
+	    string++;
+	tokptr = va_arg(arglist, char **);
+	tokcount++;
+	if (!*string)
+	    break;
+	*string++ = 0;
+    }
+    va_end(arglist);
+
+    return tokcount;
+}
+
+static int comparef(const void *key1, const void *key2)
 {
-    dnode_t* node1;
-    dnode_t* node2;
+    return strcmp(key1, key2);
+}
 
-    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;
+static char *dupstring(char *str)
+{
+    int sz = strlen(str) + 1;
+    char *new = malloc(sz);
+    if (new)
+	memcpy(new, str, sz);
+    return new;
+}
+
+static dnode_t *new_node(void *c)
+{
+    static dnode_t few[5];
+    static int count;
+
+    if (count < 5)
+	return few + count++;
+
+    return NULL;
+}
+
+static void del_node(dnode_t *n, void *c)
+{
+}
+
+static int prompt = 0;
+
+static void construct(dict_t *d)
+{
+    input_t in;
+    int done = 0;
+    dict_load_t dl;
+    dnode_t *dn;
+    char *tok1, *tok2, *val;
+    const char *key;
+    char *help = 
+	"p                      turn prompt on\n"
+	"q                      finish construction\n"
+	"a <key> <val>          add new entry\n";
+
+    if (!dict_isempty(d))
+	puts("warning: dictionary not empty!");
+
+    dict_load_begin(&dl, d);
+
+    while (!done) {
+	if (prompt)
+	    putchar('>');
+	fflush(stdout);
+
+	if (!fgets(in, sizeof(input_t), stdin))
+	    break;
+
+	switch (in[0]) {
+	    case '?':
+		puts(help);
+		break;
+	    case 'p':
+		prompt = 1;
+		break;
+	    case 'q':
+		done = 1;
+		break;
+	    case 'a':
+		if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
+		    puts("what?");
+		    break;
+		}
+		key = dupstring(tok1);
+		val = dupstring(tok2);
+		dn = dnode_create(val);
+
+		if (!key || !val || !dn) {
+		    puts("out of memory");
+		    free((void *) key);
+		    free(val);
+		    if (dn)
+			dnode_destroy(dn);
+		}
+
+		dict_load_next(&dl, dn, key);
+		break;
+	    default:
+		putchar('?');
+		putchar('\n');
+		break;
+	}
     }
-    return 1;
+
+    dict_load_end(&dl);
+}
+
+int main(void)
+{
+    input_t in;
+    dict_t darray[10];
+    dict_t *d = &darray[0];
+    dnode_t *dn;
+    int i;
+    char *tok1, *tok2, *val;
+    const char *key;
+
+    char *help =
+	"a <key> <val>          add value to dictionary\n"
+	"d <key>                delete value from dictionary\n"
+	"l <key>                lookup value in dictionary\n"
+	"( <key>                lookup lower bound\n"
+	") <key>                lookup upper bound\n"
+	"# <num>                switch to alternate dictionary (0-9)\n"
+	"j <num> <num>          merge two dictionaries\n"
+	"f                      free the whole dictionary\n"
+	"k                      allow duplicate keys\n"
+	"c                      show number of entries\n"
+	"t                      dump whole dictionary in sort order\n"
+	"m                      make dictionary out of sorted items\n"
+	"p                      turn prompt on\n"
+	"s                      switch to non-functioning allocator\n"
+	"q                      quit";
+
+    for (i = 0; i < sizeof darray / sizeof *darray; i++)
+	dict_init(&darray[i], DICTCOUNT_T_MAX, comparef);
+
+    for (;;) {
+	if (prompt)
+	    putchar('>');
+	fflush(stdout);
+
+	if (!fgets(in, sizeof(input_t), stdin))
+	    break;
+
+	switch(in[0]) {
+	    case '?':
+		puts(help);
+		break;
+	    case 'a':
+		if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
+		    puts("what?");
+		    break;
+		}
+		key = dupstring(tok1);
+		val = dupstring(tok2);
+
+		if (!key || !val) {
+		    puts("out of memory");
+		    free((void *) key);
+		    free(val);
+		}
+
+		if (!dict_alloc_insert(d, key, val)) {
+		    puts("dict_alloc_insert failed");
+		    free((void *) key);
+		    free(val);
+		    break;
+		}
+		break;
+	    case 'd':
+		if (tokenize(in+1, &tok1, (char **) 0) != 1) {
+		    puts("what?");
+		    break;
+		}
+		dn = dict_lookup(d, tok1);
+		if (!dn) {
+		    puts("dict_lookup failed");
+		    break;
+		}
+		val = dnode_get(dn);
+		key = dnode_getkey(dn);
+		dict_delete_free(d, dn);
+
+		free(val);
+		free((void *) key);
+		break;
+	    case 'f':
+		dict_free(d);
+		break;
+	    case 'l':
+	    case '(':
+	    case ')':
+		if (tokenize(in+1, &tok1, (char **) 0) != 1) {
+		    puts("what?");
+		    break;
+		}
+		dn = 0;
+		switch (in[0]) {
+		case 'l':
+		    dn = dict_lookup(d, tok1);
+		    break;
+		case '(':
+		    dn = dict_lower_bound(d, tok1);
+		    break;
+		case ')':
+		    dn = dict_upper_bound(d, tok1);
+		    break;
+		}
+		if (!dn) {
+		    puts("lookup failed");
+		    break;
+		}
+		val = dnode_get(dn);
+		puts(val);
+		break;
+	    case 'm':
+		construct(d);
+		break;
+	    case 'k':
+		dict_allow_dupes(d);
+		break;
+	    case 'c':
+		printf("%lu\n", (unsigned long) dict_count(d));
+		break;
+	    case 't':
+		for (dn = dict_first(d); dn; dn = dict_next(d, dn)) {
+		    printf("%s\t%s\n", (char *) dnode_getkey(dn),
+			    (char *) dnode_get(dn));
+		}
+		break;
+	    case 'q':
+		exit(0);
+		break;
+	    case '\0':
+		break;
+	    case 'p':
+		prompt = 1;
+		break;
+	    case 's':
+		dict_set_allocator(d, new_node, del_node, NULL);
+		break;
+	    case '#':
+		if (tokenize(in+1, &tok1, (char **) 0) != 1) {
+		    puts("what?");
+		    break;
+		} else {
+		    int dictnum = atoi(tok1);
+		    if (dictnum < 0 || dictnum > 9) {
+			puts("invalid number");
+			break;
+		    }
+		    d = &darray[dictnum];
+		}
+		break;
+	    case 'j':
+		if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
+		    puts("what?");
+		    break;
+		} else {
+		    int dict1 = atoi(tok1), dict2 = atoi(tok2);
+		    if (dict1 < 0 || dict1 > 9 || dict2 < 0 || dict2 > 9) {
+			puts("invalid number");
+			break;
+		    }
+		    dict_merge(&darray[dict1], &darray[dict2]);
+		}
+		break;
+	    default:
+		putchar('?');
+		putchar('\n');
+		break;
+	}
+    }
+
+    return 0;
 }
+
+#endif