native_btree 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08e62bb88bd973ac257570f1b769323dea7ccedf9c0c2d80f5e99ba7eb2f33ff'
-  data.tar.gz: d8d2cfac5c388216c45b1c17e225a2982871dd94c871414623f73222cd8e6f81
+  metadata.gz: 4744529a22fe3d5cd3eb53cf258fa5440346df593e6d268d7af3d2e4b197addf
+  data.tar.gz: 887db38cf3c3c23cd72984f6ec2bbdfce1ebce57e547c5cc2d96c81184a36833
 SHA512:
-  metadata.gz: 5ef4b7687b447e1b36c32e0252bb71f90005e0cfa729a1ddfd6f62f0b4e6b0c11ef29e3703563459de551fa3ae0577c537cd8d09f1a04fa34745d2abf53ab541
-  data.tar.gz: 99d89673be28500e83030d0d300f758ff0857d0be0d9026dd39d72fe7b35ac58bdc44ba5fd567145ace04676ada29dd6a4afe895e47c99b23de530f53cf72951
+  metadata.gz: f46367c894c10a0ca5db645470228f08edafabe9010a5115d9c92008688eec29f9a0973ba462138483912a2bebe52660eb17828298ea69ebd1709d4811cfb470
+  data.tar.gz: 9a342ae22e6ced29b02aa24917f1307fc0a0721885667185266eaa1b23f73fd37c90918126dd1ac6aa24cee08a3c838c25a951e3a84ea5f23cb93e2532d9549d

data/CHANGELOG.md

@@ -7,10 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-* delete_if()
+* #compact
+* #compact!
+* #>
+* #>=
+* #<
+* #<=
+
+## [0.6.0] - 2022-10-28
+
+### Added
+
+* inspect
+* to_s
+* delete_if
 * first, min
 * last, max
 
+### Changed
+
+* Refactoring
+* Performance improvements for #==
+
 ## [0.5.0] - 2022-10-04
 
 ### Added

data/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.5)
 
 project(ruby-native-btree
 	LANGUAGES C
-	VERSION 0.5.0)
+	VERSION 0.6.0)
 
 include(CheckSymbolExists)
 include(CheckCCompilerFlag)

data/README.md

@@ -103,12 +103,14 @@ Implemented methods:
 * `delete`
 * `size`
 * `height`
-* `each` (NB! block is required) (NB! block is required)
+* `each`
 * `include?`
 * `clear`
 * `to_h`
 * `to_a`
 * `to_proc`
+* `to_s`
+* `inspect`
 * `filter` (alias: select)
 * `filter!` (alias: select!)
 * `each_value`
@@ -117,5 +119,6 @@ Implemented methods:
 * `search_after` (GLib version >= 2.68) - Select keys >= first arg, ret new Btree
 * `empty?`
 * `reverse_each`
+* `delete_if`
 
 You can mix in the `Enumerable` module if additional methods are needed.

data/ext/native_btree/conversion.c

@@ -76,3 +76,14 @@ rbtree_to_proc(VALUE self)
 {
   return rb_proc_new(to_proc_proc, self);
 }
+
+
+VALUE
+rbtree_to_s(VALUE self)
+{
+  VALUE h = rbtree_to_h(self);
+
+  VALUE str = rb_sprintf("#<NativeBtree::Btree:%"PRIsVALUE">", h);
+
+  return str;
+}

data/ext/native_btree/include/iterators.h

@@ -1,13 +1,20 @@
 #include <common.h>
 
+#ifndef _NATIVE_BTREE_ITERATORS_
+#define _NATIVE_BTREE_ITERATORS_
+
 typedef struct {
   const VALUE block;
   const RBTree *tree;
+  glong counter;
+  gushort flags;
   gconstpointer something;
-} RBTreeSearchData;
+} RBTreeSearchContext;
 
 #ifdef HAS_GTREE_NODE
 
 typedef GTreeNode *(RBTreeStepFunction) (GTreeNode *node);
 
 #endif
+
+#endif // _NATIVE_BTREE_ITERATORS_

data/ext/native_btree/include/native_btree.h

@@ -89,4 +89,13 @@ rbtree_equal(VALUE self, VALUE btree);
 VALUE
 rbtree_reverse_each(VALUE self);
 
+VALUE
+rbtree_first(VALUE self);
+
+VALUE
+rbtree_last(VALUE self);
+
+VALUE
+rbtree_to_s(VALUE self);
+
 #endif // _NATIVE_BTREE_

data/ext/native_btree/instance.c

@@ -4,6 +4,7 @@
   #include <compare_trees.h>
 #else
   #include <utils.h>
+  #include <iterators.h>
 #endif
 
 #ifndef HAS_GTREE_REMOVE_ALL
@@ -20,6 +21,96 @@ rbtree_remove_node(gpointer key, gpointer val, gpointer data) {
 #endif
 
 
+#ifndef HAS_GTREE_NODE
+
+static gint
+rbtree_first_cb(gpointer a, gpointer b, gpointer data)
+{
+  RBTreeSearchContext *context = (RBTreeSearchContext *) data;
+
+  context->something = (gconstpointer) b;
+  context->counter = 0;
+
+  return TRUE;
+}
+
+
+static gint
+rbtree_last_cb(gpointer a, gpointer b, gpointer data)
+{
+  RBTreeSearchContext *context = (RBTreeSearchContext *) data;
+
+  context->something = (gconstpointer) b;
+  context->counter += 1;
+
+  return FALSE;
+}
+
+
+static gint
+legacy_compare_visitor(gpointer a, gpointer b, gpointer data)
+{
+  RBTreeSearchContext *context = (RBTreeSearchContext *) data;
+
+  GPtrArray *flat_tree = (GPtrArray *) context->something;
+  VALUE key = (VALUE) a;
+  VALUE val = (VALUE) b;
+  VALUE is_eq = Qfalse;
+
+  VALUE key2 = (VALUE) g_ptr_array_index(flat_tree, context->counter);
+  VALUE val2 = (VALUE) g_ptr_array_index(flat_tree, context->counter + 1);
+
+  is_eq = rb_funcall(key, rb_intern("=="), 1, key2);
+
+  if (!RTEST(is_eq)) {
+    context->flags = 1;
+    return TRUE;
+  }
+
+  is_eq = rb_funcall(val, rb_intern("=="), 1, val2);
+
+  if (!RTEST(is_eq)) {
+    context->flags = 1;
+    return TRUE;
+  }
+
+  (context->counter) += 2;
+
+  return FALSE;
+}
+
+
+static inline gboolean
+legacy_rbtree_compare(const RBTree *a, const RBTree *b)
+{
+  gboolean result = TRUE;
+
+  GPtrArray *second = rbtree_to_ptr_array(b);
+
+  // assumes that the size of arrays is same (checked before)
+
+  RBTreeSearchContext context = {
+    Qnil,
+    NULL,
+    0,
+    0,
+    (gconstpointer) second
+  };
+
+  g_tree_foreach(a->gtree, legacy_compare_visitor, &context);
+
+  if (context.flags) {
+    result = FALSE;
+  }
+
+  g_ptr_array_free(second, TRUE);
+
+  return result;
+}
+
+#endif
+
+
 VALUE
 rbtree_set(VALUE self, VALUE key, VALUE value)
 {
@@ -141,53 +232,6 @@ rbtree_is_empty(VALUE self)
 }
 
 
-#ifndef HAS_GTREE_NODE
-
-static inline gboolean
-legacy_rbtree_compare(const RBTree *a, const RBTree *b)
-{
-  gboolean result = FALSE;
-
-  GPtrArray *first = rbtree_to_ptr_array(a);
-  GPtrArray *second = rbtree_to_ptr_array(b);
-
-  // assumes that the size of arrays is same (checked before)
-
-  VALUE key, val, key2, val2, is_eq;
-
-  for (guint i = 0; i < first->len; i += 2) {
-    key = (VALUE) g_ptr_array_index(first, i);
-    val = (VALUE) g_ptr_array_index(first, i + 1);
-
-    key2 = (VALUE) g_ptr_array_index(second, i);
-    val2 = (VALUE) g_ptr_array_index(second, i + 1);
-
-    is_eq = rb_funcall(key, rb_intern("=="), 1, key2);
-
-    if (!RTEST(is_eq)) {
-      goto fail;
-    }
-
-    is_eq = rb_funcall(val, rb_intern("=="), 1, val2);
-
-    if (!RTEST(is_eq)) {
-      goto fail;
-    }
-  }
-
-  result = TRUE;
-
-  fail:
-
-  g_ptr_array_free(first, TRUE);
-  g_ptr_array_free(second, TRUE);
-
-  return result;
-}
-
-#endif
-
-
 VALUE
 rbtree_equal(VALUE self, VALUE second)
 {
@@ -221,3 +265,69 @@ rbtree_equal(VALUE self, VALUE second)
   ret:
   return result;
 }
+
+
+VALUE
+rbtree_first(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+#ifdef HAS_GTREE_NODE
+  GTreeNode *node = g_tree_node_first(rbtree->gtree);
+
+  if (!node) {
+    return Qnil;
+  }
+
+  return (VALUE) g_tree_node_value(node);
+#else
+  RBTreeSearchContext context = {
+    Qnil,
+    NULL,
+    1,
+    0,
+    NULL
+  };
+
+  g_tree_foreach(rbtree->gtree, rbtree_first_cb, &context);
+
+  if (context.counter) {
+    return Qnil;
+  }
+
+  return (VALUE) context.something;
+#endif
+}
+
+
+VALUE
+rbtree_last(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+#ifdef HAS_GTREE_NODE
+  GTreeNode *node = g_tree_node_last(rbtree->gtree);
+
+  if (!node) {
+    return Qnil;
+  }
+
+  return (VALUE) g_tree_node_value(node);
+#else
+  RBTreeSearchContext context = {
+    Qnil,
+    NULL,
+    0,
+    0,
+    NULL
+  };
+
+  g_tree_foreach(rbtree->gtree, rbtree_last_cb, &context);
+
+  if (!context.counter) {
+    return Qnil;
+  }
+
+  return (VALUE) context.something;
+#endif
+}

data/ext/native_btree/iterators.c

@@ -1,4 +1,5 @@
 #include <common.h>
+#include <iterators.h>
 
 #ifndef HAS_GTREE_NODE
   #include <utils.h>
@@ -128,3 +129,53 @@ rbtree_reverse_each(VALUE self)
 
   return self;
 }
+
+
+static gint
+rbtree_delete_if_cb(gpointer k, gpointer v, gpointer data)
+{
+  VALUE key = (VALUE) k;
+  VALUE value = (VALUE) v;
+  RBTreeSearchContext *context = (RBTreeSearchContext *) data;
+  VALUE block = (VALUE) context->block;
+  GPtrArray *result = (GPtrArray *) context->something;
+
+  VALUE to_delete = rb_funcall(block, rb_intern("call"), 2, key, value);
+
+  if (RTEST(to_delete)) {
+    g_ptr_array_add(result, (gpointer) key);
+  }
+
+  return FALSE;
+}
+
+
+VALUE
+rbtree_delete_if(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  GPtrArray *to_delete = g_ptr_array_new();
+
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, rbtree_enum_length);
+
+  VALUE block = rb_block_proc();
+
+  RBTreeSearchContext context = {
+    block,
+    NULL,
+    0,
+    0,
+    to_delete
+  };
+
+  g_tree_foreach(rbtree->gtree, rbtree_delete_if_cb, &context);
+
+  for (guint i = 0; i < to_delete->len; i++) {
+    g_tree_remove(rbtree->gtree, g_ptr_array_index(to_delete, i));
+  }
+
+  g_ptr_array_free(to_delete, TRUE);
+
+  return self;
+}

data/ext/native_btree/native_btree.c

@@ -57,6 +57,13 @@ Init_native_btree()
   rb_define_method(native_btree_class, "empty?", rbtree_is_empty, 0);
   rb_define_method(native_btree_class, "==", rbtree_equal, 1);
   rb_define_method(native_btree_class, "reverse_each", rbtree_reverse_each, 0);
+  rb_define_method(native_btree_class, "first", rbtree_first, 0);
+  rb_define_alias(native_btree_class, "min", "first");
+  rb_define_method(native_btree_class, "last", rbtree_last, 0);
+  rb_define_alias(native_btree_class, "max", "last");
+  rb_define_method(native_btree_class, "delete_if", rbtree_delete_if, 0);
+  rb_define_method(native_btree_class, "to_s", rbtree_to_s, 0);
+  rb_define_alias(native_btree_class, "inspect", "to_s");
 
 #ifdef HAS_GTREE_NODE
   rb_define_method(native_btree_class, "select_before", rbtree_select_before, 1);

data/ext/native_btree/search.c

@@ -4,7 +4,7 @@
 static gboolean
 filter_callback(gpointer a, gpointer b, gpointer data)
 {
-  RBTreeSearchData *context = (RBTreeSearchData *) data;
+  RBTreeSearchContext *context = (RBTreeSearchContext *) data;
 
   VALUE compare_result = rb_funcall(
     context->block,
@@ -24,7 +24,7 @@ filter_callback(gpointer a, gpointer b, gpointer data)
 static gboolean
 filter_bang_callback(gpointer a, gpointer b, gpointer data)
 {
-  RBTreeSearchData *context = (RBTreeSearchData *) data;
+  RBTreeSearchContext *context = (RBTreeSearchContext *) data;
   GPtrArray *to_remove = (GPtrArray *) context->something;
 
   VALUE compare_result = rb_funcall(
@@ -55,9 +55,11 @@ rbtree_filter(VALUE self)
 
   EXTRACT_RBTREE(new_tree, new_rbtree);
 
-  RBTreeSearchData data = {
+  RBTreeSearchContext data = {
     block,
     new_rbtree,
+    0,
+    0,
     NULL
   };
 
@@ -76,9 +78,11 @@ rbtree_filter_bang(VALUE self)
 
   GPtrArray *to_remove = g_ptr_array_new();
 
-  RBTreeSearchData data = {
+  RBTreeSearchContext data = {
     block,
     NULL,
+    0,
+    0,
     (gconstpointer) to_remove
   };
 

data/lib/native_btree/version.rb

@@ -1,3 +1,3 @@
 module NativeBtree
-  VERSION = "0.5.0".freeze
+  VERSION = "0.6.0".freeze
 end

data/spec/debug.rb

@@ -1,6 +1,7 @@
 # rubocop:disable all
 
 require_relative "../lib/native_btree/native_btree"
+require 'benchmark'
 
 NativeBtree::Btree.include(Enumerable)
 

data/spec/native_btree_conversion_spec.rb

@@ -65,6 +65,37 @@ RSpec.describe NativeBtree do
           expect(pr.call(12)).to be_nil
         end
       end
+
+      describe "#to_s" do
+        it 'respond to' do
+          expect(tree).to respond_to(:to_s)
+        end
+
+        it 'return correct str for empty' do
+          expect(tree.to_s).to eq('#<NativeBtree::Btree:{}>')
+        end
+
+        it 'return correct str' do
+          tree[10] = "20"
+          expect(tree.to_s).to eq('#<NativeBtree::Btree:{10=>"20"}>')
+        end
+      end
+
+      describe "#inspect" do
+        it 'respond to' do
+          expect(tree).to respond_to(:inspect)
+        end
+
+        it 'return correct str for empty' do
+          expect(tree.to_s).to eq('#<NativeBtree::Btree:{}>')
+        end
+
+        it 'return correct str' do
+          tree[10] = "20"
+          tree[30] = "40"
+          expect(tree.to_s).to eq('#<NativeBtree::Btree:{10=>"20", 30=>"40"}>')
+        end
+      end
     end
   end
 end

data/spec/native_btree_instance_spec.rb

@@ -258,5 +258,62 @@ RSpec.describe NativeBtree do
         expect(tree).not_to eq tree2
       end
     end
+
+    describe '#last method' do
+      it 'respond to' do
+        expect(tree).to respond_to(:last)
+      end
+
+      it 'return correct value' do
+        tree[1] = 10
+        tree[10] = 20
+        tree[20] = 30
+
+        expect(tree.last).to eq(30)
+      end
+
+      it 'return nil if empty' do
+        expect(tree.last).to be_nil
+      end
+    end
+
+    describe '#first method' do
+      it 'respond to' do
+        expect(tree).to respond_to(:first)
+      end
+
+      it 'return correct value' do
+        tree[1] = 10
+        tree[10] = 20
+        tree[20] = 30
+
+        expect(tree.first).to eq(10)
+      end
+
+      it 'return nil if empty' do
+        expect(tree.first).to be_nil
+      end
+    end
+
+    describe '#delete_if method' do
+      it 'respond to' do
+        expect(tree).to respond_to(:delete_if)
+      end
+
+      it 'return self' do
+        expect(tree.delete_if { |_, _| false }).to be tree
+      end
+
+      it 'return expected result' do
+        tree[1] = 10
+        tree[10] = 20
+        tree[20] = 30
+
+        tree.delete_if { |_, v| v < 30 }
+
+        expect(tree.to_a).to eq([[20, 30]])
+      end
+    end
+
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: native_btree
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Alexander Feodorov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-03 00:00:00.000000000 Z
+date: 2022-10-27 00:00:00.000000000 Z
 dependencies: []
 description: Ruby bindings to GTree balanced binary tree from GLib library.
 email: