native_btree 0.1.0.alpha1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4350c3868f788f61a124316be8b5585fdaeff625d68146132400dc35d8c11c65
+  data.tar.gz: 6d8d0ab48fd80fe1495fc467e94aab3697f3a6f268b3922c192de766d5ce97ca
+SHA512:
+  metadata.gz: e75a27871d722cd11d5453d980ef55698cc9de9c25fc1dd825a0e824189171f6ebb827def85616659ff778ad30739df84579bc02b9639f2c64cd1803ee301d57
+  data.tar.gz: cfab277fb1f5c2265a94f588aaf27a1002c210fb1c70aea5d6311e1b5f39de9f356e5b0b89c9ff0f5ab8441ca9731576b824bfe975a719b0ef60403ece9f2545

data/ext/native_btree/btree.cc

@@ -0,0 +1,128 @@
+#include "btree.h"
+
+BTree::BTree(VALUE comnparator)
+{
+  this->comparator = comnparator;
+  this->tree = g_tree_new_with_data(BTree::nativeComparator, this);
+}
+
+BTree::~BTree()
+{
+  g_tree_destroy(this->tree);
+}
+
+void
+BTree::mark()
+{
+  rb_gc_mark(this->comparator);
+  this->markMyRValues();
+}
+
+void
+BTree::markMyRValues()
+{
+  g_tree_foreach(this->tree, BTree::markRValue, NULL);
+}
+
+gint
+BTree::markRValue(gpointer k, gpointer v, gpointer not_used)
+{
+  const VALUE key = reinterpret_cast<VALUE>(k);
+  const VALUE value = reinterpret_cast<VALUE>(v);
+
+  rb_gc_mark(key);
+  rb_gc_mark(value);
+
+  return false;
+}
+
+gint
+BTree::nativeComparator(gconstpointer a, gconstpointer b, gpointer data)
+{
+  const BTree *tree = static_cast<BTree *>(data);
+  const VALUE keyA = reinterpret_cast<VALUE>(a);
+  const VALUE keyB = reinterpret_cast<VALUE>(b);
+
+  VALUE ruby_result = rb_funcall(tree->comparator, rb_intern("call"), 2, keyA, keyB);
+
+  return NUM2INT(ruby_result);
+}
+
+gint
+BTree::size()
+{
+  return g_tree_nnodes(this->tree);
+}
+
+gint
+BTree::height()
+{
+  return g_tree_height(this->tree);
+}
+
+void
+BTree::set(VALUE key, VALUE value)
+{
+  g_tree_replace(this->tree, (gpointer) key, (gpointer) value);
+}
+
+VALUE
+BTree::get(VALUE key)
+{
+  gpointer result = g_tree_lookup(this->tree, reinterpret_cast<gconstpointer>(key));
+
+  if (!result) {
+    return Qnil;
+  }
+
+  return reinterpret_cast<VALUE>(result);
+}
+
+bool
+BTree::del(VALUE key)
+{
+  return g_tree_remove(this->tree, reinterpret_cast<gconstpointer>(key));
+}
+
+void
+BTree::clear()
+{
+  g_tree_unref(this->tree);
+  this->tree = g_tree_new_with_data(BTree::nativeComparator, this);
+}
+
+bool
+BTree::has(VALUE key)
+{
+  bool result = g_tree_lookup(this->tree, reinterpret_cast<gconstpointer>(key));
+
+  if (!result) {
+    return true;
+  }
+
+  return false;
+}
+
+gboolean
+BTree::traverseFunc(gpointer k, gpointer v, gpointer b)
+{
+  const VALUE key = reinterpret_cast<VALUE>(k);
+  const VALUE value = reinterpret_cast<VALUE>(v);
+  const VALUE block = reinterpret_cast<VALUE>(b);
+
+  rb_funcall(block, rb_intern("call"), 2, key, value);
+
+  return FALSE;
+}
+
+void
+BTree::each(VALUE block)
+{
+  g_tree_foreach(this->tree, BTree::traverseFunc, reinterpret_cast<gpointer>(block));
+}
+
+void
+BTree::each(GTraverseFunc func, gpointer data)
+{
+  g_tree_foreach(this->tree, func, data);
+}

data/ext/native_btree/extconf.h

@@ -0,0 +1,11 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#define HAVE_G_TREE_INSERT 1
+#define HAVE_G_TREE_REPLACE 1
+#define HAVE_G_TREE_NNODES 1
+#define HAVE_G_TREE_LOOKUP 1
+#define HAVE_G_TREE_FOREACH 1
+#define HAVE_G_TREE_SEARCH 1
+#define HAVE_G_TREE_DESTROY 1
+#define HAVE_G_TREE_HEIGHT 1
+#endif

data/ext/native_btree/extconf.rb

@@ -0,0 +1,35 @@
+require "mkmf"
+
+local_include = %w(
+  $(srcdir)/include
+);
+
+ldflags = cppflags = nil
+
+pkg_config "glib-2.0"
+dir_config 'glib', cppflags, ldflags
+
+abort "Can't find the glib.h header"  unless find_header 'glib.h'
+abort "Can't find the glib libary'"   unless find_library 'glib-2.0', 'g_tree_new_full'
+abort "g_tree_insert() not found"     unless have_func 'g_tree_insert'
+abort "g_tree_replace() not found"    unless have_func 'g_tree_replace'
+abort "g_tree_nnodes() not found"     unless have_func 'g_tree_nnodes'
+abort "g_tree_lookup() not found"     unless have_func 'g_tree_lookup'
+abort "g_tree_foreach() not found"    unless have_func 'g_tree_foreach'
+abort "g_tree_search() not found"     unless have_func 'g_tree_search'
+abort "g_tree_destroy() not found"    unless have_func 'g_tree_destroy'
+abort "g_tree_height() not found"     unless have_func 'g_tree_height'
+
+$DEBUG = true
+
+$VPATH.concat %w(
+  $(srcdir)/include
+)
+
+$INCFLAGS << local_include.map{|dir| " -I#{dir}" }.join("")
+CONFIG["debugflags"] = "-ggdb3"
+CONFIG["optflags"] = "-O0"
+$CXXFLAGS = "-O0 -ggdb3 -pipe"
+
+create_header
+create_makefile "native_btree/native_btree"

data/ext/native_btree/include/btree.h

@@ -0,0 +1,63 @@
+#include <string>
+#include <ruby.h>
+#include <glib.h>
+
+using namespace std;
+
+class BTree {
+  public:
+    BTree(VALUE comparator);
+    ~BTree();
+
+    // get
+    VALUE const &operator[](VALUE key) const;
+    // set
+    void operator[](VALUE key);
+
+    gint
+    height();
+
+    gint
+    size();
+
+    bool
+    del(VALUE key);
+
+    void
+    clear();
+
+    bool
+    has(VALUE key);
+
+    void
+    mark();
+
+    void
+    set(VALUE key, VALUE value);
+
+    VALUE
+    get(VALUE key);
+
+    void
+    each(VALUE block);
+
+    void
+    each(GTraverseFunc func, gpointer data);
+
+  private:
+    GTree *tree;
+    VALUE comparator;
+
+    void
+    markMyRValues();
+
+    static gint
+    nativeComparator(gconstpointer keyA, gconstpointer keyB, gpointer tree);
+
+    static gint
+    markRValue(gpointer key, gpointer value, gpointer not_used);
+
+    static gboolean
+    traverseFunc(gpointer k, gpointer v, gpointer data);
+};
+

data/ext/native_btree/include/native_btree.h

@@ -0,0 +1,51 @@
+#ifndef _NATIVE_BTREE_
+#include <ruby.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+extern VALUE btree_class;
+extern VALUE btree_module;
+
+VALUE
+btree_new(VALUE klass);
+
+VALUE
+btree_init(VALUE self);
+
+VALUE
+btree_size(VALUE self);
+
+VALUE
+btree_height(VALUE self);
+
+VALUE
+btree_set(VALUE self, VALUE key, VALUE value);
+
+VALUE
+btree_get(VALUE self, VALUE key);
+
+VALUE
+btree_delete(VALUE self, VALUE key);
+
+VALUE
+btree_clear(VALUE self);
+
+VALUE
+btree_has(VALUE self, VALUE key);
+
+VALUE
+btree_each(VALUE self);
+
+VALUE
+btree_cmp(VALUE self, VALUE tree2);
+
+VALUE
+btree_equal(VALUE self, VALUE tree2);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // _NATIVE_BTREE_

data/ext/native_btree/native_btree.c

@@ -0,0 +1,30 @@
+#include <native_btree.h>
+
+VALUE btree_class;
+VALUE btree_module;
+
+void
+Init_native_btree()
+{
+  btree_module = rb_define_module("NativeBTree");
+  btree_class = rb_define_class_under(btree_module, "BTree", rb_cObject);
+
+  rb_define_singleton_method(btree_class, "new", btree_new, 0);
+  // rb_define_method(btree_class, "initialize", btree_init, 0);
+  rb_define_method(btree_class, "size", btree_size, 0);
+  rb_define_method(btree_class, "height", btree_height, 0);
+  rb_define_method(btree_class, "set", btree_set, 2);
+  rb_define_alias(btree_class, "[]=", "set");
+  rb_define_method(btree_class, "get", btree_get, 1);
+  rb_define_alias(btree_class, "[]", "get");
+  rb_define_method(btree_class, "delete", btree_delete, 1);
+  rb_define_method(btree_class, "clear", btree_clear, 0);
+  rb_define_method(btree_class, "has", btree_has, 1);
+  rb_define_method(btree_class, "each", btree_each, 0);
+  rb_define_method(btree_class, "<=>", btree_cmp, 1);
+  rb_define_method(btree_class, "eql?", btree_equal, 1);
+  rb_define_alias(btree_class, "==", "eql?");
+  // TODO: to_ary
+  // TODO: to_hash
+}
+

data/ext/native_btree/rb_methods.cc

@@ -0,0 +1,221 @@
+#include <ruby.h>
+#include <glib.h>
+
+#include "native_btree.h"
+#include "btree.h"
+
+
+extern "C" {
+
+class BTreeEQCtxt {
+  public:
+    VALUE eq = Qtrue;
+    BTree *tree2 = nullptr;
+};
+
+static void
+btree_free(BTree *btree)
+{
+  delete btree;
+}
+
+static void
+btree_mark(gpointer obj)
+{
+  reinterpret_cast<BTree *>(obj)->mark();
+}
+
+static VALUE
+btree_enum_size(VALUE tree, VALUE args, VALUE eobj)
+{
+  return btree_size(tree);
+}
+
+
+VALUE
+btree_new(VALUE klass)
+{
+  rb_need_block();
+
+  VALUE comparator = rb_block_lambda();
+
+  BTree *tree = new BTree(comparator);
+
+  VALUE instance = Data_Wrap_Struct(klass, btree_mark, btree_free, tree);
+
+  return instance;
+}
+
+VALUE
+btree_init(VALUE self)
+{
+  return self;
+}
+
+VALUE
+btree_size(VALUE self)
+{
+  BTree *tree;
+  Data_Get_Struct(self, BTree, tree);
+
+  VALUE result = INT2NUM(tree->size());
+
+  return result;
+}
+
+VALUE
+btree_height(VALUE self)
+{
+  BTree *tree;
+  Data_Get_Struct(self, BTree, tree);
+
+  VALUE result = INT2NUM(tree->height());
+
+  return result;
+}
+
+
+VALUE
+btree_set(VALUE self, VALUE key, VALUE value)
+{
+  BTree *tree;
+  Data_Get_Struct(self, BTree, tree);
+
+  tree->set(key, value);
+
+  return Qnil;
+}
+
+VALUE
+btree_get(VALUE self, VALUE key)
+{
+  BTree *tree;
+  Data_Get_Struct(self, BTree, tree);
+
+  return tree->get(key);
+}
+
+VALUE
+btree_delete(VALUE self, VALUE key)
+{
+  BTree *tree;
+  Data_Get_Struct(self, BTree, tree);
+
+  bool result = tree->del(key);
+
+  return result ? Qtrue : Qfalse;
+}
+
+VALUE
+btree_clear(VALUE self)
+{
+  BTree *tree;
+  Data_Get_Struct(self, BTree, tree);
+
+  tree->clear();
+
+  return Qnil;
+}
+
+VALUE
+btree_has(VALUE self, VALUE key)
+{
+  BTree *tree;
+  Data_Get_Struct(self, BTree, tree);
+
+  bool result = tree->has(key);
+
+  return result ? Qtrue : Qfalse;
+}
+
+VALUE
+btree_each(VALUE self)
+{
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, btree_enum_size);
+
+  VALUE block = rb_block_lambda();
+
+  BTree *tree;
+  Data_Get_Struct(self, BTree, tree);
+
+  tree->each(block);
+
+  return Qnil;
+}
+
+// TODO: Need implementation
+VALUE
+btree_cmp(VALUE self, VALUE tree2)
+{
+  return Qnil;
+}
+
+static gboolean
+eql_comparator(gpointer k, gpointer v, gpointer data)
+{
+  VALUE key = reinterpret_cast<VALUE>(k);
+  VALUE val = reinterpret_cast<VALUE>(v);
+  BTreeEQCtxt *context = reinterpret_cast<BTreeEQCtxt *>(data);
+
+  VALUE val2 = context->tree2->get(key);
+
+  // key not found
+  if (NIL_P(val2)) {
+    context->eq = Qfalse;
+
+    return TRUE;
+  }
+
+  // values !eql
+  if (!rb_eql(val, val2)) {
+    context->eq = Qfalse;
+
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+static VALUE//      obj         arg        recur
+recursive_eql(VALUE tree, VALUE tree2, int recur)
+{
+  if (recur)
+    return Qtrue; /* Subtle! */
+
+  BTree *t, *t2;
+  Data_Get_Struct(tree, BTree, t);
+  Data_Get_Struct(tree2, BTree, t2);
+
+  BTreeEQCtxt context;
+  // context.eq == Qtrue;
+
+  context.tree2 = t2;
+
+  t->each(eql_comparator, reinterpret_cast<gpointer>(&context));
+
+  return context.eq;
+}
+
+VALUE
+btree_equal(VALUE self, VALUE tree2)
+{
+  BTree *t, *t2;
+  Data_Get_Struct(self, BTree, t);
+  Data_Get_Struct(tree2, BTree, t2);
+
+  if (self == tree2)
+    return Qtrue;
+
+  if (CLASS_OF(tree2) != btree_class)
+    return Qfalse;
+
+  if (t->size() != t2->size() || t->height() != t2->height())
+    return Qfalse;
+
+  if (t->size() == 0)
+    return Qtrue;
+  //                              func           obj   paired arg
+  return rb_exec_recursive_paired(recursive_eql, self, tree2, tree2);
+}
+
+}

data/lib/native_btree.rb

@@ -0,0 +1,5 @@
+module NativeBTree
+end
+
+require "native_btree/version"
+require "native_btree/native_btree"

data/lib/native_btree/version.rb

@@ -0,0 +1,3 @@
+module NativeBTree
+  VERSION = "0.1.0.alpha1".freeze
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: native_btree
+version: !ruby/object:Gem::Version
+  version: 0.1.0.alpha1
+platform: ruby
+authors:
+- Alexander Feodorov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-07-11 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- webmaster@unixcomp.org
+executables: []
+extensions:
+- ext/native_btree/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/native_btree/btree.cc
+- ext/native_btree/extconf.h
+- ext/native_btree/extconf.rb
+- ext/native_btree/include/btree.h
+- ext/native_btree/include/native_btree.h
+- ext/native_btree/native_btree.c
+- ext/native_btree/rb_methods.cc
+- lib/native_btree.rb
+- lib/native_btree/version.rb
+homepage: https://github.com/unixs/ruby-native-btree
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Bindings to GTree data stucture from libglib-2.0
+test_files: []