sparsehash 0.1.0

data/README

@@ -0,0 +1,74 @@
+= sparsehash
+
+Copyright (c) 2009 SUGAWARA Genki <sgwr_dts@yahoo.co.jp>
+
+== Description
+
+Ruby bindings for Google Sparse Hash.
+
+see {Google Sparse Hash}[http://goog-sparsehash.sourceforge.net/].
+
+== Install
+
+gem install sparsehash
+
+== Example
+
+    require 'sparsehash'
+    
+    map = Sparsehash::SparseHashMap.new
+    map['foo'] = 'bar'
+    map['zoo'] = 'baz'
+    
+    map.each do |k, v|
+      puts "#{k}=#{v}"
+    end
+    
+    set = Sparsehash::SparseHashSet.new
+    set << 'foo'
+    set << 'bar'
+    
+    set.each do |v|
+      puts v
+    end
+
+== Performance
+
+link:memory.png
+link:time.png
+
+== Project Page
+
+http://rubyforge.org/projects/sparsehash
+
+== Source Code
+
+http://coderepos.org/share/browser/lang/ruby/ruby-sparsehash
+
+== License
+
+    Copyright (c) 2009 SUGAWARA Genki <sgwr_dts@yahoo.co.jp>
+    All rights reserved.
+    
+    Redistribution and use in source and binary forms, with or without modification,
+    are permitted provided that the following conditions are met:
+    
+        * Redistributions of source code must retain the above copyright notice, 
+          this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above copyright notice, 
+          this list of conditions and the following disclaimer in the documentation 
+          and/or other materials provided with the distribution.
+        * The names of its contributors may not be used to endorse or promote products 
+           derived from this software without specific prior written permission.
+    
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+    ANY EXPRESS OR IMPLIED WARRANTIES,
+    INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 
+    FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
+    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
+    OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
+    OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 
+    DAMAGE.

data/etc/anymap.rb

@@ -0,0 +1,34 @@
+# * Sparsehash::SparseHashMap
+# * Sparsehash::DenseHashMap
+# * STL::Map
+# * GNU::HashMap (gcc only)
+#
+# (include Enumerable)
+class AnyMap
+  def [](key)
+  end
+
+  def []=(key, value)
+  end
+
+  def each
+  end
+
+  def erase(key)
+  end
+
+  def delete(key)
+  end
+
+  def size
+  end
+
+  def length
+  end
+
+  def empty?
+  end
+
+  def clear
+  end
+end

data/etc/anyset.rb

@@ -0,0 +1,34 @@
+# * Sparsehash::SparseHashSet
+# * Sparsehash::DenseHashSet
+# * STL::Set
+# * GNU::HashMap (gcc only)
+#
+# (include Enumerable)
+class AnySet
+  def insert(value)
+  end
+
+  def <<(value)
+  end
+
+  def each
+  end
+
+  def erase(value)
+  end
+
+  def delete(value)
+  end
+
+  def size
+  end
+
+  def length
+  end
+
+  def empty?
+  end
+
+  def clear
+  end
+end

data/ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+if have_library('stdc++')
+  create_makefile('sparsehash')
+end

data/ext/sparsehash.cpp

@@ -0,0 +1,429 @@
+#include <google/sparse_hash_map>
+#include <google/dense_hash_map>
+#include <google/sparse_hash_set>
+#include <google/dense_hash_set>
+
+#include <map>
+#include <set>
+
+#ifdef __GNUC__
+#include <ext/hash_map>
+#include <ext/hash_set>
+namespace std {
+  using namespace __gnu_cxx;
+}
+#endif
+
+#include "sparsehash_internal.h"
+
+namespace {
+
+struct sparsehash_equal_key {
+  bool operator() (const VALUE &x, const VALUE &y) const {
+    return (rb_funcall(x, rb_intern("=="), 1, y) == Qtrue);
+  }
+};
+
+struct sparsehash_hash {
+  size_t operator() (const VALUE &x) const {
+    VALUE hash = rb_funcall(x, rb_intern("hash"), 0);
+    return NUM2INT(hash);
+  }
+};
+
+struct stl_key_compare {
+  bool operator() (const VALUE &x, const VALUE &y) const {
+    VALUE hash_x = rb_funcall(x, rb_intern("hash"), 0);
+    VALUE hash_y = rb_funcall(y, rb_intern("hash"), 0);
+    int i_hash_x = NUM2INT(hash_x);
+    int i_hash_y = NUM2INT(hash_y);
+
+    return (i_hash_x < i_hash_y);
+  }
+};
+
+typedef google::sparse_hash_map<VALUE, VALUE, sparsehash_hash, sparsehash_equal_key> SHMap;
+typedef google::dense_hash_map<VALUE, VALUE, sparsehash_hash, sparsehash_equal_key> DHMap;
+typedef google::sparse_hash_set<VALUE, sparsehash_hash, sparsehash_equal_key> SHSet;
+typedef google::dense_hash_set<VALUE, sparsehash_hash, sparsehash_equal_key> DHSet;
+typedef std::map<VALUE, VALUE, stl_key_compare> STLMap;
+typedef std::set<VALUE, stl_key_compare> STLSet;
+
+#ifdef __GNUC__
+typedef std::hash_map<VALUE, VALUE, sparsehash_hash, sparsehash_equal_key> GNUHashMap;
+typedef std::hash_set<VALUE, sparsehash_hash, sparsehash_equal_key> GNUHashSet;
+#endif
+
+template <class T>
+void sparsehash_initialize(T *x) {
+};
+
+template <>
+void sparsehash_initialize<SHMap>(SHMap *x) {
+  x->set_deleted_key(Qnil);
+}
+
+template <>
+void sparsehash_initialize<SHSet>(SHSet *x) {
+  x->set_deleted_key(Qnil);
+}
+
+template <>
+void sparsehash_initialize<DHMap>(DHMap *x) {
+  x->set_empty_key((VALUE) NULL);
+  x->set_deleted_key(Qnil);
+}
+
+template <>
+void sparsehash_initialize<DHSet>(DHSet *x) {
+  x->set_empty_key((VALUE) NULL);
+  x->set_deleted_key(Qnil);
+}
+
+template <class T>
+void sparsehash_validate_key(VALUE &x) {
+}
+
+template <>
+void sparsehash_validate_key<SHMap>(VALUE &x) {
+  if (NIL_P(x)) {
+    rb_raise(rb_eArgError, "Invalid key: nil");
+  }
+}
+
+template <>
+void sparsehash_validate_key<SHSet>(VALUE &x) {
+  if (NIL_P(x)) {
+    rb_raise(rb_eArgError, "Invalid key: nil");
+  }
+}
+
+template <>
+void sparsehash_validate_key<DHMap>(VALUE &x) {
+  if (!x) {
+    rb_raise(rb_eArgError, "Invalid key: false");
+  } else if(NIL_P(x)) {
+    rb_raise(rb_eArgError, "Invalid key: nil");
+  }
+}
+
+template <>
+void sparsehash_validate_key<DHSet>(VALUE &x) {
+  if (!x) {
+    rb_raise(rb_eArgError, "Invalid key: false");
+  } else if(NIL_P(x)) {
+    rb_raise(rb_eArgError, "Invalid key: nil");
+  }
+}
+
+template <class T>
+struct SparsehashMap {
+  T *m;
+
+  static void mark(SparsehashMap<T> *p) {
+    if (!p->m) {
+      return;
+    }
+
+    T *m = p->m;
+
+    for(typename T::iterator i = m->begin(); i != m->end(); i++) {
+      rb_gc_mark(i->first);
+      rb_gc_mark(i->second);
+    }
+  }
+
+  static void free(SparsehashMap<T> *p) {
+    if (p->m) {
+      delete p->m;
+    }
+
+    delete p;
+  }
+
+  static VALUE alloc(VALUE klass) {
+    SparsehashMap<T> *p;
+
+    p = new SparsehashMap<T>;
+    p->m = NULL;
+
+    return Data_Wrap_Struct(klass, &mark, &free, p);
+  }
+
+  static VALUE initialize(VALUE self) {
+    SparsehashMap<T> *p;
+
+    Data_Get_Struct(self, SparsehashMap<T>, p);
+    p->m = new T;
+    sparsehash_initialize<T>(p->m);
+
+    return Qnil;
+  }
+
+  static VALUE get(VALUE self, VALUE key) {
+    SparsehashMap<T> *p;
+
+    sparsehash_validate_key<T>(key);
+    Data_Get_Struct(self, SparsehashMap<T>, p);
+    T &m = *(p->m);
+
+    VALUE value = m[key];
+
+    return(value ? value : Qnil);
+  }
+
+  static VALUE set(VALUE self, VALUE key, VALUE value) {
+    SparsehashMap<T> *p;
+
+    sparsehash_validate_key<T>(key);
+    Data_Get_Struct(self, SparsehashMap<T>, p);
+    T &m = *(p->m);
+
+    m[key] = value;
+
+    return value;
+  }
+
+  static VALUE each0(VALUE args) {
+    return rb_yield(args);
+  }
+
+  static VALUE each(VALUE self) {
+    SparsehashMap<T> *p;
+
+    rb_need_block();
+
+    Data_Get_Struct(self, SparsehashMap<T>, p);
+    T &m = *(p->m);
+    int status = 0;
+
+    for(typename T::iterator i = m.begin(); i != m.end(); i++) {
+      VALUE args = rb_ary_new3(2, i->first, i->second);
+
+      rb_protect(each0, args, &status);
+
+      if (status != 0) {
+        break;
+      }
+    }
+
+    if (status != 0) {
+      rb_jump_tag(status);
+    }
+
+    return self;
+  }
+
+  static VALUE erase(VALUE self, VALUE key) {
+    SparsehashMap<T> *p;
+
+    sparsehash_validate_key<T>(key);
+    Data_Get_Struct(self, SparsehashMap<T>, p);
+    T &m = *(p->m);
+
+    VALUE value = m[key];
+    m.erase(key);
+
+    return(value ? value : Qnil);
+  }
+
+  static VALUE size(VALUE self) {
+    SparsehashMap<T> *p;
+
+    Data_Get_Struct(self, SparsehashMap<T>, p);
+    T &m = *(p->m);
+
+    return LONG2NUM(m.size());
+  }
+
+  static VALUE empty(VALUE self) {
+    SparsehashMap<T> *p;
+
+    Data_Get_Struct(self, SparsehashMap<T>, p);
+    T &m = *(p->m);
+
+    return m.empty() ? Qtrue : Qfalse;
+  }
+
+  static VALUE clear(VALUE self) {
+    SparsehashMap<T> *p;
+
+    Data_Get_Struct(self, SparsehashMap<T>, p);
+    T &m = *(p->m);
+    m.clear();
+
+    return self;
+  }
+
+  static void init(VALUE &module, const char *name) {
+    VALUE rb_cMap = rb_define_class_under(module, name, rb_cObject);
+
+    rb_define_alloc_func(rb_cMap, &alloc);
+    rb_include_module(rb_cMap, rb_mEnumerable);
+    rb_define_private_method(rb_cMap, "initialize", __F(&initialize), 0);
+    rb_define_method(rb_cMap, "[]", __F(&get), 1);
+    rb_define_method(rb_cMap, "[]=", __F(&set), 2);
+    rb_define_method(rb_cMap, "each", __F(&each), 0);
+    rb_define_method(rb_cMap, "erase", __F(&erase), 1);
+    rb_define_method(rb_cMap, "delete", __F(&erase), 1);
+    rb_define_method(rb_cMap, "size", __F(&size), 0);
+    rb_define_method(rb_cMap, "length", __F(&size), 0);
+    rb_define_method(rb_cMap, "empty?", __F(&empty), 0);
+    rb_define_method(rb_cMap, "clear", __F(&clear), 0);
+  }
+};
+
+template <class T>
+struct SparsehashSet {
+  T *s;
+
+  static void mark(SparsehashSet<T> *p) {
+    if (!p->s) {
+      return;
+    }
+
+    T *s = p->s;
+
+    for(typename T::iterator i = s->begin(); i != s->end(); i++) {
+      rb_gc_mark(*i);
+    }
+  }
+
+  static void free(SparsehashSet<T> *p) {
+    if (p->s) {
+      delete p->s;
+    }
+
+    delete p;
+  }
+
+  static VALUE alloc(VALUE klass) {
+    SparsehashSet<T> *p;
+
+    p = new SparsehashSet<T>;
+    p->s = NULL;
+
+    return Data_Wrap_Struct(klass, &mark, &free, p);
+  }
+
+  static VALUE initialize(VALUE self) {
+    SparsehashSet<T> *p;
+
+    Data_Get_Struct(self, SparsehashSet<T>, p);
+    p->s = new T;
+    sparsehash_initialize<T>(p->s);
+
+    return Qnil;
+  }
+
+  static VALUE insert(VALUE self, VALUE value) {
+    SparsehashSet<T> *p;
+
+    sparsehash_validate_key<T>(value);
+    Data_Get_Struct(self, SparsehashSet<T>, p);
+    T &s = *(p->s);
+    s.insert(value);
+
+    return self;
+  }
+
+  static VALUE each0(VALUE arg) {
+    return rb_yield(arg);
+  }
+
+  static VALUE each(VALUE self) {
+    SparsehashSet<T> *p;
+
+    rb_need_block();
+
+    Data_Get_Struct(self, SparsehashSet<T>, p);
+    T &s = *(p->s);
+    int status = 0;
+
+    for(typename T::iterator i = s.begin(); i != s.end(); i++) {
+      rb_protect(each0, *i, &status);
+
+      if (status != 0) {
+        break;
+      }
+    }
+
+    return self;
+  }
+
+  static VALUE erase(VALUE self, VALUE value) {
+    SparsehashSet<T> *p;
+
+    sparsehash_validate_key<T>(value);
+    Data_Get_Struct(self, SparsehashSet<T>, p);
+    T &s = *(p->s);
+    s.erase(value);
+
+    return self;
+  }
+
+  static VALUE size(VALUE self) {
+    SparsehashSet<T> *p;
+
+    Data_Get_Struct(self, SparsehashSet<T>, p);
+    T &s = *(p->s);
+
+    return LONG2NUM(s.size());
+  }
+
+  static VALUE empty(VALUE self) {
+    SparsehashSet<T> *p;
+
+    Data_Get_Struct(self, SparsehashSet<T>, p);
+    T &s = *(p->s);
+
+    return s.empty() ? Qtrue : Qfalse;
+  }
+
+  static VALUE clear(VALUE self) {
+    SparsehashSet<T> *p;
+
+    Data_Get_Struct(self, SparsehashSet<T>, p);
+    T &s = *(p->s);
+    s.clear();
+
+    return self;
+  }
+
+  static void init(VALUE &module, const char *name) {
+    VALUE rb_cSet = rb_define_class_under(module, name, rb_cObject);
+
+    rb_define_alloc_func(rb_cSet, &alloc);
+    rb_include_module(rb_cSet, rb_mEnumerable);
+    rb_define_private_method(rb_cSet, "initialize", __F(&initialize), 0);
+    rb_define_method(rb_cSet, "insert", __F(&insert), 1);
+    rb_define_method(rb_cSet, "<<", __F(&insert), 1);
+    rb_define_method(rb_cSet, "each", __F(&each), 0);
+    rb_define_method(rb_cSet, "erase", __F(&erase), 1);
+    rb_define_method(rb_cSet, "delete", __F(&erase), 1);
+    rb_define_method(rb_cSet, "size", __F(&size), 0);
+    rb_define_method(rb_cSet, "length", __F(&size), 0);
+    rb_define_method(rb_cSet, "empty?", __F(&empty), 0);
+    rb_define_method(rb_cSet, "clear", __F(&clear), 0);
+  }
+};
+
+} // namespace
+
+void Init_sparsehash() {
+  VALUE rb_mSparsehash = rb_define_module("Sparsehash");
+  SparsehashMap<SHMap>::init(rb_mSparsehash, "SparseHashMap");
+  SparsehashMap<DHMap>::init(rb_mSparsehash, "DenseHashMap");
+  SparsehashSet<SHSet>::init(rb_mSparsehash, "SparseHashSet");
+  SparsehashSet<DHSet>::init(rb_mSparsehash, "DenseHashSet");
+
+  VALUE rb_mSTL = rb_define_module("STL");
+  SparsehashMap<STLMap>::init(rb_mSTL, "Map");
+  SparsehashSet<STLSet>::init(rb_mSTL, "Set");
+
+#ifdef __GNUC__
+  VALUE rb_mGNU = rb_define_module("GNU");
+  SparsehashMap<GNUHashMap>::init(rb_mGNU, "HashMap");
+  SparsehashSet<GNUHashSet>::init(rb_mGNU, "HashSet");
+#endif
+}

data/ext/sparsehash_internal.h

@@ -0,0 +1,26 @@
+#ifndef __SPARSEHASH_INTERNAL_H__
+#define __SPARSEHASH_INTERNAL_H__
+
+#include "ruby.h"
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#ifdef _WIN32
+#define __F(f) (reinterpret_cast<VALUE (__cdecl *)(...)>(f))
+#else
+#define __F(f) (reinterpret_cast<VALUE (*)(...)>(f))
+#endif
+
+extern "C" {
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+void Init_sparsehash();
+}
+
+#endif // __SPARSEHASH_INTERNAL_H__

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: sparsehash
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- winebarrel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-20 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: 
+email: sgwr_dts@yahoo.co.jp
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README
+- etc/anymap.rb
+- etc/anyset.rb
+files: 
+- ext/extconf.rb
+- ext/sparsehash.cpp
+- ext/sparsehash_internal.h
+- README
+- etc/anymap.rb
+- etc/anyset.rb
+has_rdoc: true
+homepage: http://sparsehash.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --title
+- sparsehash - Ruby bindings for Google Sparse Hash.
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: sparsehash
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Ruby bindings for Google Sparse Hash.
+test_files: []
+