google_hash 0.4.0 → 0.5.1

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.5.1

data/ext/extconf.rb

@@ -34,49 +34,51 @@ else
   unreachable_int = 63
 end
 
-ruby_key =  {:convert_keys_from_ruby => "", :convert_keys_to_ruby => "", :key_type => "VALUE", :unreachable_key => "current_instance"} # TODO NULL is false here?
-#long is not useful to us since we don't support BigNum yet
-# i.e. long is basically broken till we do
-#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}"}
+ruby_key =  {:convert_keys_from_ruby => "", :convert_keys_to_ruby => "", :key_type => "VALUE", :english_key_type => "ruby",
+  :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}"}
+  :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",
+  :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...
 
 
-ruby_value =  {:value_type => "VALUE"}
-#long_value = {:assert_value_type => 'T_FIXNUM', :convert_values_from_ruby => "FIX2LONG",
-#:convert_values_to_ruby => "LONG2FIX", :value_type => "long"}
+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"}
+  :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", }
 
 init_funcs = []
 
-for key in [ruby_key, int_key] do
+for key in [ruby_key, int_key, bignum_key] do
   for value in [ruby_value, int_value] do
     options = key.merge(value)
     for type in ['sparse', 'dense'] do
 
-
       # create local variables so that the template can look cleaner
       unreachable_key = options[:unreachable_key]
       convert_keys_from_ruby = options[:convert_keys_from_ruby]
       convert_keys_to_ruby = options[:convert_keys_to_ruby]
       key_type = options[:key_type]
       value_type = options[:value_type]
-      english_key_type = options[:key_type] == 'VALUE' ? 'ruby' : options[:key_type]
-      english_value_type = options[:value_type] == 'VALUE' ? 'ruby' : options[:value_type]
+      english_key_type = options[:english_key_type] || options[:key_type]
+      english_value_type = options[:english_value_type] || options[:value_type]
 
-      assert_key_type = options[:assert_key_type]
+      
+      assert_key_type = [options[:assert_key_type]].flatten[0]
+      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]
 
-      if options[:key_type] == 'VALUE'
-        extra_hash_params =  ", hashrb, eqrb"
-      else
-        extra_hash_params = nil
-      end
-
+      extra_hash_params = options[:extra_hash_params]
+      
       template = ERB.new(File.read('template/google_hash.cpp.erb'))
       descriptor = type + '_' + english_key_type + '_to_' + english_value_type;
       File.write(descriptor + '.cpp', template.result(binding))

data/ext/go.bat

@@ -1,3 +1,6 @@
 rm *.cpp 
 rm *.o
-ruby extconf.rb && make clean && make && ruby ..\spec\spec.google_hash.rb
+rm *.so
+ruby extconf.rb
+call make
+spec.bat

data/ext/template/google_hash.cpp.erb

@@ -11,6 +11,7 @@ using std::endl;
   #include <ext/hash_set>
 <% end %>
 using __gnu_cxx::hash;  // or __gnu_cxx::hash, or maybe tr1::hash, depending on your OS
+
 extern "C" {
 
 // some helpers
@@ -40,6 +41,37 @@ struct eqint
 
 static ID id_eql, id_hash;
 
+<% if key_type == 'double' %>
+
+struct eqdouble
+
+{
+
+  bool operator()(const double &f1, const double &f2) const
+
+  {
+
+    return f1 == f2;
+
+  }
+
+};
+
+
+extern hash<int> inthash;
+
+struct hashdouble {
+
+  size_t operator ()(const double& foo) const {
+
+    return inthash((int)foo);
+
+  }
+
+};
+
+<% end %>
+
 <% if key_type == 'VALUE' %>
 static hash<const char*> H;
 
@@ -103,33 +135,27 @@ struct hashrb
             switch (TYPE(hval)) {
               case T_FIXNUM:
 	              return hval;
-<% unless RUBY_VERSION < '1.9' %>
               case T_BIGNUM:
 	              return LONG2FIX(((long*)(RBIGNUM_DIGITS(hval)))[0]);
-<% end %>
-
               default:
 	              hval = rb_to_int(hval);
 	              goto retry;
-        }  
-  
+              }
       }
 };
 
 <% end %>
 
-/* we end up not needing this...or at least not using it, I don't know if it would be faster than using the default or not
-*/
-
 
 typedef struct {
   <%= type %>_hash_map< <%= key_type %>, <%= value_type %> <%= extra_hash_params %> > *hash_map;
 } RCallback;
 
-
 static void mark_hash_map_values(RCallback *incoming) {
   <% if value_type == 'VALUE' || key_type == 'VALUE' %>
-
+    
+    // only need to iterate if we store *real* Ruby values
+    
     for(<%= type %>_hash_map< <%= key_type %>, <%= value_type %> <%= extra_hash_params %> >::iterator it = incoming->hash_map->begin(); it != incoming->hash_map->end(); ++it) {
      
      <% if value_type == 'VALUE' %>
@@ -180,16 +206,18 @@ rb_mri_hash_new(VALUE freshly_created) {
 static VALUE rb_ghash_set(VALUE cb, VALUE set_this, VALUE to_this) {
   <% if assert_key_type %>
     if(!(TYPE(set_this) == <%= assert_key_type %>)) {
-       rb_raise(rb_eTypeError, "not valid key #{assert_key_type}");
+       <%= "if(!(TYPE(set_this) == #{assert_key_type2}))" if assert_key_type2 %>
+         rb_raise(rb_eTypeError, "not valid key (expected <%= assert_key_type %>)");
     }
   <% end %>
   
   <% if assert_value_type %>
     if(!(TYPE(to_this) == <%= assert_value_type %>)) {
-       rb_raise(rb_eTypeError, "not valid value #{assert_value_type}");
+       rb_raise(rb_eTypeError, "not valid value <%=assert_value_type%>");
     }
   <% end %>
 
+  <%= options[:extra_set_code] %>
   
   RCallback* cbs = GetCallbackStruct(cb);
   (*cbs->hash_map)[ <%= convert_keys_from_ruby %>(set_this)] = <%= convert_values_from_ruby %>(to_this);  
@@ -197,13 +225,15 @@ static VALUE rb_ghash_set(VALUE cb, VALUE set_this, VALUE to_this) {
 }
 
 static VALUE rb_ghash_get(VALUE cb, VALUE get_this) {
-  // TODO optionally not assert [?]
+  // TODO optionally not type check assert anywhere [?]
   <% if assert_key_type %>
     if(!(TYPE(get_this) == <%= assert_key_type %>)) {
-       rb_raise(rb_eTypeError, "not valid key #{assert_key_type}");
+       <%= "if(!(TYPE(get_this) == #{assert_key_type2}))" if assert_key_type2 %>
+         rb_raise(rb_eTypeError, "not valid get key (expected <%=assert_key_type%>)");
     }
   <% end %>
   RCallback* cbs = GetCallbackStruct(cb);
+  <%= options[:extra_get_code] %>
   
   <%= type %>_hash_map< <%= key_type %>, <%= value_type %> <%= extra_hash_params %> >::iterator out = cbs->hash_map->find(<%= convert_keys_from_ruby %>(get_this));
   
@@ -241,7 +271,7 @@ static VALUE rb_ghash_keys(VALUE cb) {
 }
 
 
-// only yields for now :)
+// only does yields (blocks) for now :)
 
 static VALUE rb_ghash_combination_2(VALUE cb) {
     RCallback* incoming = GetCallbackStruct(cb);

data/ext/template/main.cpp.erb

@@ -13,7 +13,6 @@ void Init_google_hash() {
 <% end %>
   
   rb_eval_string("GoogleHash = GoogleHashDenseRubyToRuby"); // give a default
-  printf("I set it!");
  }
  
 }

data/spec/spec.google_hash.rb

@@ -1,12 +1,16 @@
 require 'rubygems' if RUBY_VERSION < '1.9'
 require 'sane'
 require_relative '../ext/google_hash.so'
-require 'spec/autorun'
+begin
+  require 'spec/autorun'
+rescue LoadError
+  require 'rspec' # rspec2
+end
 
 describe "google_hash" do
 
   before do
-   @subject = GoogleHashSparseLongToRuby.new
+   @subject = GoogleHashSparseIntToRuby.new
   end
 
   it "should be instantiable" do
@@ -141,7 +145,6 @@ describe "google_hash" do
     assert sum == 1 + 2 + 1 + 3 + 2 + 3
   end
 
-
   it "should have an Array for values, keys" do
     @subject[33] = 34
     @subject.keys.should == [33]
@@ -149,22 +152,82 @@ describe "google_hash" do
   end
   
   it "should work with all Longs" do
-    a = GoogleHashDenseLongToLong.new
+    a = GoogleHashDenseIntToInt.new
     a[3] = 4
     a[3].should == 4
   end
   
   it "should raise on errant values" do
-    a = GoogleHashDenseLongToLong.new
+    a = GoogleHashDenseIntToInt.new
     proc { a[3] = 'abc'}.should raise_error
-  end  
+  end
   
-  it "should have an Enumerator for values, keys, on demand"
+  it "should do bignum values as doubles" do
+    a = GoogleHashDenseDoubleToInt.new
+    a[10000000000000000000] = 1
+    a[10000000000000000000].should == 1
+  end
   
-  it "should have a block for values, keys, on demand"
+  it "should not leak" do
+    a = GoogleHashDenseIntToInt.new
+    100_000.times {
+      a[1] = 1
+      a[1]
+      a.each{|k, v|}
+      a.delete(1) rescue nil
+    }
+    OS.rss_bytes.should be < 25_000_000
+  end
   
-  it "should have real sets"
+  it "should do int values as doubles" do
+    a = GoogleHashDenseDoubleToInt.new
+    a[1] = 1
+    a[1].should == 1
+  end
+
+  it "should do float values as doubles" do
+    a = GoogleHashDenseDoubleToInt.new
+    a[1.0] = 1
+    a[1.0].should == 1
+  end
   
-  it "should skip GC when native to native"
+  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[10000000000000000000] = 10000000000000000000
+    a[10000000000000000000].should == 10000000000000000000
+  end
+  
+  it "should have really real bignums" do
+    pending
+    fail 'same as above plus'
+    a = GoogleHashDenseBignumToRuby.new
+    a[10000000000000000000] = 'abc'
+  end
+  
+  it 'should be able to delete bignums without leaking' do
+    pending
+    a = GoogleHashDenseBignumToBignum.new
+    100_000.times {
+      a[10000000000000000000] = 1
+      a.size.should == 1
+      a.delete[10000000000000000000]
+      a.size.should == 0
+    }
+    assert OS.rss_bytes < 100_000
+  end
+  
+  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 sets, too, not just hashes"
+  
+  it "should skip GC when native to native" do
+  end
 
 end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: google_hash
 version: !ruby/object:Gem::Version 
-  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 4
-  - 0
-  version: 0.4.0
+  - 5
+  - 1
+  version: 0.5.1
 platform: ruby
 authors: 
 - rogerdpack
@@ -26,7 +25,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -144,7 +142,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -153,7 +150,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"