digital_trees_and_sets 0.4.0

data/ext/judy_compat.h

@@ -0,0 +1,156 @@
+// A non existently thin (inline) layer to sanitize judy calling interface
+
+//  working with the assumption that NULL is not a valid value
+
+// Function are get/set/delete  , first/next/bycount/length , clear/mem (memtotal?)
+
+// Indexes are VALUE's
+// All numbers also VALUES (though not converted) (rembering that a value is short for unsigned long int)
+// Both Judy1 and JudyL go as Tree, as typecheking is done the layer above and their void* anyway
+// Interface uses Tree* for consitency on all functions
+// Using Qfalse which actualy is NULL (as we use VALUE not pointers)
+
+#include "judy.h"
+#include "ruby.h"
+
+static inline int basic_type(VALUE x){
+  return (x == Qnil || x == Qtrue || x == Qfalse || FIXNUM_P(x) || SYMBOL_P(x) ) ;
+}
+static inline void check_index_basic(VALUE i){ // for judy_hash/set
+  if(!basic_type(i)) rb_raise(rb_eArgError ,"Key must be int or symbol, not %s" , RSTRING_PTR(rb_funcall(i,rb_intern("to_s"),0)));
+}
+
+typedef struct {
+  VALUE count ;
+  void*   judy ;
+} tree_object;
+
+typedef Pvoid_t Tree;
+
+static inline int judy_set_has(Tree* set , VALUE index){
+  return Judy1Test(*set, index , PJE0) ;
+}
+static inline VALUE judy_set_set(Tree* set , VALUE index){
+  int was;
+  was = Judy1Set(set, index , PJE0) ;
+  return was ? Qtrue : Qfalse ;
+}
+static inline VALUE judy_set_delete(Tree* set , VALUE index){
+  int was;
+  was = Judy1Unset(set, index , PJE0) ;
+  return was ? Qtrue : Qfalse ;
+}
+
+static inline VALUE judy_set_first_index(Tree* set){
+  VALUE index =  0 ;
+  VALUE continu =  0 ;
+  continu = Judy1First(*set, &index, PJE0);
+  return continu ? index : Qfalse ;
+}
+static inline VALUE judy_set_next_index(Tree* set , VALUE index){
+  VALUE continu =  0 ;
+  continu = Judy1Next(*set, &index, PJE0);
+  return continu ? index : Qfalse ;
+}
+static inline VALUE judy_set_last_index(Tree* set){
+  VALUE index =  -1 ;
+  VALUE continu =  0 ;
+  continu = Judy1Last(*set, &index, PJE0);
+  return continu ? index : Qfalse ;
+}
+static inline VALUE judy_set_prev_index(Tree* set , VALUE index){
+  VALUE continu =  0 ;
+  continu = Judy1Prev(*set, &index, PJE0);
+  return continu ? index : Qfalse ;
+}
+static inline VALUE judy_set_at_count(Tree* set , VALUE at){
+  VALUE index =  Qfalse ;
+  VALUE continu;
+  continu = Judy1ByCount(*set, NUM2INT(at) , &index, PJE0);
+  return continu ? index : Qfalse ;
+}
+
+static inline VALUE judy_set_length(Tree* set){
+  VALUE c;
+  c = Judy1Count(*set, 0 , -1 , PJE0) ;
+  return UINT2NUM(c) ; 
+}
+static inline void judy_set_clear(Tree* set){
+  Judy1FreeArray(set , PJE0) ;
+}
+static inline VALUE judy_set_mem(Tree* set){
+  VALUE c;
+  c = Judy1MemUsed(*set) ;
+  return UINT2NUM(c) ;
+}
+
+static inline tree_object* judy_array_at_index(Tree* array , VALUE index){
+  tree_object** val;
+  val = (tree_object**)JudyLGet(*array, index , PJE0) ;
+  if(val == NULL) return NULL;
+  return *val;
+}
+static inline tree_object* judy_array_set(Tree* array , VALUE index , tree_object* value ){
+  tree_object* was = NULL ;
+  tree_object** there;
+  there = (tree_object**)JudyLIns(array, index , PJE0) ;
+  if( *there != NULL ) was = *there ;
+  *there = value ;
+  return was ;
+}
+static inline tree_object* judy_array_delete(Tree* array , VALUE index){
+  tree_object* was ;
+  was = judy_array_at_index(array , index);
+  JudyLDel(array, index , PJE0) ;
+  return was ;
+}
+
+static inline VALUE judy_array_first_index(Tree* array){
+  VALUE index = 0;
+  VALUE* here;
+  here = (VALUE*)JudyLFirst(*array, &index, PJE0);
+  if(here == NULL)  index = Qfalse ;
+  return index;
+}
+static inline VALUE judy_array_next_index(Tree* array , VALUE i){
+  VALUE index = i;
+  VALUE* here;
+  here = (VALUE*)JudyLNext(*array, &index, PJE0);
+  if(here == NULL)  index = Qfalse ;
+  return index;
+}
+static inline VALUE judy_array_last_index(Tree* array){
+  VALUE index = -1;
+  VALUE* here;
+  here = (VALUE*)JudyLLast(*array, &index, PJE0);
+  if(here == NULL)  index = Qfalse ;
+  return index;
+}
+static inline VALUE judy_array_prev_index(Tree* array , VALUE i){
+  VALUE index = i;
+  VALUE* here;
+  here = (VALUE*)JudyLPrev(*array, &index, PJE0);
+  if(here == NULL)  index = Qfalse ;
+  return index;
+}
+static inline tree_object* judy_array_at_count(Tree* array , VALUE at){
+  tree_object** val;
+  VALUE index;
+  val = (tree_object**)JudyLByCount(*array, NUM2INT(at) , &index, PJE0);
+  if(val == NULL ) return NULL;
+  return *val;
+}
+
+static inline VALUE judy_array_length(Tree* array){
+  VALUE c;
+  c = JudyLCount(*array, 0 , -1 , PJE0) ;
+  return UINT2NUM(c) ; 
+}
+static inline void judy_array_clear(Tree* array){
+  JudyLFreeArray(array , PJE0) ;
+}
+static inline VALUE judy_array_mem(Tree* array){
+  VALUE c;
+  c = JudyLMemUsed(*array) ;
+  return UINT2NUM(c) ; 
+}

data/ext/judy_hash.c

@@ -0,0 +1,227 @@
+/************************************************    
+  Author : Torsten Rueger , Copyright 2002-20011
+  License: GPL v.2 see LICENSE
+************************************************/
+#include "judy_compat.h"
+
+// The class JudyHash is a RubyHash replacement. At least to the degree that the implementation is complete.
+// Also it really only takes int and symbol as keys
+
+
+typedef Tree JudyHash; // JudyHash == pcvoid_t
+
+// Get_Hash converts from the ruby world to c judy-pointers
+// Basically all functions available from ruby start with a call to Get_Hash
+JudyHash * Get_Hash(VALUE obj) {
+  tree_object* object ;//= DATA_PTR(obj);
+  Check_Type(obj , T_DATA); 
+  object = DATA_PTR(obj);
+//  assert( JudyHash == object->class) ;
+  return (JudyHash*) &(object->judy) ;
+}
+
+VALUE ruby_JudyHash_clear(VALUE self) {
+  JudyHash *p_hash = Get_Hash(self) ;
+  JudyLFreeArray( p_hash, PJE0);
+  return self;
+}
+
+void gc_mark_hash( tree_object* hash){
+  VALUE value , index ; 
+  if(hash == NULL) return ;
+  index = judy_array_first_index(&(hash->judy));
+  while (index != Qfalse) {
+    value = (VALUE) judy_array_at_index(&(hash->judy) , index);
+    rb_gc_mark(value );
+    index = judy_array_next_index(&(hash->judy), index);
+  }
+}
+void gc_free_hash( tree_object* p_hash){
+  if(p_hash == NULL) return;
+  JudyLFreeArray( &(p_hash->judy), PJE0);
+  free(p_hash);
+}
+
+VALUE ruby_JudyHash_allocate(VALUE self) {
+  tree_object* tree = malloc( sizeof(tree_object) ) ;
+  tree->judy = NULL;
+  return Data_Wrap_Struct(self,  gc_mark_hash, gc_free_hash, tree);
+}
+
+VALUE ruby_JudyHash_getitem(VALUE self , VALUE index) {
+  VALUE val;
+  JudyHash *p_hash ;
+  if( index == Qnil ) return Qnil ;
+  p_hash = Get_Hash(self);
+  check_index_basic(index);
+  val = (VALUE)judy_array_at_index(p_hash, index);
+  return (val == 0) ? Qnil : val;
+}
+
+VALUE ruby_JudyHash_has_key(VALUE self , VALUE index) {
+  JudyHash *p_hash ;
+  VALUE val;
+  if( index == Qnil ) return Qnil ;
+  p_hash = Get_Hash(self) ;
+  check_index_basic(index);
+  if(!p_hash) return Qfalse;
+  val = (VALUE)judy_array_at_index(p_hash, index);
+  return (val == 0) ? Qfalse : Qtrue;
+}
+
+VALUE ruby_JudyHash_delete(VALUE self , VALUE index) {
+  JudyHash *p_hash = Get_Hash(self) ;
+  tree_object * was;
+  check_index_basic(index);
+  if( index == Qnil ) return Qfalse ;
+  was = judy_array_delete(p_hash , index);
+  return (was == NULL) ? Qfalse : Qtrue ;
+}
+
+VALUE ruby_JudyHash_setitem(VALUE self , VALUE index , VALUE value ) {
+  JudyHash *p_hash = Get_Hash(self) ;
+  tree_object *was;
+  check_index_basic(index);
+  if( index == Qnil ) return Qnil ;
+  was = judy_array_set(p_hash , index , (tree_object*)value);
+  return value;
+}
+
+VALUE ruby_JudyHash_length(VALUE self) {
+  JudyHash *p_hash = Get_Hash(self) ;
+  return judy_array_length(p_hash);
+}
+
+VALUE ruby_JudyHash_each_key(VALUE self) {
+  JudyHash *p_hash = Get_Hash(self) ;
+  VALUE index = judy_array_first_index(p_hash);
+  while (index != Qfalse) {
+    rb_yield(index);
+    index = judy_array_next_index(p_hash, index);
+  }
+  return self;
+}
+
+VALUE ruby_JudyHash_keys(VALUE self) {
+  JudyHash *p_hash = Get_Hash(self) ;
+  VALUE index = judy_array_first_index(p_hash);
+  VALUE array = rb_ary_new();
+  while (index != Qfalse) {
+    rb_ary_push(array , (VALUE)index);
+    index = judy_array_next_index(p_hash, index);
+  }
+  return array;
+}
+
+VALUE ruby_JudyHash_each(VALUE self) {
+  JudyHash *p_hash = Get_Hash(self) ;
+  VALUE index = Qfalse;
+  VALUE value = Qnil;
+  if(p_hash == NULL) return self;
+  index = judy_array_first_index(p_hash);
+  while (index != Qfalse) {
+    value = (VALUE) judy_array_at_index(p_hash , index);
+    rb_yield_values(2 , index , value );
+    index = judy_array_next_index(p_hash, index);
+  }
+  return self;
+}
+
+VALUE ruby_JudyHash_empty(VALUE self) {
+  JudyHash *p_hash = Get_Hash(self) ;
+  int c;
+  if( ! p_hash ) return Qtrue;
+  c = JudyLCount(*p_hash, 0 , -1 , PJE0) ;
+  return  (0 == c) ? Qtrue : Qfalse ;
+}
+
+VALUE ruby_JudyHash_by_count(VALUE self, VALUE num) {
+  JudyHash *p_hash = Get_Hash(self) ;
+  VALUE val;
+  check_index_basic(num);
+  val = (VALUE)judy_array_at_count(p_hash, num);
+  return (val == 0) ? Qnil : val;
+}
+
+VALUE ruby_JudyHash_mem_used(VALUE self) {
+  JudyHash *p_hash = Get_Hash(self) ;
+  return judy_array_mem(p_hash);
+}
+
+VALUE ruby_JudyHash_first_index(VALUE self) {
+    JudyHash *p_hash = Get_Hash(self) ;
+    VALUE val = (VALUE)judy_array_first_index(p_hash);
+    return (val == 0) ? Qnil : val;
+}
+
+VALUE ruby_JudyHash_next_index(VALUE self, VALUE in) {
+  JudyHash *p_hash = Get_Hash(self) ;
+  VALUE val;
+  check_index_basic(in);
+  val = (VALUE)judy_array_next_index(p_hash, in);
+  return (val == 0) ? Qnil : val;
+}
+
+VALUE ruby_JudyHash_last_index(VALUE self) {
+    JudyHash *p_hash = Get_Hash(self) ;
+    VALUE val = (VALUE)judy_array_last_index(p_hash);
+    return (val == 0) ? Qnil : val;
+}
+VALUE ruby_JudyHash_prev_index(VALUE self, VALUE in) {
+  JudyHash *p_hash = Get_Hash(self) ;
+  VALUE val;
+  check_index_basic(in);
+  val = (VALUE)judy_array_prev_index(p_hash, in);
+  return (val == 0) ? Qnil : val;
+}
+
+VALUE ruby_JudyHash_includeq(VALUE self, VALUE dat) {
+  JudyHash *p_hash = Get_Hash(self) ;
+  VALUE index = judy_array_first_index(p_hash);
+  VALUE value = Qnil;
+  while (index != Qfalse) {
+    value = (VALUE) judy_array_at_index(p_hash , index);
+    if( dat == value ) return index;
+    index = judy_array_next_index(p_hash, index);
+  }
+  return Qfalse;
+}
+
+VALUE ruby_Hash_mem_used(VALUE hash) {
+  if (!RHASH(hash)->ntbl ) return Qnil;
+  return UINT2NUM(st_memsize(RHASH(hash)->ntbl));
+}
+
+extern void Init_JudySet(void);
+
+/* Ruby calls this when it loads the module. Define all public functions
+ and initialize variables   */
+void Init_digital_trees_and_sets(){
+  VALUE cJudyHash_klass = rb_define_class("JudyHash", rb_cObject);
+  rb_include_module(cJudyHash_klass, rb_eval_string("Enumerable"));
+  rb_define_singleton_method(cJudyHash_klass, "new", ruby_JudyHash_allocate, 0);
+  rb_define_method(cJudyHash_klass, "[]=", ruby_JudyHash_setitem, 2);
+  rb_define_method(cJudyHash_klass, "set", ruby_JudyHash_setitem, 2);
+  rb_define_method(cJudyHash_klass, "delete", ruby_JudyHash_delete, 1);
+  rb_define_method(cJudyHash_klass, "get", ruby_JudyHash_getitem, 1);
+  rb_define_method(cJudyHash_klass, "[]", ruby_JudyHash_getitem, 1);
+  rb_define_method(cJudyHash_klass, "do_get", ruby_JudyHash_getitem, 1);
+  rb_define_method(cJudyHash_klass, "length", ruby_JudyHash_length, 0);
+  rb_define_method(cJudyHash_klass, "empty?", ruby_JudyHash_empty, 0);
+  rb_define_method(cJudyHash_klass, "count", ruby_JudyHash_length, 0);
+  rb_define_method(cJudyHash_klass, "each_key", ruby_JudyHash_each_key, 0);
+  rb_define_method(cJudyHash_klass, "each", ruby_JudyHash_each, 0);
+  rb_define_method(cJudyHash_klass, "keys", ruby_JudyHash_keys, 0);
+  rb_define_method(cJudyHash_klass, "by_count", ruby_JudyHash_by_count, 1);
+  rb_define_method(cJudyHash_klass, "mem_used", ruby_JudyHash_mem_used, 0);
+  rb_define_method(cJudyHash_klass, "first_index", ruby_JudyHash_first_index, 0);
+  rb_define_method(cJudyHash_klass, "next_index", ruby_JudyHash_next_index, 1);
+  rb_define_method(cJudyHash_klass, "last_index", ruby_JudyHash_last_index, 0);
+  rb_define_method(cJudyHash_klass, "clear", ruby_JudyHash_clear, 0);
+  rb_define_method(cJudyHash_klass, "include?", ruby_JudyHash_includeq, 1);
+  rb_define_method(cJudyHash_klass, "has_key?", ruby_JudyHash_has_key, 1);
+  // for testing 
+  rb_define_method(rb_cHash, "mem_used", ruby_Hash_mem_used, 0);
+  
+  Init_JudySet();
+}

data/ext/judy_set.c

@@ -0,0 +1,146 @@
+/************************************************    
+  Author : Torsten Rueger , Copyright 2002-20011
+  License: GPL v.2 see LICENSE
+************************************************/
+#include "judy_compat.h"
+
+// The class JudySet is a Ruby Api to a judy set. It only takes ints and symbols though
+
+typedef Tree JudySet; // JudySet == pcvoid_t
+
+static inline JudySet * Get_Set(VALUE obj) {
+  tree_object* object;
+  Check_Type(obj, T_DATA);
+  object = DATA_PTR(obj);
+  return (JudySet*)  &(object->judy) ;
+} 
+
+void gc_free_set(tree_object* set){
+  judy_set_clear(&(set->judy));
+  free(set);
+}
+
+VALUE ruby_JudySet_allocate(VALUE self) {
+  tree_object* set = malloc( sizeof(tree_object) ) ;
+  set->judy = NULL;
+  return Data_Wrap_Struct(self,  NULL, gc_free_set, set); // NULL means no marking
+}
+
+VALUE ruby_JudySet_delete(VALUE self , VALUE index) {
+  JudySet *p_set;
+  if( index == Qnil ) return Qnil ;
+  p_set = Get_Set(self) ;
+  check_index_basic(index);
+  return judy_set_delete(p_set , index) ;
+}
+
+VALUE ruby_JudySet_set(VALUE self , VALUE index , VALUE value ) {
+  JudySet *p_set;
+  if( index == Qnil ) return Qnil ;
+  if( value == Qnil || value == Qfalse ) return ruby_JudySet_delete(self , index) ;
+  p_set = Get_Set(self) ;
+  check_index_basic(index);
+  return judy_set_set(p_set , index);
+}
+
+VALUE ruby_JudySet_add(VALUE self , VALUE index ) {
+  JudySet *p_set;
+  if( index == Qnil ) return Qnil ;
+  p_set = Get_Set(self) ;
+  check_index_basic(index);
+  return judy_set_set(p_set , index);
+}
+
+VALUE ruby_JudySet_get(VALUE self , VALUE index) {
+  JudySet *p_set;
+  if( index == Qnil ) return Qnil ;
+  p_set = Get_Set(self) ;
+  check_index_basic(index);
+  return judy_set_has(p_set , index) ? Qtrue : Qfalse ;
+}
+
+VALUE ruby_JudySet_length(VALUE self) {
+  JudySet *p_set = Get_Set(self) ;
+  return judy_set_length(p_set);
+}
+
+VALUE ruby_JudySet_by_count(VALUE self, VALUE num) {
+  JudySet *p_set = Get_Set(self) ;
+  check_index_basic(num);
+  return judy_set_at_count(p_set, num )  ;
+}
+
+VALUE ruby_JudySet_mem_used(VALUE self) {
+  JudySet *p_set = Get_Set(self) ;
+  return judy_set_mem(p_set);
+}
+
+VALUE ruby_JudySet_first_index(VALUE self) {
+    JudySet *p_set = Get_Set(self) ;
+    return judy_set_first_index(p_set);
+}
+
+VALUE ruby_JudySet_next_index(VALUE self, VALUE index) {
+  JudySet *p_set = Get_Set(self) ;
+  check_index_basic(index);
+  return judy_set_next_index(p_set, index);
+}
+
+VALUE ruby_JudySet_last_index(VALUE self) {
+    JudySet *p_set = Get_Set(self) ;
+    return judy_set_last_index(p_set);
+}
+
+VALUE ruby_JudySet_clear(VALUE self) {
+  JudySet *p_set = Get_Set(self) ;
+  VALUE len = ruby_JudySet_length(self) ;
+  judy_set_clear(p_set);
+  return len;
+}
+
+VALUE ruby_JudySet_each(VALUE self) {
+  JudySet *p_set = Get_Set(self) ;
+  VALUE index =  judy_set_first_index(p_set);
+  while(index != Qfalse ){
+    rb_yield(index);
+    index = judy_set_next_index(p_set, index);
+  }
+  return self;
+}
+
+VALUE ruby_JudySet_sum(VALUE self  ) {
+  long int ret = 0;
+  JudySet *p_set = Get_Set(self) ;
+  VALUE index =  judy_set_first_index(p_set);
+  while(index != Qfalse ){
+    ret +=  NUM2LONG(index) ;
+    index = judy_set_next_index(p_set, index);
+  }
+  return LONG2NUM(ret);
+}
+
+void Init_JudySet(void) {
+  VALUE cJudySet_klass = rb_define_class("JudySet", rb_cObject);
+  rb_include_module(cJudySet_klass, rb_eval_string("Enumerable"));
+  rb_define_singleton_method(cJudySet_klass, "new", ruby_JudySet_allocate, 0);
+  rb_define_method(cJudySet_klass, "do_set", ruby_JudySet_set, 2);
+  rb_define_method(cJudySet_klass, "set", ruby_JudySet_set, 2);
+  rb_define_method(cJudySet_klass, "[]=", ruby_JudySet_set, 2);
+  rb_define_method(cJudySet_klass, "add", ruby_JudySet_add, 1);
+  rb_define_method(cJudySet_klass, "delete", ruby_JudySet_delete, 1);
+  rb_define_method(cJudySet_klass, "unset", ruby_JudySet_delete, 1);
+  rb_define_method(cJudySet_klass, "get", ruby_JudySet_get, 1);
+  rb_define_method(cJudySet_klass, "do_get", ruby_JudySet_get, 1);
+  rb_define_method(cJudySet_klass, "[]", ruby_JudySet_get, 1);
+  rb_define_method(cJudySet_klass, "length", ruby_JudySet_length, 0);
+  rb_define_method(cJudySet_klass, "by_count", ruby_JudySet_by_count, 1);
+  rb_define_method(cJudySet_klass, "mem_used", ruby_JudySet_mem_used, 0);
+  rb_define_method(cJudySet_klass, "first_index", ruby_JudySet_first_index, 0);
+  rb_define_method(cJudySet_klass, "next_index", ruby_JudySet_next_index, 1);
+  rb_define_method(cJudySet_klass, "last_index", ruby_JudySet_last_index, 0);
+  rb_define_method(cJudySet_klass, "clear", ruby_JudySet_clear, 0);
+  rb_define_method(cJudySet_klass, "each", ruby_JudySet_each, 0);
+  rb_define_method(cJudySet_klass, "each_index", ruby_JudySet_each, 0);
+  rb_define_method(cJudySet_klass, "sum", ruby_JudySet_sum, 2);    
+}
+