native_btree 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 467637c8963d9da6b70984356470bddfaa7d1b6b3952091e76730852bde71bac
-  data.tar.gz: a1842e6875ae3dbd94855a50cc38e35369a623518a502694df1d7f223ebe481b
+  metadata.gz: '08e62bb88bd973ac257570f1b769323dea7ccedf9c0c2d80f5e99ba7eb2f33ff'
+  data.tar.gz: d8d2cfac5c388216c45b1c17e225a2982871dd94c871414623f73222cd8e6f81
 SHA512:
-  metadata.gz: c14e828145463b99a5edd19b0c830fcba54a86872380e32acee447ce302daea5a9300771f8b4ee68c90c2807e2fd9d595bb9f71ac15c7e9d2f261f95790f9767
-  data.tar.gz: b2d449bfd707dabec594f0847312956cbf6c80543497027611c04eb81215b620dfd4efdbda8427f4628ddd8e500742fdb3d7e12f9664ba963387a1556c40bb74
+  metadata.gz: 5ef4b7687b447e1b36c32e0252bb71f90005e0cfa729a1ddfd6f62f0b4e6b0c11ef29e3703563459de551fa3ae0577c537cd8d09f1a04fa34745d2abf53ab541
+  data.tar.gz: 99d89673be28500e83030d0d300f758ff0857d0be0d9026dd39d72fe7b35ac58bdc44ba5fd567145ace04676ada29dd6a4afe895e47c99b23de530f53cf72951

data/CHANGELOG.md

@@ -8,7 +8,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 * delete_if()
-* each method refactoring for Enumerator return type
+* first, min
+* last, max
+
+## [0.5.0] - 2022-10-04
+
+### Added
+
+* ==()
+* each like methods without a block returns Enumerator
+* reverse_each
+
+### Changed
+
+* Refactoring
+
+## [0.4.1] - 2022-09-30
+
+### Changed
+
+* Fix - Failed building on Apple M1 CPU
 
 ## [0.4.0] - 2022-09-16
 

data/CMakeLists.txt

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

data/README.md

@@ -99,6 +99,7 @@ Implemented methods:
 
 * `[]= (alias: set)`
 * `[] (alias: get)`
+* `==`
 * `delete`
 * `size`
 * `height`
@@ -115,5 +116,6 @@ Implemented methods:
 * `search_before` (GLib version >= 2.68) - Select keys <= first arg, ret new Btree
 * `search_after` (GLib version >= 2.68) - Select keys >= first arg, ret new Btree
 * `empty?`
+* `reverse_each`
 
 You can mix in the `Enumerable` module if additional methods are needed.

data/ext/native_btree/CMakeLists.txt

@@ -38,6 +38,7 @@ add_library(iterators OBJECT iterators.c)
 add_library(conversion OBJECT conversion.c)
 add_library(search OBJECT search.c)
 add_library(glib_module OBJECT glib_module.c)
+add_library(utils OBJECT utils.c)
 
 
 set(LIB_OBJECTS)
@@ -53,6 +54,9 @@ list(APPEND LIB_OBJECTS
 
 if(HAS_GTREE_NODE)
 	list(APPEND LIB_OBJECTS $<TARGET_OBJECTS:additional_iterators>)
+	list(APPEND LIB_OBJECTS $<TARGET_OBJECTS:compare_trees>)
+else()
+	list(APPEND LIB_OBJECTS $<TARGET_OBJECTS:utils>)
 endif()
 
 add_library(native_btree_interface

data/ext/native_btree/glib2_68/CMakeLists.txt

@@ -1,3 +1,4 @@
 # set(CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE  ON)
 
 add_library(additional_iterators OBJECT additional_iterators.c)
+add_library(compare_trees OBJECT compare_trees.c)

data/ext/native_btree/glib2_68/compare_trees.c

@@ -0,0 +1,54 @@
+#include <compare_trees.h>
+
+static inline gboolean
+rbtree_compare_trees_nodes(GTreeNode *a, GTreeNode *b)
+{
+  gboolean result = TRUE;
+
+  VALUE key_a = (VALUE) g_tree_node_key(a);
+  VALUE val_a = (VALUE) g_tree_node_value(a);
+  VALUE key_b = (VALUE) g_tree_node_key(b);
+  VALUE val_b = (VALUE) g_tree_node_value(b);
+
+  VALUE key_result = rb_funcall(key_a, rb_intern("=="), 1, key_b);
+
+  if (!RTEST(key_result)) {
+    return FALSE;
+  }
+
+  VALUE val_result = rb_funcall(val_a, rb_intern("=="), 1, val_b);
+
+  if (!RTEST(val_result)) {
+    return FALSE;
+  }
+
+  return result;
+}
+
+/**
+ * Compare two trees
+ *
+ * This function assumes that the number of nodes is same (already checked)
+ */
+gboolean
+rbtree_compare_trees(const RBTree *a, const RBTree *b)
+{
+
+  GTreeNode *a_node = g_tree_node_first(a->gtree);
+  GTreeNode *b_node = g_tree_node_first(b->gtree);
+
+  gboolean result = FALSE;
+
+  while (a_node && b_node) {
+    result = rbtree_compare_trees_nodes(a_node, b_node);
+
+    if (!result) {
+      break;
+    }
+
+    a_node = g_tree_node_next(a_node);
+    b_node = g_tree_node_next(b_node);
+  }
+
+  return result;
+}

data/ext/native_btree/include/compare_trees.h

@@ -0,0 +1,4 @@
+#include <common.h>
+
+gboolean
+rbtree_compare_trees(const RBTree *a, const RBTree *b);

data/ext/native_btree/include/native_btree.h

@@ -83,4 +83,10 @@ rbtree_keys(VALUE self);
 VALUE
 rbtree_values(VALUE self);
 
+VALUE
+rbtree_equal(VALUE self, VALUE btree);
+
+VALUE
+rbtree_reverse_each(VALUE self);
+
 #endif // _NATIVE_BTREE_

data/ext/native_btree/include/utils.h

@@ -0,0 +1,10 @@
+#include <common.h>
+
+
+#ifndef _NATIVE_BTREE_UTILS_
+#define _NATIVE_BTREE_UTILS_
+
+GPtrArray*
+rbtree_to_ptr_array(const RBTree *rbtree);
+
+#endif //_NATIVE_BTREE_UTILS_

data/ext/native_btree/instance.c

@@ -1,5 +1,10 @@
 #include <common.h>
 
+#ifdef HAS_GTREE_NODE
+  #include <compare_trees.h>
+#else
+  #include <utils.h>
+#endif
 
 #ifndef HAS_GTREE_REMOVE_ALL
 
@@ -63,9 +68,7 @@ rbtree_delete(VALUE self, VALUE key)
   }
   else {
     if (rb_block_given_p()) {
-      VALUE block = rb_block_proc();
-
-      return rb_funcall(block, rb_intern("call"), 1, key);
+      return rb_yield(key);
     }
 
     return Qnil;
@@ -136,3 +139,85 @@ rbtree_is_empty(VALUE self)
 
   return size > 0 ? Qfalse : Qtrue;
 }
+
+
+#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)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+  EXTRACT_RBTREE(second, rbtree2);
+
+  gint self_size = g_tree_nnodes(rbtree->gtree);
+  gint second_size = g_tree_nnodes(rbtree2->gtree);
+
+  VALUE result = Qfalse;
+
+  if (self_size != second_size) {
+    goto ret;
+  }
+
+  if (self_size == 0) {
+    result = Qtrue;
+    goto ret;
+  }
+
+#ifdef HAS_GTREE_NODE
+  if (rbtree_compare_trees(rbtree, rbtree2)) {
+    result = Qtrue;
+  }
+#else
+  if (legacy_rbtree_compare(rbtree, rbtree2)) {
+    result = Qtrue;
+  }
+#endif
+
+  ret:
+  return result;
+}

data/ext/native_btree/iterators.c

@@ -1,5 +1,8 @@
 #include <common.h>
 
+#ifndef HAS_GTREE_NODE
+  #include <utils.h>
+#endif
 
 static gboolean
 foraech_callbac(gpointer a, gpointer b, gpointer data)
@@ -38,14 +41,22 @@ foraech_value_callbac(gpointer a, gpointer b, gpointer data)
 }
 
 
+static VALUE
+rbtree_enum_length(VALUE rbtree, VALUE args, VALUE eobj)
+{
+  return rbtree_size(rbtree);
+}
+
+
 VALUE
 rbtree_each(VALUE self)
 {
-  rb_need_block();
-  VALUE block = rb_block_proc();
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, rbtree_enum_length);
 
   EXTRACT_RBTREE_SELF(rbtree);
 
+  VALUE block = rb_block_proc();
+
   g_tree_foreach(rbtree->gtree, foraech_callbac, (gpointer) block);
 
   return self;
@@ -55,11 +66,12 @@ rbtree_each(VALUE self)
 VALUE
 rbtree_each_key(VALUE self)
 {
-  rb_need_block();
-  VALUE block = rb_block_proc();
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, rbtree_enum_length);
 
   EXTRACT_RBTREE_SELF(rbtree);
 
+  VALUE block = rb_block_proc();
+
   g_tree_foreach(rbtree->gtree, foraech_key_callbac, (gpointer) block);
 
   return self;
@@ -69,12 +81,50 @@ rbtree_each_key(VALUE self)
 VALUE
 rbtree_each_value(VALUE self)
 {
-  rb_need_block();
-  VALUE block = rb_block_proc();
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, rbtree_enum_length);
 
   EXTRACT_RBTREE_SELF(rbtree);
 
+  VALUE block = rb_block_proc();
+
   g_tree_foreach(rbtree->gtree, foraech_value_callbac, (gpointer) block);
 
   return self;
 }
+
+
+VALUE
+rbtree_reverse_each(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, rbtree_enum_length);
+
+#ifdef HAS_GTREE_NODE
+  GTreeNode *current = g_tree_node_last(rbtree->gtree);
+
+  VALUE key, val;
+  while (current) {
+    key = (VALUE) g_tree_node_key(current);
+    val = (VALUE) g_tree_node_value(current);
+
+    rb_yield_values(2, val, key);
+
+    current = g_tree_node_previous(current);
+  }
+#else
+  GPtrArray *buff = rbtree_to_ptr_array(rbtree);
+
+  VALUE key, val;
+  for (glong i = buff->len - 1; i > 0; i--) {
+    val = (VALUE) g_ptr_array_index(buff, i);
+    key = (VALUE) g_ptr_array_index(buff, --i);
+
+    rb_yield_values(2, val, key);
+  }
+
+  g_ptr_array_free(buff, TRUE);
+#endif
+
+  return self;
+}

data/ext/native_btree/native_btree.c

@@ -55,6 +55,8 @@ Init_native_btree()
   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);
+  rb_define_method(native_btree_class, "==", rbtree_equal, 1);
+  rb_define_method(native_btree_class, "reverse_each", rbtree_reverse_each, 0);
 
 #ifdef HAS_GTREE_NODE
   rb_define_method(native_btree_class, "select_before", rbtree_select_before, 1);

data/ext/native_btree/utils.c

@@ -0,0 +1,26 @@
+#include <utils.h>
+
+
+static gint
+to_ptr_array_cb(gpointer a, gpointer b, gpointer data)
+{
+  GPtrArray *buff = (GPtrArray *) data;
+
+  g_ptr_array_add(buff, a);
+  g_ptr_array_add(buff, b);
+
+  return FALSE;
+}
+
+
+GPtrArray*
+rbtree_to_ptr_array(const RBTree *rbtree)
+{
+  gint tree_size = g_tree_nnodes(rbtree->gtree);
+
+  GPtrArray *buff = g_ptr_array_sized_new(tree_size * 2);
+
+  g_tree_foreach(rbtree->gtree, to_ptr_array_cb, (gpointer) buff);
+
+  return buff;
+}

data/lib/native_btree/version.rb

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

data/spec/debug.rb

@@ -2,7 +2,10 @@
 
 require_relative "../lib/native_btree/native_btree"
 
+NativeBtree::Btree.include(Enumerable)
+
 tree = NativeBtree::Btree.new() {|a, b| a - b }
+tree2 = NativeBtree::Btree.new() {|a, b| a - b }
 
 GC.start
 
@@ -17,8 +20,6 @@ GC.start
 block = ->(key) { "#{key} is not found" }
 puts tree.delete(77, &block)
 
-tree2 = tree.filter!() { true }
-
 puts tree.to_h
 
 pr = tree.to_proc
@@ -27,15 +28,12 @@ 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
+(1..1000000).each do |i|
+  tree[i] = i+2
+  tree2[i] = i+2
+end
+
+puts tree == tree2
 
 GC.start
 

data/spec/native_btree_instance_spec.rb

@@ -186,5 +186,77 @@ RSpec.describe NativeBtree do
         expect(tree.empty?).to be true
       end
     end
+
+    describe '#== method' do
+      let(:tree2) do
+        described_class.new do |a, b|
+          a - b
+        end
+      end
+
+      it 'respond to' do
+        expect(tree).to respond_to(:==)
+      end
+
+      it 'return true if eql' do
+        tree[1] = 11
+        tree[2] = 22
+        tree[7] = 77
+
+        tree2[7] = 77
+        tree2[2] = 22
+        tree2[1] = 11
+
+        expect(tree).to eq tree2
+      end
+
+      it 'return false if not eql' do
+        tree[1] = 11
+        tree[2] = 22
+        tree[7] = 77
+        tree[8] = 88
+
+        tree2[7] = 77
+        tree2[2] = 22
+        tree2[1] = 11
+
+        expect(tree).not_to eq tree2
+      end
+
+      it 'return true if are empty trees' do
+        expect(tree).to eq tree2
+      end
+
+      it 'return false if one key is not eq' do
+        tree[5] = 11
+        tree[2] = 22
+        tree[7] = 77
+
+        tree2[7] = 77
+        tree2[2] = 22
+        tree2[1] = 11
+
+        expect(tree).not_to eq tree2
+      end
+
+      it 'return false if one value is not eq' do
+        tree[1] = 11
+        tree[2] = 22
+        tree[7] = 7
+
+        tree2[7] = 77
+        tree2[2] = 22
+        tree2[1] = 11
+
+        expect(tree).not_to eq tree2
+      end
+
+      it 'return false if any tree is empty' do
+        tree[1] = 11
+        tree[2] = 22
+
+        expect(tree).not_to eq tree2
+      end
+    end
   end
 end

data/spec/native_btree_iterators_spec.rb

@@ -45,6 +45,28 @@ RSpec.describe NativeBtree do
 
         expect(result).to eq(check)
       end
+
+      it 'return Enumerator without block' do
+        expect(tree.each).to be_kind_of(Enumerator)
+      end
+
+      it 'enumerator return correct values' do
+        tree[16] = 16
+        tree[0] = 0
+        tree[5] = 5
+        tree[-4] = -4
+        tree[7] = 7
+
+        check = [[-4, -4], [0, 0], [5, 5], [7, 7], [16, 16]]
+        result = []
+        enum = tree.each
+
+        loop do
+          result.push enum.next
+        end
+
+        expect(result).to eq(check)
+      end
     end
 
     describe "#each_key method" do
@@ -86,5 +108,43 @@ RSpec.describe NativeBtree do
         expect(result).to eq(check)
       end
     end
+
+    describe "#reverse_each method" do
+      it "respond to" do
+        expect(tree).to respond_to(:reverse_each)
+      end
+
+      it 'yield in to block value first' do
+        tree[2] = 22
+
+        value = nil
+        tree.reverse_each { |v| value = v }
+
+        expect(value).to be 22
+      end
+
+      it 'yield in to block key second' do
+        tree[2] = 22
+
+        key = nil
+        tree.reverse_each { |_v, k| key = k }
+
+        expect(key).to be 2
+      end
+
+      it 'yield ordered keys in reverse order' do
+        tree[16] = 16
+        tree[0] = 0
+        tree[5] = 5
+        tree[-4] = -4
+        tree[7] = 7
+
+        check = [16, 7, 5, 0, -4]
+        result = []
+        tree.reverse_each { |value| result << value }
+
+        expect(result).to eq(check)
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: native_btree
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Alexander Feodorov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-30 00:00:00.000000000 Z
+date: 2022-10-03 00:00:00.000000000 Z
 dependencies: []
 description: Ruby bindings to GTree balanced binary tree from GLib library.
 email:
@@ -31,18 +31,22 @@ files:
 - ext/native_btree/extconf_cmake.rb
 - ext/native_btree/glib2_68/CMakeLists.txt
 - ext/native_btree/glib2_68/additional_iterators.c
+- ext/native_btree/glib2_68/compare_trees.c
 - ext/native_btree/glib_module.c
 - ext/native_btree/include/common.h
 - ext/native_btree/include/comparator.h
+- ext/native_btree/include/compare_trees.h
 - ext/native_btree/include/glib_module.h
 - ext/native_btree/include/iterators.h
 - ext/native_btree/include/native_btree.h
 - ext/native_btree/include/rbtree_type.h
+- ext/native_btree/include/utils.h
 - ext/native_btree/instance.c
 - ext/native_btree/iterators.c
 - ext/native_btree/native_btree.c
 - ext/native_btree/rbtree_type.c
 - ext/native_btree/search.c
+- ext/native_btree/utils.c
 - lib/native_btree.rb
 - lib/native_btree/native_btree.bundle
 - lib/native_btree/version.rb