methodmissing-hwia 1.0.1 → 1.0.2

data/bench/bench.rb

@@ -3,16 +3,20 @@ $:.unshift "." #ruby 1.9.2
 require File.dirname(__FILE__) + "/../ext/hwia/hwia"
 require File.dirname(__FILE__) + "/as_hwia"
 
-STR_HASH = { :a  => 1, 'b' => 2 }.strhash
-HWIA_HASH = HashWithIndifferentAccess.new({ :a  => 1, 'b' => 2 })
+STR_HASH = { :a  => 1, 'b' => 2, 1 => 1, [1] => 1 }.strhash
+HWIA_HASH = HashWithIndifferentAccess.new({ :a  => 1, 'b' => 2, 1 => 1, [1] => 1 })
 HASH = { :d => :d, 'e' => :e } 
 
 TESTS = 10_000
 Benchmark.bmbm do |results|
-  results.report("StrHash#[:sym]") { TESTS.times { STR_HASH[:a] } }
-  results.report("HashWithIndifferentAccess#[:sym]") { TESTS.times { HWIA_HASH[:a] } }  
+  results.report("StrHash#[:sym]") { TESTS.times { STR_HASH[:sym] } }
+  results.report("HashWithIndifferentAccess#[:sym]") { TESTS.times { HWIA_HASH[:a] } }   
   results.report("StrHash#['str']") { TESTS.times { STR_HASH['b'] } }
   results.report("HashWithIndifferentAccess#['str]") { TESTS.times { HWIA_HASH['b'] } }
+  results.report("StrHash#[1]") { TESTS.times { STR_HASH[1] } }
+  results.report("HashWithIndifferentAccess#[1]") { TESTS.times { HWIA_HASH[1] } }  
+  results.report("StrHash#[[1]]") { TESTS.times { STR_HASH[[1]] } }
+  results.report("HashWithIndifferentAccess#[[1]]") { TESTS.times { HWIA_HASH[[1]] } }  
   results.report("StrHash#key?(:sym)") { TESTS.times { STR_HASH.key?(:a) } }
   results.report("HashWithIndifferentAccess#key?(:sym)") { TESTS.times { HWIA_HASH.key?(:a) } }  
   results.report("StrHash#key?('str')") { TESTS.times { STR_HASH.key?('a') } }
@@ -29,6 +33,10 @@ Benchmark.bmbm do |results|
   results.report("HashWithIndifferentAccess#['str]=") { TESTS.times { HWIA_HASH['c'] = :c } }  
   results.report("StrHash#[:sym]=") { TESTS.times { STR_HASH[:c] = :c } }
   results.report("HashWithIndifferentAccess#[:sym]=") { TESTS.times { HWIA_HASH[:c] = :c } }
+  results.report("StrHash#[2]=") { TESTS.times { STR_HASH[2] = 2 } }
+  results.report("HashWithIndifferentAccess#[2]=") { TESTS.times { HWIA_HASH[2] = 2 } } 
+  results.report("StrHash#[[2]]=") { TESTS.times { STR_HASH[[2]] = 2 } }
+  results.report("HashWithIndifferentAccess#[[2]]=") { TESTS.times { HWIA_HASH[[2]] = 2 } }   
   results.report("StrHash#update") { TESTS.times { STR_HASH.update(HASH) } }
   results.report("HashWithIndifferentAccess#update") { TESTS.times { HWIA_HASH.update(HASH) } } 
   results.report("StrHash#dup") { TESTS.times { STR_HASH.dup } }
@@ -37,4 +45,8 @@ Benchmark.bmbm do |results|
   results.report("HashWithIndifferentAccess#merge") { TESTS.times { HWIA_HASH.merge(HASH) } }
   results.report("StrHash#to_hash") { TESTS.times { STR_HASH.to_hash } }
   results.report("HashWithIndifferentAccess#to_hash") { TESTS.times { HWIA_HASH.to_hash } }
+  results.report("StrHash#keys") { TESTS.times { STR_HASH.keys } }
+  results.report("HashWithIndifferentAccess#keys") { TESTS.times { HWIA_HASH.keys } } 
+  results.report("StrHash#values") { TESTS.times { STR_HASH.values } }
+  results.report("HashWithIndifferentAccess#values") { TESTS.times { HWIA_HASH.values } }   
 end  

data/ext/hwia/hwia.c

@@ -38,44 +38,44 @@ strhash(register const char *string)
     register int c;
     register int val = 0;
     while ((c = *string++) != '\0') {
-	  val = val*997 + c;
+    val = val*997 + c;
     }
     return val + (val>>5);
 }
 
 int
-rb_sym_strhash(VALUE sym)
+rb_sym_strhash(VALUE *sym)
 {
-	ID id = SYM2ID(sym);
+    ID id = SYM2ID(*sym);
     return strhash((char*)rb_id2name(id));
 }
 
 static VALUE
 rb_sym_strhash_m(VALUE sym)
 {
-    return INT2FIX(rb_sym_strhash(sym));
+    return INT2FIX(rb_sym_strhash(&sym));
 }
 
 int
-rb_str_strhash(VALUE str)
+rb_str_strhash(VALUE *str)
 {
-    return strhash((char*)RSTRING_PTR(str));
+    return strhash((char*)RSTRING_PTR(*str));
 }
 
 static VALUE
 rb_str_strhash_m(VALUE str)
 {
-    return INT2FIX(rb_str_strhash(str));
+    return INT2FIX(rb_str_strhash(&str));
 }
 
 int
-rb_strhash_cmp(VALUE s1,VALUE s2)
+rb_strhash_cmp(VALUE *s1,VALUE *s2)
 {
-	int s1_hash = SYMBOL_P(s1) ? rb_sym_strhash(s1) : rb_str_strhash(s1);
-	int s2_hash = SYMBOL_P(s2) ? rb_sym_strhash(s2) : rb_str_strhash(s2);
-	if (s1_hash == s2_hash) return 0;
-	if (s1_hash > s2_hash) return 1;
-	return -1;	
+    int s1_hash = SYMBOL_P(*s1) ? rb_sym_strhash(s1) : rb_str_strhash(s1);
+    int s2_hash = SYMBOL_P(*s2) ? rb_sym_strhash(s2) : rb_str_strhash(s2);
+    if (s1_hash == s2_hash) return 0;
+    if (s1_hash > s2_hash) return 1;
+    return -1;	
 }
 
 /* hash.c */
@@ -85,7 +85,7 @@ rb_hash_has_key(hash, key)
     VALUE key;
 {
 #ifdef RUBY19
-    if (!RHASH(hash)->ntbl)
+    if (!HASH_TBL(hash))
         return Qfalse;
 #endif
     if (st_lookup(HASH_TBL(hash), key, 0)) {
@@ -111,19 +111,15 @@ rb_strhash_hash_cmp(VALUE a, VALUE b)
     VALUE args[2];
 #endif
     if (a == b) return 0;
-    if (FIXNUM_P(a) && FIXNUM_P(b)) {
-	return a != b;
+    if (FIXNUM_P(a) && FIXNUM_P(b)) return a != b;
+    if (a == Qundef || b == Qundef) return -1;
+    if (SYMBOL_P(a) && SYMBOL_P(b)) return a != b;
+    if ((TYPE(a) == T_STRING && RBASIC(a)->klass == rb_cString && SYMBOL_P(b)) || (TYPE(b) == T_STRING && RBASIC(b)->klass == rb_cString && SYMBOL_P(a))) {
+    return rb_strhash_cmp(&a, &b);
     }
     if (TYPE(a) == T_STRING && RBASIC(a)->klass == rb_cString &&
-	TYPE(b) == T_STRING && RBASIC(b)->klass == rb_cString) {
-	return rb_str_cmp(a, b);
-    }
-    if (SYMBOL_P(b) && (TYPE(a) == T_STRING && RBASIC(a)->klass == rb_cString) || (SYMBOL_P(a) && TYPE(b) == T_STRING && RBASIC(b)->klass == rb_cString)) {
-	return rb_strhash_cmp(a, b);
-    }
-    if (a == Qundef || b == Qundef) return -1;
-    if (SYMBOL_P(a) && SYMBOL_P(b)) {
-	return a != b;
+    TYPE(b) == T_STRING && RBASIC(b)->klass == rb_cString) {
+    return rb_str_cmp(a, b);
     }
 #ifdef RUBY18
     args[0] = a;
@@ -134,62 +130,42 @@ rb_strhash_hash_cmp(VALUE a, VALUE b)
 #endif
 }
 
-VALUE
-rb_strhash(VALUE obj)
-{
-    VALUE hval = rb_funcall(obj, id_hash, 0);
-#ifdef RUBY18
-	return hval; 
-#else	
- retry:
-    switch (TYPE(hval)) {
-      case T_FIXNUM:
-	return hval;
-
-      case T_BIGNUM:
-	return LONG2FIX(((long*)(RBIGNUM_DIGITS(hval)))[0]);
-
-      default:
-	hval = rb_to_int(hval);
-	goto retry;
-    }
-#endif
-}
-
 /* hash.c */
 static int
 rb_strhash_hash(VALUE a)
 {
-    VALUE hval, hnum;
+    VALUE hval;
+    int hnum;  
+
     switch (TYPE(a)) {
       case T_FIXNUM:
 #ifdef RUBY18
 	return (int)a;  
 #else
-    hnum = a;
-	break;
+    hnum = (int)a;
+    break;
 #endif	  
       case T_SYMBOL:
-	hnum = rb_sym_strhash_m(a);
-	break;
+    hnum = rb_sym_strhash(&a);
+    break;
       case T_STRING:
-	hnum = rb_str_strhash_m(a);
-	break;
+    hnum = rb_str_strhash(&a);
+    break;
 
       default:
-	hval = rb_hash(a);
+    hval = rb_hash(a);
 #ifdef RUBY18
-	if (!FIXNUM_P(hval)) {
-	    hval = rb_funcall(hval, '%', 1, hash_format);
-	}
+    if (!FIXNUM_P(hval)) {
+       hval = rb_funcall(hval, '%', 1, hash_format);
+    }
 #endif	
-	hnum = FIX2LONG(hval);
+    hnum = (int)hval;
     }
 #ifdef RUBY18
-    return (int)hnum;
+    return hnum;
 #else
     hnum <<= 1;
-    return (int)RSHIFT(hnum, 1);
+    return RSHIFT(hnum, 1);
 #endif
 }
 
@@ -199,10 +175,10 @@ static struct st_hash_type objstrhash = {
 };
 
 static void 
-rb_hash_modify_check(VALUE hash){
-    if (OBJ_FROZEN(hash)) rb_error_frozen("hash");
-    if (!OBJ_TAINTED(hash) && rb_safe_level() >= 4)
-	rb_raise(rb_eSecurityError, "Insecure: can't modify hash");
+rb_hash_modify_check(VALUE *hash){
+    if (OBJ_FROZEN(*hash)) rb_error_frozen("hash");
+    if (!OBJ_TAINTED(*hash) && rb_safe_level() >= 4)
+    rb_raise(rb_eSecurityError, "Insecure: can't modify hash");
 }
 
 /* hash.c */
@@ -212,20 +188,20 @@ rb_hash_modify(VALUE hash)
 #ifdef RUBY18	
     if (!HASH_TBL(hash)) rb_raise(rb_eTypeError, "uninitialized Hash");
 #endif
-	rb_hash_modify_check(hash);
+    rb_hash_modify_check(&hash);
 #ifdef RUBY19
    if (!HASH_TBL(hash)) HASH_TBL(hash) = st_init_table(&objstrhash);
 #endif
 }
 
-static VALUE strhash_alloc0 _((VALUE));
+static VALUE strhash_alloc0 _((VALUE*));
 static VALUE strhash_alloc _((VALUE));
 /* hash.c */
 static VALUE
-strhash_alloc0(VALUE klass)
+strhash_alloc0(VALUE *klass)
 {
     NEWOBJ(hash, struct RHash);
-    OBJSETUP(hash, klass, T_HASH);
+    OBJSETUP(hash, *klass, T_HASH);
 
     hash->ifnone = Qnil;
 
@@ -235,27 +211,24 @@ strhash_alloc0(VALUE klass)
 static VALUE
 strhash_alloc(VALUE klass)
 {
-    VALUE hash = strhash_alloc0(klass);
+    VALUE hash = strhash_alloc0(&klass);
 
     HASH_TBL(hash) = st_init_table(&objstrhash);
 
     return hash;
 }
 
-VALUE
-rb_strhash_new()
-{
-    return strhash_alloc(rb_cStrHash);
-}
-
 static VALUE rb_hash_strhash(VALUE hash);
-static VALUE rb_strhash_convert(VALUE hash, VALUE value);
+static void rb_strhash_convert(VALUE *value);
 
 /* hash.c */
 static int
 rb_hash_rehash_i(VALUE key, VALUE value, st_table *tbl)
 {
-    if (key != Qundef) st_insert(tbl, key, rb_strhash_convert(Qnil, value));
+    if (key != Qundef){ 
+      rb_strhash_convert(&value);
+      st_insert(tbl, key, value);
+    }
     return ST_CONTINUE;
 }
 
@@ -266,9 +239,9 @@ rb_strhash_rehash(VALUE hash)
     st_table *tbl;
 #ifdef RUBY19
     if (RHASH(hash)->iter_lev > 0) {
-	rb_raise(rb_eRuntimeError, "rehash during iteration");
+    rb_raise(rb_eRuntimeError, "rehash during iteration");
     }
-    rb_hash_modify_check(hash);
+    rb_hash_modify_check(&hash);
     if (!RHASH(hash)->ntbl)
         return hash;
 #endif
@@ -281,33 +254,32 @@ rb_strhash_rehash(VALUE hash)
     return hash;
 }
 
-/* temp. public API */
-static VALUE
-rb_strhash_convert(VALUE hash, VALUE val)
+static void
+rb_strhash_convert(VALUE *val)
 {
     int i;
     VALUE values;
 
-    switch (TYPE(val)) {
+    switch (TYPE(*val)) {
       case T_HASH:
-           return rb_hash_strhash(val);    
+           *val = rb_hash_strhash(*val); 
+           break;   
       case T_ARRAY:
-            values = rb_ary_new2(RARRAY_LEN(val));
-            for (i = 0; i < RARRAY_LEN(val); i++) {
-               VALUE el = RARRAY_PTR(val)[i];
+            values = rb_ary_new2(RARRAY_LEN(*val));
+            for (i = 0; i < RARRAY_LEN(*val); i++) {
+               VALUE el = RARRAY_PTR(*val)[i];
                rb_ary_push(values, (TYPE(el) == T_HASH) ? rb_hash_strhash(el) : el);
             } 
-           return values;
-      default:
-           return val;
+           *val = values;
+           break;
     }
 }
 
 static VALUE
 rb_strhash_aset(VALUE hash, VALUE key, VALUE val){
-	VALUE converted = rb_strhash_convert(hash,val);
-	rb_hash_aset(hash, key, converted);
-    return converted;
+    rb_strhash_convert(&val);
+    rb_hash_aset(hash, key, val);
+    return val;
 }
 
 /* hash.c */
@@ -318,15 +290,15 @@ rb_strhash_s_create(int argc, VALUE *argv, VALUE klass)
     int i;
 
     if (argc == 1 && TYPE(argv[0]) == T_HASH) {
-	hash = strhash_alloc0(klass);
-	HASH_TBL(hash) = st_copy(HASH_TBL(argv[0]));
-	HASH_TBL(hash)->type = &objstrhash;
-	RHASH(hash)->ifnone = RHASH(argv[0])->ifnone;
-	return rb_strhash_rehash(hash);
+    hash = strhash_alloc0(&klass);
+    HASH_TBL(hash) = st_copy(HASH_TBL(argv[0]));
+    HASH_TBL(hash)->type = &objstrhash;
+    RHASH(hash)->ifnone = RHASH(argv[0])->ifnone;
+    return rb_strhash_rehash(hash);
     }
 
     if (argc % 2 != 0) {
-	rb_raise(rb_eArgError, "odd number of arguments for Hash");
+    rb_raise(rb_eArgError, "odd number of arguments for Hash");
     }
 
     hash = strhash_alloc(klass);
@@ -340,15 +312,15 @@ rb_strhash_s_create(int argc, VALUE *argv, VALUE klass)
 static VALUE
 rb_strhash_strhash(VALUE hash)
 {
-	return hash;
+    return hash;
 }
 
 static VALUE
 rb_hash_strhash(VALUE hash)
 {
-	VALUE args[1];
-	args[0] = hash;
-	return rb_strhash_s_create(1, (VALUE *)args, rb_cStrHash);
+    VALUE args[1];
+    args[0] = hash;
+    return rb_strhash_s_create(1, (VALUE *)args, rb_cStrHash);
 }
 
 /* hash.c */
@@ -361,22 +333,24 @@ to_strhash(hash)
 
 /* hash.c */
 static int
-rb_strhash_update_i(VALUE key, VALUE value, VALUE hash)
+rb_strhash_update_i(VALUE key, VALUE value, VALUE *hash)
 {
     if (key == Qundef) return ST_CONTINUE;
-    st_insert(HASH_TBL(hash), key, rb_strhash_convert(hash,value));
+    rb_strhash_convert(&value);
+    st_insert(HASH_TBL(*hash), key, value);
     return ST_CONTINUE;
 }
 
 /* hash.c */
 static int
-rb_strhash_update_block_i(VALUE key, VALUE value, VALUE hash)
+rb_strhash_update_block_i(VALUE key, VALUE value, VALUE *hash)
 {
     if (key == Qundef) return ST_CONTINUE;
-    if (rb_hash_has_key(hash, key)) {
-	value = rb_yield_values(3, key, rb_hash_aref(hash, key), value);
+    if (rb_hash_has_key(*hash, key)) {
+    value = rb_yield_values(3, key, rb_hash_aref(*hash, key), value);
     }
-    st_insert(HASH_TBL(hash), key, rb_strhash_convert(hash,value));
+    rb_strhash_convert(&value);
+    st_insert(HASH_TBL(*hash), key, value);
     return ST_CONTINUE;
 }
 
@@ -385,34 +359,33 @@ static VALUE
 rb_strhash_update(VALUE hash1, VALUE hash2)
 {
 #ifdef RUBY19	
-	rb_hash_modify(hash1);
+    rb_hash_modify(hash1);
 #endif
     hash2 = to_strhash(hash2);
     if (rb_block_given_p()) {
-	rb_hash_foreach(hash2, rb_strhash_update_block_i, hash1);
+    rb_hash_foreach(hash2, rb_strhash_update_block_i, &hash1);
     }
     else {
-	rb_hash_foreach(hash2, rb_strhash_update_i, hash1);
+    rb_hash_foreach(hash2, rb_strhash_update_i, &hash1);
     }
     return hash1;
 }
 
 static VALUE
 rb_strhash_initialize(int argc, VALUE *argv, VALUE hash){
-	VALUE constructor;
-	rb_scan_args(argc, argv, "01", &constructor);
-	if(TYPE(constructor) == T_HASH){
-		return rb_strhash_update(hash,constructor);
-	}else{
-		return rb_call_super(argc,argv);
-	}		
+    VALUE constructor;
+    rb_scan_args(argc, argv, "01", &constructor);
+    if(TYPE(constructor) == T_HASH){
+      return rb_strhash_update(hash,constructor);
+    }else{
+      return rb_call_super(argc,argv);
+    }
 }
 
 static VALUE
 rb_strhash_merge(VALUE hash1, VALUE hash2){
-	/* see note in Init */
-	VALUE duped = rb_hash_strhash(hash1);
-	return rb_strhash_update(hash1,hash2);
+    /* see note in Init */
+   return rb_strhash_update(hash1,hash2);
 }
 
 /*hash.c, see rb_strhash_to_hash*/
@@ -427,13 +400,13 @@ to_hash(hash)
 static int
 rb_hash_update_i(key, value, hash)
     VALUE key, value;
-    VALUE hash;
+    VALUE *hash;
 {
     if (key == Qundef) return ST_CONTINUE;
 #ifdef RUBY19
-    st_insert(RHASH(hash)->ntbl, key, value);
+    st_insert(RHASH(*hash)->ntbl, key, value);
 #else
-    rb_hash_aset(hash, key, value);
+    rb_hash_aset(*hash, key, value);
 #endif
     return ST_CONTINUE;
 }
@@ -442,16 +415,16 @@ rb_hash_update_i(key, value, hash)
 static int
 rb_hash_update_block_i(key, value, hash)
     VALUE key, value;
-    VALUE hash;
+    VALUE *hash;
 {
     if (key == Qundef) return ST_CONTINUE;
-    if (rb_hash_has_key(hash, key)) {
-	value = rb_yield_values(3, key, rb_hash_aref(hash, key), value);
+    if (rb_hash_has_key(*hash, key)) {
+    value = rb_yield_values(3, key, rb_hash_aref(*hash, key), value);
     }
 #ifdef RUBY19
-    st_insert(RHASH(hash)->ntbl, key, value);
+    st_insert(RHASH(*hash)->ntbl, key, value);
 #else
-    rb_hash_aset(hash, key, value);
+    rb_hash_aset(*hash, key, value);
 #endif
     return ST_CONTINUE;
 }
@@ -466,29 +439,31 @@ rb_hash_update(hash1, hash2)
 #endif	
     hash2 = to_hash(hash2);
     if (rb_block_given_p()) {
-	rb_hash_foreach(hash2, rb_hash_update_block_i, hash1);
+    rb_hash_foreach(hash2, rb_hash_update_block_i, &hash1);
     }
     else {
-	rb_hash_foreach(hash2, rb_hash_update_i, hash1);
+    rb_hash_foreach(hash2, rb_hash_update_i, &hash1);
     }
     return hash1;
 }
 
 static int
-rb_strhash_to_hash_i(VALUE key, VALUE value, VALUE hash){
+rb_strhash_to_hash_i(VALUE key, VALUE value, VALUE *hash){
     if (SYMBOL_P(key)){
-      rb_hash_delete(hash,key);
-      rb_hash_aset(hash, rb_obj_as_string(key), value);
+      rb_hash_delete(*hash,key);
+      VALUE str = rb_str_new2(rb_id2name(SYM2ID(key)));
+      OBJ_FREEZE(str);
+      rb_hash_aset(*hash, str, value);
     }
     return ST_CONTINUE;
 }
 
 static VALUE
 rb_strhash_to_hash(VALUE hash){
-	VALUE hsh = rb_hash_update(rb_hash_new(), hash);
-	RHASH(hsh)->ifnone = RHASH(hash)->ifnone;
-	rb_hash_foreach(hsh, rb_strhash_to_hash_i, hsh);
-	return hsh;
+    VALUE hsh = rb_hash_update(rb_hash_new(), hash);
+    RHASH(hsh)->ifnone = RHASH(hash)->ifnone;
+    rb_hash_foreach(hsh, rb_strhash_to_hash_i, &hsh);
+    return hsh;
 }
 
 void
@@ -496,7 +471,7 @@ Init_hwia()
 {
     id_hash = rb_intern("hash");
     id_strhash = rb_intern("strhash");
-	hash_format = INT2FIX(536870923);
+    hash_format = INT2FIX(536870923);
 
     rb_cStrHash = rb_define_class("StrHash", rb_cHash);
 
@@ -512,7 +487,6 @@ Init_hwia()
     /* revist, same API, but may be clobbered */
     rb_define_method(rb_cStrHash, "dup", rb_hash_strhash, 0);
     rb_define_method(rb_cStrHash, "strhash", rb_strhash_strhash, 0);
-    rb_define_method(rb_cStrHash, "convert", rb_strhash_convert, 1);
     rb_define_method(rb_cStrHash, "[]=", rb_strhash_aset, 2);
     rb_define_method(rb_cStrHash, "store", rb_strhash_aset, 2);
     rb_define_method(rb_cStrHash, "update", rb_strhash_update, 1);
@@ -520,4 +494,4 @@ Init_hwia()
     rb_define_method(rb_cStrHash, "merge", rb_strhash_merge, 1);
     rb_define_method(rb_cStrHash, "to_hash", rb_strhash_to_hash, 0);
     rb_define_method(rb_cHash, "strhash", rb_hash_strhash, 0);
-}	
+}

data/hwia.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name     = "hwia"
-  s.version  = "1.0.1"
+  s.version  = "1.0.2"
   s.date     = "2009-08-23"
   s.summary  = "A faster HashWithIndifferentAccess (hwia) for MRI"
   s.email    = "lourens@methodmissing.com"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: methodmissing-hwia
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors: 
 - "Lourens Naud\xC3\xA9 (methodmissing)"