rb_lovely 0.3.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6257def0a1d18050a37cfe61c6b6a07ebcc557b4
+  data.tar.gz: 8500185c4d547bf45bd83ba3ecdc48dddae95ebb
+SHA512:
+  metadata.gz: 8618d167887a777da7b37f2389555678528f3b5b919b44a39dec8686b0aa66805b3e9885c92f3f7cd3af075252125fd6f620d7777d3a4dae73ebf11d9ab5384e
+  data.tar.gz: 411c88e8103e448542c8d39c8d5dbbcd9c5753529b21d2d021321bf4e8724da60276e9a9c53fa8b0be219285800d0455c111035b33960794fbe7d159083837a4

data/ext/rb_lovely/container.hpp

@@ -0,0 +1,22 @@
+#ifndef RB_LOVELY_SETS_SET_HPP
+#define RB_LOVELY_SETS_SET_HPP
+
+#include "ruby_util.hpp"
+
+namespace rb_lovely {
+
+template <class T>
+VALUE containerLength(VALUE self) {
+  T* set = rubyCast<T>(self);
+  return INT2NUM(set->size());
+}
+
+template <class T>
+static void initSet(VALUE rbSet) {
+  rb_define_method(rbSet, "length", RUBY_METHOD_FUNC(containerLength<T>), 0);
+}
+
+auto toS = [](VALUE val) { return RSTRING_PTR(rb_funcall(val, to_sSym, 0)); };
+
+}
+#endif

data/ext/rb_lovely/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+$CPPFLAGS += ' -std=c++0x'
+with_cflags('-x c++') do
+  # needed for SortedHash, optional
+  have_header('boost/multi_index_container.hpp')
+end
+create_makefile('rb_lovely')

data/ext/rb_lovely/package.cpp

@@ -0,0 +1,34 @@
+#include "ruby_util.hpp"
+
+namespace rb_lovely {
+  // extern stuff from ruby_util
+  VALUE rbMod;
+  VALUE cmpMethSym;
+  VALUE equalitySym;
+  VALUE to_sSym;
+  VALUE hashSym;
+}
+
+extern "C" {
+  using namespace rb_lovely;
+
+  extern void Init_rb_lovely_sorted_set();
+#ifdef HAVE_BOOST_MULTI_INDEX_CONTAINER_HPP
+  extern void Init_rb_lovely_hybrid_set();
+#endif
+
+  void Init_rb_lovely() {
+    ruby_init();
+    ruby_init_loadpath();
+
+    initRubyUtil();
+
+    Init_rb_lovely_sorted_set();
+#ifdef HAVE_BOOST_MULTI_INDEX_CONTAINER_HPP
+    Init_rb_lovely_hybrid_set();
+#endif
+
+    // i saw this somewhere... but it dumps core... so um...
+    // ruby_finalize();
+  }
+}

data/ext/rb_lovely/ruby_util.hpp

@@ -0,0 +1,39 @@
+#ifndef RB_LOVELY_SETS_UTIL_HPP
+#define RB_LOVELY_SETS_UTIL_HPP
+#include "ruby.h"
+
+namespace rb_lovely {
+
+extern VALUE rbMod;
+extern VALUE cmpMethSym;
+extern VALUE equalitySym;
+extern VALUE to_sSym;
+extern VALUE hashSym;
+
+template <class T>
+void rubyDelete(T *obj) {
+  delete obj;
+}
+
+template <class T>
+T *rubyCast(VALUE rbObj) {
+  T *obj;
+  Data_Get_Struct(rbObj, T, obj);
+  return obj;
+}
+
+template <class T>
+VALUE rubyAlloc(VALUE klass) {
+  return Data_Wrap_Struct(klass, 0, rubyDelete<T>, new T);
+}
+
+static void initRubyUtil() {
+  rbMod = rb_define_module("RbLovely");
+  cmpMethSym = rb_intern("<=>");
+  equalitySym = rb_intern("==");
+  to_sSym = rb_intern("to_s");
+  hashSym = rb_intern("hash");
+}
+
+}
+#endif

data/ext/rb_lovely/sorted_hash.cpp

@@ -0,0 +1,212 @@
+#ifdef HAVE_BOOST_MULTI_INDEX_CONTAINER_HPP
+#include "container.hpp"
+
+#include "ruby_util.hpp"
+
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/member.hpp>
+
+namespace rb_lovely { namespace hybrid {
+
+struct member {
+  bool operator<(member const& rhs) const {
+    auto cmpVal = rb_funcall(val, cmpMethSym, 1, rhs.val);
+    return NUM2INT(cmpVal) < 0;
+  }
+
+  bool operator==(member const& rhs) const {
+    auto equalityVal = rb_funcall(key, equalitySym, 1, rhs.key);
+    return RTEST(equalityVal);
+  }
+
+  // also cache as two element array?
+  member(VALUE _key, VALUE _val) : key(_key), val(_val) {}
+
+  VALUE key;
+  VALUE val;
+};
+
+std::size_t hash_value(member const& member) {
+  // TODO: something better?
+  return reinterpret_cast<std::size_t>(&member);
+  // return NUM2INT(rb_funcall(member.val, hashSym, 0));
+}
+
+namespace mi = boost::multi_index;
+
+typedef boost::multi_index_container<
+  member,
+  mi::indexed_by<
+    mi::hashed_unique< mi::member<member, VALUE, &member::key> >,
+    mi::ordered_non_unique< mi::identity<member> >
+  >
+> Hash;
+
+VALUE hashInitialize(int argc, VALUE *argv, VALUE self) {
+  if (argc == 1) {
+    auto array = rb_check_array_type(argv[0]);
+    if (array == Qnil) {
+      rb_raise(rb_eArgError, "Expected array");
+    }
+    else {
+      auto len = RARRAY_LEN(array);
+      if (len % 2 != 0) {
+        rb_raise(rb_eArgError, "Expected even number of parameters");
+      }
+      else {
+        Hash* hash = rubyCast<Hash>(self);
+        for (auto i = 0; i < len; i += 2) {
+          hash->insert(member(rb_ary_entry(array, i), rb_ary_entry(array, i + 1)));
+        }
+      }
+    }
+  }
+  return self;
+}
+
+VALUE hashUpdate(VALUE self, VALUE key, VALUE val) {
+  Hash* hash = rubyCast<Hash>(self);
+  // TODO: overwrite value
+  auto it = hash->find(key);
+  if (it != hash->end())
+    hash->replace(it, member(key, val));
+  else
+    hash->insert(member(key, val));
+  return self;
+}
+
+VALUE hashGet(VALUE self, VALUE key) {
+  Hash* hash = rubyCast<Hash>(self);
+  auto it = hash->find(key);
+  if (it == hash->end()) {
+    return Qnil;
+  }
+  else {
+    return it->val;
+  }
+}
+
+VALUE hashEach(VALUE self) {
+  if (! rb_block_given_p()) {
+    // TODO: return Enumerator
+    rb_raise(rb_eArgError, "Expected block");
+  }
+  else {
+    Hash* hash = rubyCast<Hash>(self);
+    for (auto const& member : hash->get<1>()) {
+      rb_yield_values(2, member.key, member.val);
+    }
+  }
+
+  return Qnil;
+}
+
+VALUE hashToString(VALUE self) {
+  std::stringstream str;
+  str << "RbLovely::SortedHash {";
+  Hash* hash = rubyCast<Hash>(self);
+  if (! hash->empty()) {
+    auto& idx = hash->get<1>();
+    auto it = idx.begin();
+    str << ' ' << toS(it->key) << " => " << toS(it->val);
+    for (++it; it != idx.end(); ++it) {
+      str << ", " << toS(it->key) << " => " << toS(it->val);
+    }
+  }
+  str << " }";
+
+  auto stlString = str.str();
+  return rb_str_new(stlString.data(), stlString.size());
+}
+
+VALUE hashFirst(VALUE self) {
+  Hash* hash = rubyCast<Hash>(self);
+  return hash->empty() ? Qnil : hash->get<1>().begin()->val;
+}
+
+VALUE hashLast(VALUE self) {
+  Hash* hash = rubyCast<Hash>(self);
+  if (hash->empty())
+    return Qnil;
+
+  auto last = hash->get<1>().end();
+  --last;
+  return last->val;
+}
+
+VALUE hashMutatingDelete(VALUE self, VALUE toDelete) {
+  Hash* hash = rubyCast<Hash>(self);
+  auto it = hash->find(toDelete);
+  if (it == hash->end()) {
+    return Qnil;
+  }
+  else {
+    auto valBackup = it->val;
+    hash->erase(it);
+    return valBackup;
+  }
+}
+
+VALUE hashShift(VALUE self) {
+  Hash* hash = rubyCast<Hash>(self);
+  if (hash->empty())
+   return Qnil;
+
+  auto& idx = hash->get<1>();
+  auto bak = idx.begin()->val;
+  idx.erase(idx.begin());
+  return bak;
+}
+
+VALUE hashPop(VALUE self) {
+  Hash* hash = rubyCast<Hash>(self);
+  if (hash->empty())
+    return Qnil;
+
+  auto& idx = hash->get<1>();
+  auto last = idx.end();
+  --last;
+  auto bak = last->val;
+  idx.erase(last);
+  return bak;
+}
+
+VALUE hashHas(VALUE self, VALUE key) {
+  Hash* hash = rubyCast<Hash>(self);
+  auto it = hash->find(key);
+  return it == hash->end() ? Qfalse : Qtrue;
+}
+
+} }
+
+extern "C" {
+  using namespace rb_lovely;
+  using namespace rb_lovely::hybrid;
+
+  void Init_rb_lovely_hybrid_set() {
+    auto rbHash = rb_define_class_under(rbMod, "SortedHash", rb_cObject);
+    rb_define_alloc_func(rbHash, rubyAlloc<Hash>);
+    rb_include_module(rbHash, rb_const_get(rb_cObject, rb_intern("Enumerable")));
+
+    rb_define_method(rbHash, "initialize", RUBY_METHOD_FUNC(hashInitialize), -1);
+    initSet<Hash>(rbHash);
+    rb_define_method(rbHash, "[]=", RUBY_METHOD_FUNC(hashUpdate), 2);
+    rb_define_method(rbHash, "[]", RUBY_METHOD_FUNC(hashGet), 1);
+    rb_define_method(rbHash, "each", RUBY_METHOD_FUNC(hashEach), 0);
+    rb_define_method(rbHash, "to_s", RUBY_METHOD_FUNC(hashToString), 0);
+    rb_define_method(rbHash, "first", RUBY_METHOD_FUNC(hashFirst), 0);
+    rb_define_method(rbHash, "last", RUBY_METHOD_FUNC(hashLast), 0);
+    rb_define_method(rbHash, "delete", RUBY_METHOD_FUNC(hashMutatingDelete), 1);
+    // rb_define_method(rbHash, "reject!", RUBY_METHOD_FUNC(hashMutatingReject), 0);
+    // rb_define_method(rbHash, "reject_first!", RUBY_METHOD_FUNC(hashMutatingRejectFirst), 0);
+    // rb_define_method(rbHash, "select!", RUBY_METHOD_FUNC(hashMutatingSelect), 0);
+    rb_define_method(rbHash, "shift", RUBY_METHOD_FUNC(hashShift), 0);
+    rb_define_method(rbHash, "pop", RUBY_METHOD_FUNC(hashPop), 0);
+    // Enumerable would test both key and value for include?
+    rb_define_method(rbHash, "include?", RUBY_METHOD_FUNC(hashHas), 1);
+    rb_define_method(rbHash, "has_key?", RUBY_METHOD_FUNC(hashHas), 1);
+  }
+}
+#endif

data/ext/rb_lovely/sorted_set.cpp

@@ -0,0 +1,214 @@
+#include "container.hpp"
+
+#include "ruby_util.hpp"
+
+#include <set>
+#include <sstream>
+
+namespace rb_lovely { namespace ordered {
+
+struct Compare {
+  bool operator()(VALUE const& lhs, VALUE const& rhs);
+};
+
+typedef std::set<VALUE, Compare> Set;
+
+bool Compare::operator()(VALUE const& lhs, VALUE const& rhs) {
+  auto cmpVal = rb_funcall(lhs, cmpMethSym, 1, rhs);
+  return NUM2INT(cmpVal) < 0;
+}
+
+VALUE setInitialize(int argc, VALUE *argv, VALUE self) {
+  if (argc == 1) {
+    auto array = rb_check_array_type(argv[0]);
+    if (array == Qnil) {
+      rb_raise(rb_eArgError, "Expected array");
+    }
+    else {
+      Set* set = rubyCast<Set>(self);
+      auto len = RARRAY_LEN(array);
+      for (auto i = 0; i < len; ++i) {
+        set->insert(rb_ary_entry(array, i));
+      }
+    }
+  }
+  return self;
+}
+
+VALUE setAdd(VALUE self, VALUE val) {
+  Set* set = rubyCast<Set>(self);
+  set->insert(val);
+  return self;
+}
+
+VALUE setEach(VALUE self) {
+  if (! rb_block_given_p()) {
+    // TODO: return Enumerator
+    rb_raise(rb_eArgError, "Expected block");
+  }
+  else {
+    Set* set = rubyCast<Set>(self);
+    for (auto const& val : *set) {
+      rb_yield(val);
+    }
+  }
+
+  return Qnil;
+}
+
+VALUE setToString(VALUE self) {
+  std::stringstream str;
+  str << "RbLovely::SortedSet {";
+  Set* set = rubyCast<Set>(self);
+  if (! set->empty()) {
+    auto it = set->begin();
+    str << ' ' << toS(*it);
+    for (++it; it != set->end(); ++it) {
+      str << ", " << toS(*it);
+    }
+  }
+  str << " }";
+
+  auto stlString = str.str();
+  return rb_str_new(stlString.data(), stlString.size());
+}
+
+VALUE setFirst(VALUE self) {
+  Set* set = rubyCast<Set>(self);
+
+  return set->empty() ? Qnil : *set->begin();
+}
+
+VALUE setLast(VALUE self) {
+  Set* set = rubyCast<Set>(self);
+  if (set->empty())
+    return Qnil;
+
+  auto last = set->end();
+  --last;
+  return *last;
+}
+
+VALUE setMutatingDelete(VALUE self, VALUE toDelete) {
+  Set* set = rubyCast<Set>(self);
+  auto it = set->find(toDelete);
+  if (it == set->end()) {
+    return Qnil;
+  }
+  else {
+    auto valBackup = *it;
+    set->erase(it);
+    return valBackup;
+  }
+}
+
+VALUE setMutatingReject(VALUE self) {
+  if (! rb_block_given_p()) {
+    rb_raise(rb_eArgError, "Expected block");
+  }
+  else {
+    Set* set = rubyCast<Set>(self);
+    for (auto it = set->begin(); it != set->end();) {
+      auto predicateRetVal = rb_yield(*it);
+      if (RTEST(predicateRetVal))
+        it = set->erase(it);
+      else
+        ++it;
+    }
+  }
+  return self;
+}
+
+VALUE setMutatingRejectFirst(VALUE self) {
+  if (! rb_block_given_p()) {
+    rb_raise(rb_eArgError, "Expected block");
+  }
+  else {
+    Set* set = rubyCast<Set>(self);
+    for (auto it = set->begin(); it != set->end(); ++it) {
+      auto predicateRetVal = rb_yield(*it);
+      if (RTEST(predicateRetVal)) {
+        auto valBackup = *it;
+        set->erase(it);
+        return valBackup;
+      }
+    }
+  }
+  return Qnil;
+}
+
+VALUE setMutatingSelect(VALUE self) {
+  if (! rb_block_given_p()) {
+    rb_raise(rb_eArgError, "Expected block");
+    return self;
+  }
+  else {
+    Set* set = rubyCast<Set>(self);
+    for (auto it = set->begin(); it != set->end();) {
+      auto predicateRetVal = rb_yield(*it);
+      if (! RTEST(predicateRetVal))
+        it = set->erase(it);
+      else
+        ++it;
+    }
+  }
+  return self;
+}
+
+VALUE setShift(VALUE self) {
+  Set* set = rubyCast<Set>(self);
+  if (set->empty())
+   return Qnil;
+
+  auto bak = *set->begin();
+  set->erase(set->begin());
+  return bak;
+}
+
+VALUE setPop(VALUE self) {
+  Set* set = rubyCast<Set>(self);
+  if (set->empty())
+    return Qnil;
+
+  auto last = set->end();
+  --last;
+  auto bak = *last;
+  set->erase(last);
+  return bak;
+}
+
+VALUE setHas(VALUE self, VALUE val) {
+  Set* set = rubyCast<Set>(self);
+  auto it = set->find(val);
+  return it == set->end() ? Qfalse : Qtrue;
+}
+
+} } // end namespace
+
+extern "C" {
+  using namespace rb_lovely;
+  using namespace rb_lovely::ordered;
+
+  void Init_rb_lovely_sorted_set() {
+    auto rbSet = rb_define_class_under(rbMod, "SortedSet", rb_cObject);
+    rb_define_alloc_func(rbSet, rubyAlloc<Set>);
+    rb_include_module(rbSet, rb_const_get(rb_cObject, rb_intern("Enumerable")));
+
+    rb_define_method(rbSet, "initialize", RUBY_METHOD_FUNC(setInitialize), -1);
+    initSet<Set>(rbSet);
+    rb_define_method(rbSet, "add", RUBY_METHOD_FUNC(setAdd), 1);
+    rb_define_method(rbSet, "<<", RUBY_METHOD_FUNC(setAdd), 1);
+    rb_define_method(rbSet, "each", RUBY_METHOD_FUNC(setEach), 0);
+    rb_define_method(rbSet, "to_s", RUBY_METHOD_FUNC(setToString), 0);
+    rb_define_method(rbSet, "first", RUBY_METHOD_FUNC(setFirst), 0);
+    rb_define_method(rbSet, "last", RUBY_METHOD_FUNC(setLast), 0);
+    rb_define_method(rbSet, "delete", RUBY_METHOD_FUNC(setMutatingDelete), 1);
+    rb_define_method(rbSet, "reject!", RUBY_METHOD_FUNC(setMutatingReject), 0);
+    rb_define_method(rbSet, "reject_first!", RUBY_METHOD_FUNC(setMutatingRejectFirst), 0);
+    rb_define_method(rbSet, "select!", RUBY_METHOD_FUNC(setMutatingSelect), 0);
+    rb_define_method(rbSet, "shift", RUBY_METHOD_FUNC(setShift), 0);
+    rb_define_method(rbSet, "pop", RUBY_METHOD_FUNC(setPop), 0);
+    // Enumerable provides a slower version of this
+    rb_define_method(rbSet, "include?", RUBY_METHOD_FUNC(setHas), 1);
+  }
+}

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: rb_lovely
+version: !ruby/object:Gem::Version
+  version: 0.3.3
+platform: ruby
+authors:
+- James Pike
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-01 00:00:00.000000000 Z
+dependencies: []
+description: A fast sorted set built using std::set and a fast sorted hash built using
+  boost::multi_index_container.
+email:
+- gems@chilon.net
+executables: []
+extensions:
+- ext/rb_lovely/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/rb_lovely/container.hpp
+- ext/rb_lovely/extconf.rb
+- ext/rb_lovely/package.cpp
+- ext/rb_lovely/ruby_util.hpp
+- ext/rb_lovely/sorted_hash.cpp
+- ext/rb_lovely/sorted_set.cpp
+homepage: https://github.com/nuisanceofcats/rb_lovely
+licenses:
+- Expat
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Fast sorted sets and hashes.
+test_files: []