native_btree 0.2.1 → 0.4.0

data/ext/native_btree/iterators.c

@@ -1,4 +1,5 @@
-#include <iterators.h>
+#include <common.h>
+
 
 static gboolean
 foraech_callbac(gpointer a, gpointer b, gpointer data)
@@ -12,6 +13,31 @@ foraech_callbac(gpointer a, gpointer b, gpointer data)
   return FALSE;
 }
 
+
+static gboolean
+foraech_key_callbac(gpointer a, gpointer b, gpointer data)
+{
+  VALUE key = (VALUE) a;
+  VALUE block = (VALUE) data;
+
+  rb_funcall(block, rb_intern("call"), 1, key);
+
+  return FALSE;
+}
+
+
+static gboolean
+foraech_value_callbac(gpointer a, gpointer b, gpointer data)
+{
+  VALUE value = (VALUE) b;
+  VALUE block = (VALUE) data;
+
+  rb_funcall(block, rb_intern("call"), 1, value);
+
+  return FALSE;
+}
+
+
 VALUE
 rbtree_each(VALUE self)
 {
@@ -24,3 +50,31 @@ rbtree_each(VALUE self)
 
   return self;
 }
+
+
+VALUE
+rbtree_each_key(VALUE self)
+{
+  rb_need_block();
+  VALUE block = rb_block_proc();
+
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  g_tree_foreach(rbtree->gtree, foraech_key_callbac, (gpointer) block);
+
+  return self;
+}
+
+
+VALUE
+rbtree_each_value(VALUE self)
+{
+  rb_need_block();
+  VALUE block = rb_block_proc();
+
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  g_tree_foreach(rbtree->gtree, foraech_value_callbac, (gpointer) block);
+
+  return self;
+}

data/ext/native_btree/native_btree.c

@@ -1,28 +1,63 @@
 #include <native_btree.h>
+#include <rbtree_type.h>
+#include <glib_module.h>
 
-VALUE rbtree_class;
-VALUE rbtree_module;
+#define NATIVE_BTREE_MODULE "NativeBtree"
+#define NATIVE_BTREE_CLASS "Btree"
+#define NATIVE_BTREE_CONST_INT_COMPARATOR "INT_COMPARATOR"
 
 
+VALUE native_btree_class;
+VALUE native_btree_module;
+
 void
 Init_native_btree()
 {
-  rbtree_module = rb_define_module(NATIVE_BTREE_MODULE);
-  rbtree_class = rb_define_class_under(rbtree_module, NATIVE_BTREE_CLASS, rb_cObject);
-
-  rb_define_alloc_func(rbtree_class, rbtree_alloc);
-  rb_define_method(rbtree_class, "initialize", rbtree_initialize, 0);
-
-  rb_define_method(rbtree_class, "[]=", rbtree_set, 2);
-  rb_define_alias(rbtree_class, "set", "[]=");
-  rb_define_method(rbtree_class, "[]", rbtree_get, 1);
-  rb_define_alias(rbtree_class, "get", "[]");
-  rb_define_method(rbtree_class, "delete", rbtree_delete, 1);
-  rb_define_method(rbtree_class, "each", rbtree_each, 0);
-  rb_define_method(rbtree_class, "size", rbtree_size, 0);
-  rb_define_method(rbtree_class, "height", rbtree_height, 0);
-  rb_define_method(rbtree_class, "clear", rbtree_clear, 0);
-  rb_define_method(rbtree_class, "include?", rbtree_is_include, 1);
-  rb_define_method(rbtree_class, "to_h", rbtree_to_h, 0);
-  rb_define_method(rbtree_class, "to_a", rbtree_to_a, 0);
+  native_btree_module = rb_define_module(NATIVE_BTREE_MODULE);
+  native_btree_class = rb_define_class_under(
+    native_btree_module,
+    NATIVE_BTREE_CLASS,
+    rb_cObject
+  );
+
+  VALUE int_comparator = USHORT2NUM(RBTREE_FLAG_INT_COMPARATOR);
+  OBJ_FREEZE(int_comparator);
+  rb_define_const(
+    native_btree_class,
+    NATIVE_BTREE_CONST_INT_COMPARATOR,
+    int_comparator
+  );
+
+  rbtree_attach_module_glib();
+
+  // rb_include_module(native_btree_class, rb_mEnumerable);
+
+  rb_define_alloc_func(native_btree_class, rbtree_alloc);
+  rb_define_method(native_btree_class, "initialize", rbtree_initialize, -1);
+
+  rb_define_method(native_btree_class, "[]=", rbtree_set, 2);
+  rb_define_alias(native_btree_class, "set", "[]=");
+  rb_define_method(native_btree_class, "[]", rbtree_get, 1);
+  rb_define_alias(native_btree_class, "get", "[]");
+  rb_define_method(native_btree_class, "delete", rbtree_delete, 1);
+  rb_define_method(native_btree_class, "each", rbtree_each, 0);
+  rb_define_method(native_btree_class, "each_key", rbtree_each_key, 0);
+  rb_define_method(native_btree_class, "each_value", rbtree_each_value, 0);
+  rb_define_method(native_btree_class, "size", rbtree_size, 0);
+  rb_define_method(native_btree_class, "height", rbtree_height, 0);
+  rb_define_method(native_btree_class, "clear", rbtree_clear, 0);
+  rb_define_method(native_btree_class, "include?", rbtree_is_include, 1);
+  rb_define_method(native_btree_class, "to_h", rbtree_to_h, 0);
+  rb_define_method(native_btree_class, "to_a", rbtree_to_a, 0);
+  rb_define_method(native_btree_class, "to_proc", rbtree_to_proc, 0);
+  rb_define_method(native_btree_class, "filter", rbtree_filter, 0);
+  rb_define_alias(native_btree_class, "select", "filter");
+  rb_define_method(native_btree_class, "filter!", rbtree_filter_bang, 0);
+  rb_define_alias(native_btree_class, "select!", "filter!");
+  rb_define_method(native_btree_class, "empty?", rbtree_is_empty, 0);
+
+#ifdef HAS_GTREE_NODE
+  rb_define_method(native_btree_class, "select_before", rbtree_select_before, 1);
+  rb_define_method(native_btree_class, "select_after", rbtree_select_after, 1);
+#endif
 }

data/ext/native_btree/rbtree_type.c

@@ -4,11 +4,14 @@ const rb_data_type_t rbtree_type;
 
 
 static void
-rbtree_free(gpointer data)
+rbtree_type_free(gpointer data)
 {
   RBTree *rbtree = (RBTree *) data;
 
-  g_tree_destroy(rbtree->gtree);
+  if (rbtree->gtree) {
+    g_tree_destroy(rbtree->gtree);
+  }
+
   g_free(data);
 }
 
@@ -24,11 +27,13 @@ rbtree_mark_callback(gpointer key, gpointer value, gpointer data)
 
 
 static void
-rbtree_mark(gpointer data)
+rbtree_type_mark(gpointer data)
 {
-  RBTree *rbtree = (RBTree *)data;
+  RBTree *rbtree = (RBTree *) data;
 
-  rb_gc_mark(rbtree->comparator);
+  if (!NIL_P(rbtree->comparator)) {
+    rb_gc_mark(rbtree->comparator);
+  }
 
   g_tree_foreach(rbtree->gtree, rbtree_mark_callback, NULL);
 }
@@ -61,7 +66,7 @@ struct _GTreeNode
 */
 
 static size_t
-rbtree_size(gconstpointer data)
+rbtree_type_size(gconstpointer data)
 {
   RBTree *rbtree = (RBTree *) data;
 
@@ -82,11 +87,11 @@ rbtree_size(gconstpointer data)
 
 
 const rb_data_type_t rbtree_type = {
-  .wrap_struct_name = NATIVE_TYPE_NAME,
+  .wrap_struct_name = RBTREE_NATIVE_TYPE_NAME,
   .function = {
-    .dmark = rbtree_mark,
-    .dfree = rbtree_free,
-    .dsize = rbtree_size,
+    .dmark = rbtree_type_mark,
+    .dfree = rbtree_type_free,
+    .dsize = rbtree_type_size,
   },
   .data = NULL,
   .flags = RUBY_TYPED_FREE_IMMEDIATELY,
@@ -98,5 +103,26 @@ rbtree_alloc(VALUE self)
 {
   RBTree *rbtree = g_new(RBTree, 1);
 
+  rbtree->gtree = NULL;
+  rbtree->comparator = Qnil;
+  rbtree->flags = 0;
+
   return TypedData_Wrap_Struct(self, &rbtree_type, rbtree);
 }
+
+
+VALUE
+rbtree_clone_wrap(const RBTree *orig)
+{
+  const VALUE rflags = USHORT2NUM(orig->flags);
+
+  VALUE new_tree = rb_funcall_with_block(
+    native_btree_class,
+    rb_intern("new"),
+    orig->flags ? 1 : 0,
+    orig->flags ? &rflags : NULL,
+    orig->comparator
+  );
+
+  return new_tree;
+}

data/ext/native_btree/search.c

@@ -0,0 +1,94 @@
+#include <iterators.h>
+
+
+static gboolean
+filter_callback(gpointer a, gpointer b, gpointer data)
+{
+  RBTreeSearchData *context = (RBTreeSearchData *) data;
+
+  VALUE compare_result = rb_funcall(
+    context->block,
+    rb_intern("call"),
+    2,
+    (VALUE) b,
+    (VALUE) a
+  );
+
+  if (RTEST(compare_result)) {
+    g_tree_insert(context->tree->gtree, a, b);
+  }
+
+  return FALSE;
+}
+
+static gboolean
+filter_bang_callback(gpointer a, gpointer b, gpointer data)
+{
+  RBTreeSearchData *context = (RBTreeSearchData *) data;
+  GPtrArray *to_remove = (GPtrArray *) context->something;
+
+  VALUE compare_result = rb_funcall(
+    context->block,
+    rb_intern("call"),
+    2,
+    (VALUE) b,
+    (VALUE) a
+  );
+
+  if (!RTEST(compare_result)) {
+    // Add to remove
+    g_ptr_array_add(to_remove, a);
+  }
+
+  return FALSE;
+}
+
+VALUE
+rbtree_filter(VALUE self)
+{
+  rb_need_block();
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  VALUE block = rb_block_proc();
+
+  VALUE new_tree = rbtree_clone_wrap(rbtree);
+
+  EXTRACT_RBTREE(new_tree, new_rbtree);
+
+  RBTreeSearchData data = {
+    block,
+    new_rbtree,
+    NULL
+  };
+
+  g_tree_foreach(rbtree->gtree, filter_callback, &data);
+
+  return new_tree;
+}
+
+VALUE
+rbtree_filter_bang(VALUE self)
+{
+  rb_need_block();
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  VALUE block = rb_block_proc();
+
+  GPtrArray *to_remove = g_ptr_array_new();
+
+  RBTreeSearchData data = {
+    block,
+    NULL,
+    (gconstpointer) to_remove
+  };
+
+  g_tree_foreach(rbtree->gtree, filter_bang_callback, &data);
+
+  for (size_t i = 0; i < to_remove->len; i++) {
+    g_tree_remove(rbtree->gtree, g_ptr_array_index(to_remove, i));
+  }
+
+  g_ptr_array_free(to_remove, TRUE);
+
+  return self;
+}

data/lib/native_btree/version.rb

@@ -1,3 +1,3 @@
 module NativeBtree
-  VERSION = "0.2.1".freeze
+  VERSION = "0.4.0".freeze
 end

data/spec/debug.rb

@@ -2,7 +2,7 @@
 
 require_relative "../lib/native_btree/native_btree"
 
-tree = NativeBtree::Btree.new
+tree = NativeBtree::Btree.new() {|a, b| a - b }
 
 GC.start
 
@@ -17,7 +17,25 @@ GC.start
 block = ->(key) { "#{key} is not found" }
 puts tree.delete(77, &block)
 
-tree = null
+tree2 = tree.filter!() { true }
+
+puts tree.to_h
+
+pr = tree.to_proc
+
+puts pr
+
+
+tree.clear
+tree[1] = 15
+tree[2] = 22
+tree[3] = 33
+tree[4] = 44
+tree[5] = 55
+tree[6] = 66
+tree[7] = 77
+
+puts tree.select_after(4).to_h
 
 GC.start
 

data/spec/native_btree_class_spec.rb

@@ -19,6 +19,22 @@ RSpec.describe NativeBtree do
       it "raise error if block is not given" do
         expect { described_class.new() }.to raise_error(LocalJumpError)
       end
+
+      it 'return new btree with int comparator' do
+        expect(described_class.new(described_class::INT_COMPARATOR))
+          .to be_kind_of(described_class)
+      end
+
+    end
+
+    describe "constants" do
+      it 'has const INT_COMPARATOR' do
+        expect(described_class.const_defined?(:INT_COMPARATOR)).to be true
+      end
+
+      it 'const INT_COMPARATOR is 1' do
+        expect(described_class::INT_COMPARATOR).to be 128
+      end
     end
   end
 end

data/spec/native_btree_conversion_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+RSpec.describe NativeBtree do
+
+  describe NativeBtree::Btree do
+    let(:tree) do
+      described_class.new do |a, b|
+        a - b
+      end
+    end
+
+    describe "to_ methods" do
+      describe "#to_a" do
+        it "respond to" do
+          expect(tree).to respond_to(:to_a)
+        end
+
+        it 'return Array' do
+          expect(tree.to_a).to be_kind_of(Array)
+        end
+
+        it 'has similar items' do
+          tree[2] = 22
+          tree[1] = 11
+          expect(tree.to_a()[0][1]).to be 11
+        end
+      end
+
+      describe "#to_h" do
+        it "respond to" do
+          expect(tree).to respond_to(:to_h)
+        end
+
+        it "return Hash" do
+          expect(tree.to_h).to be_kind_of(Hash)
+        end
+
+        it 'has similar keys' do
+          tree[2] = 22
+          tree[1] = 11
+          expect(tree.to_h()[1]).to be 11
+        end
+      end
+
+      describe '#to_proc' do
+        it 'respond to' do
+          expect(tree).to respond_to(:to_proc)
+        end
+
+        it 'return Proc' do
+          expect(tree.to_proc).to be_kind_of(Proc)
+        end
+
+        it 'return value for key' do
+          tree[2] = 22
+          tree[1] = 11
+          pr = tree.to_proc
+          expect(pr.call(1)).to be 11
+        end
+
+        it 'return null for non existent key' do
+          tree[2] = 22
+          tree[1] = 11
+          pr = tree.to_proc
+          expect(pr.call(12)).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/native_btree_instance_spec.rb

@@ -156,18 +156,6 @@ RSpec.describe NativeBtree do
       end
     end
 
-    describe "#filter method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:filter)).to be true
-      end
-    end
-
-    describe "#filter! method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:filter!)).to be true
-      end
-    end
-
     describe "#include? method" do
       it "respond to" do
         expect(tree).to respond_to(:include?)
@@ -184,99 +172,18 @@ RSpec.describe NativeBtree do
       end
     end
 
-    describe "to_ methods" do
-      describe "#to_a" do
-        it "respond to" do
-          expect(tree).to respond_to(:to_a)
-        end
-
-        it 'return Array' do
-          expect(tree.to_a).to be_kind_of(Array)
-        end
-
-        it 'has similar items' do
-          tree[2] = 22
-          tree[1] = 11
-          expect(tree.to_a()[0][1]).to be 11
-        end
+    describe "#empty? method" do
+      it 'respond to' do
+        expect(tree).to respond_to(:empty?)
       end
 
-      describe "#to_h" do
-        it "respond to" do
-          expect(tree).to respond_to(:to_h)
-        end
-
-        it "return Hash" do
-          expect(tree.to_h).to be_kind_of(Hash)
-        end
-
-        it 'has similar keys' do
-          tree[2] = 22
-          tree[1] = 11
-          expect(tree.to_h()[1]).to be 11
-        end
-      end
-    end
-
-    describe "#each method" do
-      it "respond to" do
-        expect(tree).to respond_to(:each)
-      end
-
-      it 'yield in to block value first' do
-        tree[2] = 22
-
-        value = nil
-        tree.each { |v| value = v }
-
-        expect(value).to be 22
-      end
-
-      it 'yield in to block key second' do
-        tree[2] = 22
-
-        key = nil
-        tree.each { |_v, k| key = k }
-
-        expect(key).to be 2
-      end
-
-      it 'yield ordered keys' do
-        tree[16] = 16
-        tree[0] = 0
-        tree[5] = 5
-        tree[-4] = -4
-        tree[7] = 7
-
-        check = [-4, 0, 5, 7, 16]
-        result = []
-        tree.each { |value| result << value }
-
-        expect(result).to eq(check)
-      end
-    end
-
-    describe "#each_key method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:each_key)).to be true
-      end
-    end
-
-    describe "#each_value method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:each_value)).to be true
-      end
-    end
-
-    describe "#select method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:select)).to be true
+      it 'return false if nodes exists' do
+        tree[3] = 33
+        expect(tree.empty?).to be false
       end
-    end
 
-    describe "#select! method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:select!)).to be true
+      it 'return true if nodes not exists' do
+        expect(tree.empty?).to be true
       end
     end
   end