native_btree 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 398bae312c489bfe71fdee2f82499005e655097606a5537c38cfb122980b9f48
-  data.tar.gz: 492df9b7fc0585e0615da770a6c3fd3e2d02323d33c1d3cfecae46b882b881a3
+  metadata.gz: '05598705616620516787d5fd639f883270684c2d3981b1c04056bffd8f2b1849'
+  data.tar.gz: 1dcd3be4d1838e5b01bf7e38b2ca746004903550366f93e91922821feb3229ad
 SHA512:
-  metadata.gz: 634ac5f2eab6a8f9ebf9ed577d5cd2fcdca75fdb8e61f285b3e83e244204976bdef93981320ea101a621b2845cb9346099d61a94193eb5872d0f1480ad363f09
-  data.tar.gz: cf5f853401bdcab2d12088fe11c23cbde946e5a3542620d905e1acb59ede62522cbd293f65c7b10ca54f4a00737c9fe5485519c72358f185840fa8efbe81719b
+  metadata.gz: 98aa96b9820e879f94cc1f6682f9eb82f2139c7a81dd92f955db24167f9f8b384a80221b10ade4de7718c5fb56f94eea1f19fbb4360dc25c639bf1b4fd682230
+  data.tar.gz: f9410012b8ce525b4816377b8c8998e4ded903fca874e268a1a613a4759a5bf62051e4b55dec4259c15be5a301b1bb23978b0198b0e66d28c83e4f5f7954af1f

data/CHANGELOG.md

@@ -7,12 +7,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+* delete_if()
+* each method refactoring for Enumerator return type
+
+## [0.4.0] - 2022-09-16
+
+### Added
+
+* Native integer comparator
+* search_before()
+* search_after()
+* empty?()
+
+### Changed
+
+* Bugfixes
+
+## [0.3.0] - 2022-09-11
+
+### Added
+
+* to_proc()
+* empty?()
 * filter()
 * filter!()
-* each_key()
-* each_value()
 * select()
-* select!
+* select!()
 
 ## [0.2.1] - 2022-09-08
 

data/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.5)
 
 project(ruby-native-btree
 	LANGUAGES C
-	VERSION 0.2.1)
+	VERSION 0.4.0)
 
 include(CheckSymbolExists)
 
@@ -12,8 +12,8 @@ set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_EXTENSIONS ON)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 
-set(CMAKE_C_FLAGS_DEBUG " -O0 -ggdb3 -Wall -Wextra -Wpedantic -Wno-unused-parameter")
-set(CMAKE_C_FLAGS_RELEASE "-O3")
+set(CMAKE_C_FLAGS_DEBUG " -O0 -ggdb3 -Wall -Wextra -Wno-unused-parameter")
+set(CMAKE_C_FLAGS_RELEASE "-O3 -fomit-frame-pointer")
 set(CMAKE_C_FLAGS "-pipe -march=native")
 
 # Force -fPIC

data/Gemfile

@@ -9,10 +9,13 @@ group :development do
   gem 'awesome_print', '~> 1.9'
   gem 'debase', '~> 0.2', platforms: [:mri_26, :mri_27]
   gem 'pry', '~> 0.14'
+  gem 'ruby-debug-ide', '~> 0.7'
+  gem 'solargraph', '~> 0.46'
+end
+
+group :test do
+  gem 'rspec', '~> 3.11.0'
   gem 'rubocop', '~> 1.35.0'
   gem 'rubocop-rake', '~> 0.6.0'
   gem 'rubocop-rspec', '~> 2.12.1'
-  gem 'rspec', '~> 3.11.0'
-  gem 'ruby-debug-ide', '~> 0.7'
-  gem 'solargraph', '~> 0.46'
 end

data/README.md

@@ -11,7 +11,7 @@ In most cases it will behave same as Hash, but keys will be ordered by passed co
 
 ## Requirements
 
-* **CMake** build tool version **>= 3.14.0**
+* **CMake** build tool version **>= 3.5.0**, >= 3.14.0 will be cool.
 * `pkg-config` tool
 * **GLib** library
   * On Ubuntu run:
@@ -29,6 +29,7 @@ In most cases it will behave same as Hash, but keys will be ordered by passed co
 
 ## Basic usage
 
+### Example
 ```ruby
 require 'native_btree'
 
@@ -53,19 +54,66 @@ tree.height
 # 2
 ```
 
+### Native int comparator
+Will behave like an array with negative indexes)
+```ruby
+# Pass comparator for keys as block
+tree = NativeBtree::Btree.new(NativeBtree::Btree::INT_COMPARATOR)
+
+tree[-2] = 22
+tree[-1] = 1
+tree[0] = 100
+tree[5] = 55
+
+tree.to_a
+
+#[
+#    [0] [
+#        [0] -2,
+#        [1] 22
+#    ],
+#    [1] [
+#        [0] -1,
+#        [1] 1
+#    ],
+#    [2] [
+#        [0] 0,
+#        [1] 100
+#    ],
+#    [3] [
+#        [0] 5,
+#        [1] 55
+#    ]
+#]
+```
+
 ## API ref
 
 You must provide your own comparator for keys in `new` class method block.
 
-### Methods
+### API methods
+
+In general this class behave same as Hash
+
+Implemented methods:
 
 * `[]= (alias: set)`
 * `[] (alias: get)`
 * `delete`
 * `size`
 * `height`
-* `each`
+* `each` (NB! block is required) (NB! block is required)
 * `include?`
 * `clear`
 * `to_h`
 * `to_a`
+* `to_proc`
+* `filter` (alias: select)
+* `filter!` (alias: select!)
+* `each_value`
+* `each_key`
+* `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?`
+
+You can mix in the `Enumerable` module if additional methods are needed.

data/ext/native_btree/CMakeLists.txt

@@ -9,12 +9,22 @@ include_directories(include ${GLIB2_INCLUDE_DIRS})
 
 list(APPEND CMAKE_REQUIRED_LIBRARIES ${GLIB2_LDFLAGS})
 list(APPEND CMAKE_REQUIRED_INCLUDES ${GLIB2_INCLUDE_DIRS})
-check_symbol_exists(g_tree_remove_all "glib.h" HAVE_GTREE_REMOVE_ALL)
+check_symbol_exists(g_tree_remove_all "glib.h" HAS_GTREE_REMOVE_ALL)
+check_symbol_exists(g_tree_lookup_node "glib.h" HAS_GTREE_NODE)
 
-if(HAVE_GTREE_REMOVE_ALL)
-	add_compile_definitions(HAVE_GTREE_REMOVE_ALL)
+if(HAS_GTREE_REMOVE_ALL)
+	add_compile_definitions(HAS_GTREE_REMOVE_ALL)
 endif()
 
+if(HAS_GTREE_NODE)
+	add_compile_definitions(HAS_GTREE_NODE)
+	add_subdirectory("glib2_68")
+else()
+	message(WARNING
+		"Available GLib is not support direct node access.
+		Version < 2.68.
+		Additional iterators will not compile.")
+endif()
 
 add_library(${EXT_NAME}
 	SHARED
@@ -26,18 +36,30 @@ add_library(instance OBJECT instance.c)
 add_library(comparator OBJECT comparator.c)
 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(native_btree_interface
-	STATIC
+
+set(LIB_OBJECTS)
+list(APPEND LIB_OBJECTS
 	$<TARGET_OBJECTS:conversion>
 	$<TARGET_OBJECTS:iterators>
 	$<TARGET_OBJECTS:comparator>
 	$<TARGET_OBJECTS:instance>
 	$<TARGET_OBJECTS:constructor>
-	$<TARGET_OBJECTS:rbtree_type>)
+	$<TARGET_OBJECTS:rbtree_type>
+	$<TARGET_OBJECTS:search>
+	$<TARGET_OBJECTS:glib_module>)
+
+if(HAS_GTREE_NODE)
+	list(APPEND LIB_OBJECTS $<TARGET_OBJECTS:additional_iterators>)
+endif()
+
+add_library(native_btree_interface
+	STATIC
+	${LIB_OBJECTS})
 
 target_link_libraries(${EXT_NAME}
 	PRIVATE
 	native_btree_interface
 	${GLIB2_LDFLAGS})
-

data/ext/native_btree/comparator.c

@@ -11,3 +11,12 @@ rbtree_native_comparator(gconstpointer a, gconstpointer b, gpointer data)
 
   return compare_result;
 }
+
+gint
+rbtree_int_comparator(gconstpointer ra, gconstpointer rb, gpointer data)
+{
+  gint a = NUM2INT((VALUE) ra);
+  gint b = NUM2INT((VALUE) rb);
+
+  return a - b;
+}

data/ext/native_btree/constructor.c

@@ -1,19 +1,46 @@
-#include <constructor.h>
 #include <comparator.h>
 #include <rbtree_type.h>
+#include <stdbool.h>
 
-VALUE
-rbtree_initialize(VALUE self)
+inline static void
+init_rbtree(RBTree *rbtree, gushort flags)
 {
-  EXTRACT_RBTREE_SELF(rbtree);
+  bool flag_int_comparator = flags & RBTREE_FLAG_INT_COMPARATOR;
+  VALUE comparator = Qnil;
+  // NOTE: Possible segfault
+  GCompareDataFunc native_comparator = NULL;
+
+  if (flag_int_comparator) {
+    native_comparator = rbtree_int_comparator;
+  }
+  else {
+    rb_need_block();
+    comparator = rb_block_proc();
+    native_comparator = rbtree_native_comparator;
+  }
 
   rbtree->gtree = g_tree_new_with_data(
-    rbtree_native_comparator,
+    native_comparator,
     rbtree
   );
+  rbtree->comparator = comparator;
+  rbtree->flags = flags;
+}
+
+VALUE
+rbtree_initialize(int argc, VALUE* argv, VALUE self)
+{
+  rb_check_arity(argc, 0, 1);
+
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  gushort flags = 0;
+
+  if (argc > 0) {
+    flags = NUM2USHORT(argv[0]);
+  }
 
-  rb_need_block();
-  rbtree->comparator = rb_block_proc();
+  init_rbtree((RBTree *) rbtree, flags);
 
   return self;
 }

data/ext/native_btree/conversion.c

@@ -1,4 +1,5 @@
-#include <conversion.h>
+#include <common.h>
+
 
 static gboolean
 rbtree_to_h_callback(gpointer key, gpointer value, gpointer data)
@@ -52,3 +53,26 @@ rbtree_to_a(VALUE self)
 
   return array;
 }
+
+
+static VALUE
+to_proc_proc(RB_BLOCK_CALL_FUNC_ARGLIST(key, callback_arg))
+{
+  rb_check_arity(argc, 1, 1);
+  EXTRACT_RBTREE(callback_arg, rbtree);
+
+  VALUE value = (VALUE) g_tree_lookup(rbtree->gtree, (gconstpointer) key);
+
+  if (!value) {
+    return Qnil;
+  }
+
+  return value;
+}
+
+
+VALUE
+rbtree_to_proc(VALUE self)
+{
+  return rb_proc_new(to_proc_proc, self);
+}

data/ext/native_btree/glib2_68/CMakeLists.txt

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

data/ext/native_btree/glib2_68/additional_iterators.c

@@ -0,0 +1,84 @@
+#include <native_btree.h>
+#include <iterators.h>
+
+static void
+rbtree_gtree_foreach(GTreeNode *node, RBTreeStepFunction step_func, GTraverseFunc callback, gpointer data)
+{
+  while (node) {
+    callback(
+      g_tree_node_key(node),
+      g_tree_node_value(node),
+      data
+    );
+
+    node = step_func(node);
+  }
+}
+
+
+static int
+rbtree_traverse_insert(gpointer key, gpointer value, gpointer tree)
+{
+  g_tree_insert(tree, key, value);
+
+  return FALSE;
+}
+
+
+VALUE
+rbtree_select_before(VALUE self, VALUE target)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  VALUE new_tree = rbtree_clone_wrap(rbtree);
+
+  EXTRACT_RBTREE(new_tree, new_rbtree);
+
+  GTreeNode *target_node = g_tree_upper_bound(
+    rbtree->gtree,
+    (gconstpointer) target
+  );
+
+  target_node = g_tree_node_previous(target_node);
+
+  if (!target_node) {
+    return new_tree;
+  }
+
+  rbtree_gtree_foreach(
+    target_node,
+    g_tree_node_previous,
+    rbtree_traverse_insert,
+    (gpointer) new_rbtree->gtree
+  );
+
+  return new_tree;
+}
+
+
+VALUE
+rbtree_select_after(VALUE self, VALUE target)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  VALUE new_tree = rbtree_clone_wrap(rbtree);
+  EXTRACT_RBTREE(new_tree, new_rbtree);
+
+  GTreeNode *target_node = g_tree_lower_bound(
+    rbtree->gtree,
+    (gconstpointer) target
+  );
+
+  if (!target_node) {
+    return new_tree;
+  }
+
+  rbtree_gtree_foreach(
+    target_node,
+    g_tree_node_next,
+    rbtree_traverse_insert,
+    (gpointer) new_rbtree->gtree
+  );
+
+  return new_tree;
+}

data/ext/native_btree/glib_module.c

@@ -0,0 +1,45 @@
+#include <stdbool.h>
+#include <common.h>
+#include <glib_module.h>
+
+#define NATIVE_BTREE_GLIB_SUBMODULE "Glib"
+#define GLIB_MODULE_MAJOR_VERSION "MAJOR_VERSION"
+#define GLIB_MODULE_MINOR_VERSION "MINOR_VERSION"
+#define GLIB_MODULE_MICRO_VERSION "MICRO_VERSION"
+
+VALUE rbtree_glib_module;
+
+void
+rbtree_attach_module_glib()
+{
+  static bool initialized = FALSE;
+
+  if (initialized) {
+    return;
+  }
+
+  rbtree_glib_module = rb_define_module_under(
+    native_btree_module,
+    NATIVE_BTREE_GLIB_SUBMODULE
+  );
+
+  rb_define_const(
+    rbtree_glib_module,
+    GLIB_MODULE_MAJOR_VERSION,
+    INT2NUM(GLIB_MAJOR_VERSION)
+  );
+
+  rb_define_const(
+    rbtree_glib_module,
+    GLIB_MODULE_MINOR_VERSION,
+    INT2NUM(GLIB_MINOR_VERSION)
+  );
+
+  rb_define_const(
+    rbtree_glib_module,
+    GLIB_MODULE_MICRO_VERSION,
+    INT2NUM(GLIB_MICRO_VERSION)
+  );
+
+  initialized = TRUE;
+}

data/ext/native_btree/include/common.h

@@ -1,21 +1,19 @@
 #include <ruby.h>
 #include <glib.h>
+#include <rbtree_type.h>
+#include <native_btree.h>
+
 
 #ifndef _NATIVE_BTREE_COMMON_
 #define _NATIVE_BTREE_COMMON_
 
-#include <rbtree_type.h>
-
-#define NATIVE_BTREE_MODULE "NativeBtree"
-#define NATIVE_BTREE_CLASS "Btree"
-
 #define EXTRACT_RBTREE(from, to)                                               \
-  RBTree *to;                                                                  \
-  TypedData_Get_Struct(from, RBTree, &rbtree_type, rbtree)
+  const RBTree *to;                                                            \
+  TypedData_Get_Struct(from, RBTree, &rbtree_type, to)
 
 #define EXTRACT_RBTREE_SELF(to) EXTRACT_RBTREE(self, to)
 
-extern VALUE rbtree_class;
-extern VALUE rbtree_module;
+extern VALUE native_btree_class;
+extern VALUE native_btree_module;
 
 #endif //_NATIVE_BTREE_COMMON_

data/ext/native_btree/include/comparator.h

@@ -2,3 +2,6 @@
 
 gint
 rbtree_native_comparator(gconstpointer a, gconstpointer b, gpointer data);
+
+gint
+rbtree_int_comparator(gconstpointer a, gconstpointer b, gpointer data);

data/ext/native_btree/include/glib_module.h

@@ -0,0 +1,6 @@
+#include <ruby.h>
+
+extern VALUE rbtree_glib_module;
+
+void
+rbtree_attach_module_glib();

data/ext/native_btree/include/iterators.h

@@ -1,5 +1,13 @@
 #include <common.h>
 
+typedef struct {
+  const VALUE block;
+  const RBTree *tree;
+  gconstpointer something;
+} RBTreeSearchData;
 
-VALUE
-rbtree_each(VALUE self);
+#ifdef HAS_GTREE_NODE
+
+typedef GTreeNode *(RBTreeStepFunction) (GTreeNode *node);
+
+#endif

data/ext/native_btree/include/native_btree.h

@@ -1,9 +1,86 @@
 #ifndef _NATIVE_BTREE_
 
-#include <common.h>
-#include <constructor.h>
-#include <instance.h>
-#include <iterators.h>
-#include <conversion.h>
+#include <ruby.h>
+
+VALUE
+rbtree_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE
+rbtree_set(VALUE self, VALUE key, VALUE value);
+
+VALUE
+rbtree_get(VALUE self, VALUE key);
+
+VALUE
+rbtree_delete(VALUE self, VALUE key);
+
+VALUE
+rbtree_size(VALUE self);
+
+VALUE
+rbtree_height(VALUE self);
+
+VALUE
+rbtree_clear(VALUE self);
+
+VALUE
+rbtree_is_include(VALUE self, VALUE key);
+
+VALUE
+rbtree_each(VALUE self);
+
+VALUE
+rbtree_each_key(VALUE self);
+
+VALUE
+rbtree_each_value(VALUE self);
+
+VALUE
+rbtree_to_h(VALUE self);
+
+VALUE
+rbtree_to_a(VALUE self);
+
+VALUE
+rbtree_to_proc(VALUE self);
+
+VALUE
+rbtree_filter(VALUE self);
+
+VALUE
+rbtree_filter_bang(VALUE self);
+
+VALUE
+rbtree_is_empty(VALUE self);
+
+VALUE
+rbtree_select_before(VALUE self, VALUE target);
+
+VALUE
+rbtree_select_after(VALUE self, VALUE target);
+
+VALUE
+rbtree_select_between(VALUE self, VALUE from, VALUE to);
+
+VALUE
+rbtree_flatten(VALUE self);
+
+VALUE
+rbtree_delete_if(VALUE self);
+
+VALUE
+rbtree_has_key(VALUE self, VALUE key);
+
+VALUE
+rbtree_has_value(VALUE self, VALUE value);
+
+VALUE
+rbtree_eql(VALUE self, VALUE tree);
+
+VALUE
+rbtree_keys(VALUE self);
+
+VALUE
+rbtree_values(VALUE self);
 
 #endif // _NATIVE_BTREE_

data/ext/native_btree/include/rbtree_type.h

@@ -3,20 +3,27 @@
 
 #include <common.h>
 
-#define NATIVE_TYPE_NAME "native_btree"
+#define RBTREE_NATIVE_TYPE_NAME "native_btree"
+#define RBTREE_FLAG_INT_COMPARATOR 0b10000000
 
 extern const rb_data_type_t rbtree_type;
 
+typedef struct _RBTree RBTree;
+
 VALUE
 rbtree_alloc(VALUE self);
 
+VALUE
+rbtree_clone_wrap(const RBTree *orig);
+
 /**
  * Internal native instance
  */
-typedef struct _RBTree
+struct _RBTree
 {
   GTree *gtree;
   VALUE comparator;
-} RBTree;
+  gushort flags;
+};
 
 #endif //_RBTREE_TYPE_

data/ext/native_btree/instance.c

@@ -1,6 +1,7 @@
-#include <instance.h>
+#include <common.h>
 
-#ifndef HAVE_GTREE_REMOVE_ALL
+
+#ifndef HAS_GTREE_REMOVE_ALL
 
 static gboolean
 rbtree_remove_node(gpointer key, gpointer val, gpointer data) {
@@ -101,7 +102,7 @@ rbtree_clear(VALUE self)
 {
   EXTRACT_RBTREE_SELF(rbtree);
 
-  #ifdef HAVE_GTREE_REMOVE_ALL
+  #ifdef HAS_GTREE_REMOVE_ALL
     g_tree_remove_all(rbtree->gtree);
   #else
     g_tree_foreach(rbtree->gtree, rbtree_remove_node, (gpointer) rbtree);
@@ -124,3 +125,14 @@ rbtree_is_include(VALUE self, VALUE key)
 
   return Qtrue;
 }
+
+
+VALUE
+rbtree_is_empty(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  gint size = g_tree_nnodes(rbtree->gtree);
+
+  return size > 0 ? Qfalse : Qtrue;
+}