google_hash 0.5.1 → 0.6.0

data/README

@@ -28,26 +28,51 @@ See also the results.txt file
 
 Usage:
 
-a = GoogleHashDenseRubyToRuby.new
-b = GoogleHashDenseIntToRuby.new # :int => Ruby
+a = GoogleHashDenseRubyToRuby.new # like a normal Ruby hash, with slightly different performance characteristics, see benchmarks.txt
+b = GoogleHashDenseIntToRuby.new # :int => Ruby -- keys are stored as "native" ints, values are ruby objects
 c = GoogleHashSparseIntToInt.new # :int => :int
-d = GoogleHashSparseIntToInt.new # :long => :long  (longs are 8 byte ints on 64-bit machines, so can store larger numbers)
+
+Here's the full list of availables:
+
+>> Object.constants.each{|k k if k =~ /google/i }
+
+GoogleHashDenseLongToLong
+GoogleHashSparseLongToLong
+GoogleHashDenseLongToInt
+GoogleHashSparseLongToInt
+GoogleHashDenseLongToRuby
+GoogleHashSparseLongToRuby
+GoogleHashDenseDoubleToLong
+GoogleHashSparseDoubleToLong
+GoogleHashDenseDoubleToInt
+GoogleHashSparseDoubleToInt
+GoogleHashDenseDoubleToRuby
+GoogleHashSparseDoubleToRuby
+GoogleHashDenseIntToLong
+GoogleHashSparseIntToLong
+GoogleHashDenseIntToInt
+GoogleHashSparseIntToInt
+GoogleHashDenseIntToRuby
+GoogleHashSparseIntToRuby
+GoogleHashDenseRubyToLong
+GoogleHashSparseRubyToLong
+GoogleHashDenseRubyToInt
+GoogleHashSparseRubyToInt
+GoogleHashDenseRubyToRuby
+GoogleHashSparseRubyToRuby
+
+(long is "better" than int on 64 bit systems only)
+
+and how to use them:
 
 a[3] = 4
 b[4] = 'abc'
 b['abc'] = 'some complex object' 
 c[3] = 4 # all you can use are ints...
 
-a.each{|k, v| ... }
-
-a.keys 
- => Array
-a.values 
- => Array
-
-For a complete list, see types.txt, but it's all the various combinations of Ruby, Int, and Long.
+Use them like "normal" hashes with the same method names.
 
-To learn if sparse or dense is right for you, check their documentation: 
+To learn if sparse or dense is right for you, check the documentation: 
 
 http://google-sparsehash.googlecode.com/svn/trunk/doc/index.html
 Dense is faster, sparse uses less memory.
@@ -64,7 +89,7 @@ ex: currently it uses longs internally instead of ints--if you want ints or char
 
 if you want it to remember insertion order, I could do that, too, or native "store away" strings/bignums, whatever.
 
-Could also add vectors, vector(pairs), priority queues, floats, native bignums, other more complex types, if anybody asks me to.
+Could also add vectors, vector(pairs), priority queues, floats, native bignums, other more complex types, if anybody wants me to.
 
 This is meant to be one more tool in the rubyists toolbelt when trying to optimize speed-wise, and plans to expand to more types, but at least with this release it has a #each method.
 
@@ -80,4 +105,4 @@ Related:
 
 judy http://groups.google.com/group/ruby-talk-google/browse_thread/thread/05ed587925526a7f/314375891d12b672?lnk=raot
 
-NArray gem : provides "native" type arrays (and X-D array)
+NArray gem : provides "native" type arrays (and X-Dimensional arrays--all in native memory, so also saves memory as this gem does)

data/VERSION

@@ -1 +1 @@
-0.5.1
+0.6.0

data/ext/extconf.rb

@@ -38,26 +38,35 @@ ruby_key =  {:convert_keys_from_ruby => "", :convert_keys_to_ruby => "", :key_ty
   :extra_hash_params => ", hashrb, eqrb", :unreachable_key => "current_instance"} # TODO NULL is false here?
 int_key = {:assert_key_type => 'T_FIXNUM', :convert_keys_from_ruby => "FIX2INT",
   :convert_keys_to_ruby => "INT2FIX", :key_type => "int", :unreachable_key => "1<<#{unreachable_int}"}
-# "long" is not useful to us since it's the same as int...
-bignum_key = {:assert_key_type => ['T_BIGNUM', 'T_FIXNUM'], :convert_keys_from_ruby => "rb_big2dbl",
+  
+# "long" is useful on 64 bit...
+long_key = {:assert_key_type => 'T_FIXNUM', :convert_keys_from_ruby => "FIX2LONG",
+  :convert_keys_to_ruby => "LONG2FIX", :key_type => "long", :unreachable_key => "1<<#{unreachable_int}"}
+
+
+bignum_as_double_key = {:assert_key_type => ['T_BIGNUM', 'T_FIXNUM'], :convert_keys_from_ruby => "rb_big2dbl",
   :convert_keys_to_ruby => "rb_dbl2big", :key_type => "double", :unreachable_key => "1<<#{unreachable_int}",  # LODO is this a bignum value though?
   :extra_hash_params => ", hashdouble, eqdouble",
-  :extra_set_code => "if(TYPE(set_this) == T_FIXNUM)\nset_this = rb_int2big(set_this);",
-  :extra_get_code => "if(TYPE(get_this) == T_FIXNUM) \n get_this = rb_int2big(get_this);"
-}  # fixnum's can never be zero...
-
+  :extra_set_code => "if(TYPE(set_this) == T_FIXNUM)\nset_this = rb_int2big(FIX2INT(set_this));",
+  :extra_get_code => "if(TYPE(get_this) == T_FIXNUM) \n get_this = rb_int2big(FIX2INT(get_this));"
+}
 
 ruby_value = {:value_type => "VALUE", :english_value_type => "ruby"}
 int_value = {:assert_value_type => 'T_FIXNUM', :convert_values_from_ruby => "FIX2INT",
   :convert_values_to_ruby => "INT2FIX", :value_type => "int"}
-
-  #bignum_value = {:assert_value_type => 'T_BIGNUM', :convert_values_from_ruby => "rb_big2dbl",
-  #:convert_values_to_ruby => "rb_dbl2big", :value_type => "double", }
-
+long_value = {:assert_value_type => 'T_FIXNUM', :convert_values_from_ruby => "FIX2LONG",
+  :convert_values_to_ruby => "LONG2FIX", :value_type => "long"}
+  
+bignum_as_double_value = {:assert_value_type => ['T_BIGNUM', 'T_FIXNUM'], :convert_values_from_ruby => "rb_big2dbl",
+  :convert_values_to_ruby => "rb_dbl2big", :value_type => "double",
+  :extra_set_code2 => "if(TYPE(to_this) == T_FIXNUM)\nto_this = rb_int2big(FIX2INT(to_this));"
+}
+  
+  
 init_funcs = []
 
-for key in [ruby_key, int_key, bignum_key] do
-  for value in [ruby_value, int_value] do
+for key in [ruby_key, int_key, bignum_as_double_key, long_key] do
+  for value in [ruby_value, int_value, long_value, bignum_as_double_value] do
     options = key.merge(value)
     for type in ['sparse', 'dense'] do
 
@@ -75,7 +84,8 @@ for key in [ruby_key, int_key, bignum_key] do
       assert_key_type2 = [options[:assert_key_type]].flatten[1]
       convert_values_from_ruby = options[:convert_values_from_ruby]
       convert_values_to_ruby = options[:convert_values_to_ruby]
-      assert_value_type = options[:assert_value_type]
+      assert_value_type = [options[:assert_value_type]].flatten[0]
+      assert_value_type2 = [options[:assert_value_type]].flatten[1]
 
       extra_hash_params = options[:extra_hash_params]
       

data/ext/temp/extconf.rb

@@ -0,0 +1,11 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+# Give it a name
+extension_name = 'mytest'
+
+# The destination
+dir_config(extension_name)
+
+# Do the work
+create_makefile(extension_name)

data/ext/template/google_hash.cpp.erb

@@ -73,9 +73,8 @@ struct hashdouble {
 <% end %>
 
 <% if key_type == 'VALUE' %>
-static hash<const char*> H;
-
-// hashing it is like hash<const char*>
+// static hash<const char*> H; // unused currently...
+// using it is like hash<const char*>
 
 struct eqrb
 {
@@ -213,18 +212,21 @@ static VALUE rb_ghash_set(VALUE cb, VALUE set_this, VALUE to_this) {
   
   <% if assert_value_type %>
     if(!(TYPE(to_this) == <%= assert_value_type %>)) {
+      <%= "if(!(TYPE(to_this) == #{assert_value_type2}))" if assert_value_type2 %>
        rb_raise(rb_eTypeError, "not valid value <%=assert_value_type%>");
     }
   <% end %>
 
   <%= options[:extra_set_code] %>
   
+  <%= options[:extra_set_code2] %>
+  
   RCallback* cbs = GetCallbackStruct(cb);
   (*cbs->hash_map)[ <%= convert_keys_from_ruby %>(set_this)] = <%= convert_values_from_ruby %>(to_this);  
   return to_this; // ltodo test that it returns value...
 }
 
-static VALUE rb_ghash_get(VALUE cb, VALUE get_this) {
+static VALUE rb_ghash_get(VALUE cb, VALUE get_this, int just_check_for_presence) {
   // TODO optionally not type check assert anywhere [?]
   <% if assert_key_type %>
     if(!(TYPE(get_this) == <%= assert_key_type %>)) {
@@ -237,12 +239,33 @@ static VALUE rb_ghash_get(VALUE cb, VALUE get_this) {
   
   <%= type %>_hash_map< <%= key_type %>, <%= value_type %> <%= extra_hash_params %> >::iterator out = cbs->hash_map->find(<%= convert_keys_from_ruby %>(get_this));
   
-  if(out == cbs->hash_map->end()) { // not found...hmm...is this False, though?
-    return Qnil;
-  } else {
-    return <%= convert_values_to_ruby %>(out->second);
+  if(out == cbs->hash_map->end()) { // not found...hmm...is this False, though?
+    if(just_check_for_presence)
+      return Qfalse;
+    else
+      return Qnil;
+  } else {
+    if(just_check_for_presence)
+      return Qtrue;
+    else
+      return <%= convert_values_to_ruby %>(out->second);
   }
+  
 }
+
+static VALUE rb_ghash_get_value(VALUE cb, VALUE get_this) {
+  return rb_ghash_get(cb, get_this, 0);
+}
+
+static VALUE rb_ghash_get_present(VALUE cb, VALUE get_this) {
+  return  rb_ghash_get(cb, get_this, 1);
+}
+
+static VALUE rb_ghash_size(VALUE cb) {
+  RCallback* incoming = GetCallbackStruct(cb);
+  return INT2FIX(incoming->hash_map->size());
+}
+
 
 static VALUE rb_ghash_each(VALUE cb) {
     RCallback* incoming = GetCallbackStruct(cb);
@@ -299,11 +322,16 @@ void init_<%= type %>_<%= english_key_type %>_to_<%= english_value_type %>() {
 
     rb_define_method(rb_cGoogleHashLocal, "initialize", RUBY_METHOD_FUNC(rb_mri_hash_new), 0); 
     rb_define_method(rb_cGoogleHashLocal, "[]=", RUBY_METHOD_FUNC(rb_ghash_set), 2); 
-    rb_define_method(rb_cGoogleHashLocal, "[]", RUBY_METHOD_FUNC(rb_ghash_get), 1); 
+    rb_define_method(rb_cGoogleHashLocal, "[]", RUBY_METHOD_FUNC(rb_ghash_get_value), 1); 
     rb_define_method(rb_cGoogleHashLocal, "each", RUBY_METHOD_FUNC(rb_ghash_each), 0);
     rb_define_method(rb_cGoogleHashLocal, "values", RUBY_METHOD_FUNC(rb_ghash_values), 0); 
     rb_define_method(rb_cGoogleHashLocal, "keys", RUBY_METHOD_FUNC(rb_ghash_keys), 0); 
+    rb_define_method(rb_cGoogleHashLocal, "has_key?", RUBY_METHOD_FUNC(rb_ghash_get_present), 1);
+    rb_define_method(rb_cGoogleHashLocal, "key?", RUBY_METHOD_FUNC(rb_ghash_get_present), 1);
+    rb_define_method(rb_cGoogleHashLocal, "member?", RUBY_METHOD_FUNC(rb_ghash_get_present), 1);
+    rb_define_method(rb_cGoogleHashLocal, "include?", RUBY_METHOD_FUNC(rb_ghash_get_present), 1);
     rb_define_method(rb_cGoogleHashLocal, "keys_combination_2", RUBY_METHOD_FUNC(rb_ghash_combination_2), 0); 
+    rb_define_method(rb_cGoogleHashLocal, "length", RUBY_METHOD_FUNC(rb_ghash_size), 0);
     id_eql = rb_intern("eql?");
     id_hash = rb_intern("hash");
   } 

data/spec/spec.google_hash.rb

@@ -1,6 +1,6 @@
-require 'rubygems' if RUBY_VERSION < '1.9'
+require 'rubygems'
 require 'sane'
-require_relative '../ext/google_hash.so'
+require_relative '../ext/google_hash'
 begin
   require 'spec/autorun'
 rescue LoadError
@@ -13,8 +13,8 @@ describe "google_hash" do
    @subject = GoogleHashSparseIntToRuby.new
   end
 
-  it "should be instantiable" do
-    # nothing
+  it "should be instantiable [new method should not raise]" do
+    GoogleHashSparseIntToRuby.new
   end
 
   it "should allow you to set a key" do
@@ -36,23 +36,38 @@ describe "google_hash" do
    assert all_got.sort == ['abc', 'def']
   end
 
+  it "should have key methods" do
+    @subject = a = GoogleHashDenseDoubleToInt.new
+    @subject[33] = 3
+    for method in [:has_key?, :include?, :key?, :member?] do
+      @subject.send(method, 33).should == true
+      @subject.send(method, 34).should == false
+    end
+    
+  end
+  
   it "should have all the methods desired" do
-    pending "need"
     # guess these could all be tests, themselves...
-    @subject.each_key {}
-    @subject.each_value{}
     @subject.each{}
     @subject[33] = 'abc'
     @subject.length.should == 1
+    @subject.each{}
+    @subject.each{|k, v|
+      k.should == 33
+      v.should == 'abc'
+    }
     @subject.delete(33).should == 'abc'
+    @subject.length.should == 0
+    @subject[33] = 'abc'
+    @subject.length.should == 1
     @subject.clear
     @subject.length.should == 0
   end
-
-  it "should not leak" do
-    pending "testing if it leaks"
-  end
   
+  it 'should not be able to set the absent key for double' do
+    fail
+  end
+
   def populate(a)
     a['abc'] = 'def'
     a['bbc'] = 'yoyo'
@@ -109,8 +124,8 @@ describe "google_hash" do
     pending "if necessary"
   end
 
-  it "should do longs eventually" do
-    pending "caring about 64 bit"
+  it "should do longs" do
+    GoogleHashDenseLongToLong.new
   end
 
   it "should do 63 bit thingy for longs on 64 bit" do
@@ -169,6 +184,7 @@ describe "google_hash" do
   end
   
   it "should not leak" do
+    pending 'something that might leak'
     a = GoogleHashDenseIntToInt.new
     100_000.times {
       a[1] = 1
@@ -186,25 +202,27 @@ describe "google_hash" do
   end
 
   it "should do float values as doubles" do
+    pending "interest in floats"
     a = GoogleHashDenseDoubleToInt.new
     a[1.0] = 1
     a[1.0].should == 1
   end
   
   it "should do bignum to doubles et al" do
-    pending
     a = GoogleHashDenseDoubleToDouble.new
     a[10000000000000000000] = 1
     a[10000000000000000000].should == 1
     a[1] = 10000000000000000000
     a[1].should == 10000000000000000000
+    a[4] = 3
+    a[4].should == 3
     a[10000000000000000000] = 10000000000000000000
     a[10000000000000000000].should == 10000000000000000000
   end
   
-  it "should have really real bignums" do
+  it "should allow for storing true bignums" do
     pending
-    fail 'same as above plus'
+    fail 'same as above plus the following:'
     a = GoogleHashDenseBignumToRuby.new
     a[10000000000000000000] = 'abc'
   end
@@ -223,7 +241,12 @@ describe "google_hash" do
   
   it "should have an Enumerator for values, keys, an on demand, getNext enumerator object..."
   
-  it "should have a block access for values, keys"
+  it "should have a block access for values, keys" do
+    pending "interest"
+    @a[3] = 4
+    a.each_value {}
+    a.each_key {}
+  end
   
   it "should have sets, too, not just hashes"
   

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 5
-  - 1
-  version: 0.5.1
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - rogerdpack
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-22 00:00:00 -06:00
+date: 2010-07-27 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -36,6 +36,7 @@ executables: []
 
 extensions: 
 - ext/extconf.rb
+- ext/temp/extconf.rb
 extra_rdoc_files: 
 - README
 files: 
@@ -128,6 +129,7 @@ files:
 - spec/scale.rb
 - spec/spec.google_hash.rb
 - types.txt
+- ext/temp/extconf.rb
 has_rdoc: true
 homepage: http://github.com/rdp/ruby_google_hash
 licenses: []