librtree 0.8.0 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35028e6e74b4682479656b89086bf47fb42a43bd09ce7c9070df53adffcf4cec
-  data.tar.gz: d58480430dada176e90f0e42e316b82be990fc4c414a993ce627a1b4b11ba707
+  metadata.gz: c9abe4061328dd6a2b8b9f1c00a38f76332a0f0a188af7a5d3e6f1125eab346e
+  data.tar.gz: 4029ed06803576cc76ec7bd8d3d1eb9a2d628da9fd982d04e80b643177fce244
 SHA512:
-  metadata.gz: 5bcb8f2b41ccab397f5accef4846912e9932dd07fa540c020c114a079ed9252296a8324ae647452170a445babcceb03984f258d053eb55d45566ad1b6da03d67
-  data.tar.gz: 8de9c0cbcfde749d139590c81d41b55bc78c73aa826cb5385f65e9b4a1c36e8a08abc3e1f5b751a082f33fadb3e56001dd8a391f93c6314f4728e5ec772454ab
+  metadata.gz: f6b7005f8ec37a45ff8ee894de5642eb969a26af72ad9fa330aeeae1c746447d786b309301e84116de595bed40f70bef8683fbd9a969b2b9c2cabb32e5c4d374
+  data.tar.gz: c4c6641e2cdfd9f14f21b50047fe2f304ab1446eb643a0f6cd3acd594fbc37469cf71c78434daa82b759bdb2741a1f887add7809d72c7bbc3f39886aee3ecc9b

data/ext/rtree/extconf.rb

@@ -20,11 +20,9 @@ puts LIB_DIRS.inspect
 
 dir_config('librtree', HEADER_DIRS, LIB_DIRS)
 
-abort 'missing csv.h' unless find_header('csv.h')
 abort 'missing jansson.h' unless find_header('jansson.h')
 abort 'missing rtree.h' unless find_header('rtree.h')
 
-abort "libcsv is missing" unless find_library('csv', 'csv_init')
 abort "libjansson is missing" unless find_library('jansson', 'json_pack')
 abort "librtree is missing" unless find_library('rtree', 'rtree_new')
 

data/ext/rtree/rtree.c

@@ -1,35 +1,48 @@
 #include <ruby.h>
 #include <ruby/io.h>
+#include <ruby/version.h>
 
 #include <rtree.h>
+#include <rtree/package.h>
 
 #include <errno.h>
 #include <stdint.h>
 
-typedef struct
-{
-  void *rtree;
-} lrt_t;
 
-static void lrt_free(void *p)
+static void lrt_dfree(void *p)
 {
-  lrt_t *lrt = p;
-
-  if (lrt->rtree)
-    {
-      rtree_destroy(lrt->rtree);
-      lrt->rtree = NULL;
-    }
+  rtree_destroy((rtree_t*)p);
 }
 
-static VALUE lrt_alloc(VALUE cls)
+static size_t lrt_dsize(const void *p)
 {
-  lrt_t *lrt;
-  VALUE obj = Data_Make_Struct(cls, lrt_t, NULL, lrt_free, lrt);
+  return rtree_bytes((const rtree_t*)p);
+}
 
-  lrt->rtree = NULL;
+static rb_data_type_t type = {
+  .wrap_struct_name = "rtree-wrap",
+  .function = {
+    .dmark = NULL,
+    .dfree = lrt_dfree,
+    .dsize = lrt_dsize,
+#if RUBY_API_VERSION_CODE < 20700
+    .reserved = { NULL, NULL }
+#else
+    .dcompact = NULL,
+    .reserved = { NULL }
+#endif
+  },
+  .parent = NULL,
+  .data = NULL,
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
 
-  return obj;
+static VALUE lrt_alloc(VALUE cls)
+{
+  rtree_t *rtree;;
+  if ((rtree = rtree_alloc()) == NULL)
+    rb_raise(rb_eNoMemError, "failed to alloc rtree");
+  return TypedData_Wrap_Struct(cls, &type, rtree);
 }
 
 static VALUE lrt_init(VALUE self, VALUE dim_obj, VALUE flags_obj)
@@ -40,31 +53,28 @@ static VALUE lrt_init(VALUE self, VALUE dim_obj, VALUE flags_obj)
   Check_Type(dim_obj, T_FIXNUM);
   state_flags_t flags = FIX2UINT(flags_obj);
 
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
 
-  if ((lrt->rtree = rtree_new(dim, flags)) == NULL)
-    rb_raise(rb_eNoMemError, "failed to create rtree");
+  if ((rtree_init(rtree, dim, flags)) != 0)
+    rb_raise(rb_eNoMemError, "failed to init rtree");
 
   return self;
 }
 
 static VALUE lrt_release(VALUE self)
 {
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
-
-  free(lrt->rtree);
-
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
+  rtree_destroy(rtree);
   return self;
 }
 
 static VALUE lrt_height(VALUE self)
 {
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
-
-  return INT2NUM(rtree_height(lrt->rtree));
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
+  return INT2NUM(rtree_height(rtree));
 }
 
 static VALUE lrt_add_rect(VALUE self, VALUE id_obj, VALUE coord_obj)
@@ -72,11 +82,9 @@ static VALUE lrt_add_rect(VALUE self, VALUE id_obj, VALUE coord_obj)
   Check_Type(coord_obj, T_ARRAY);
   Check_Type(id_obj, T_FIXNUM);
 
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
 
-  rtree_t
-    *rtree = lrt->rtree;
   rtree_id_t
     id = FIX2ULONG(id_obj);
   size_t
@@ -132,11 +140,10 @@ static VALUE lrt_update(VALUE self)
   if (!rb_block_given_p())
     rb_raise(rb_eArgError, "Expected block");
 
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
-  rtree_t *rtree = lrt->rtree;
-  size_t len = 2 * state_dims(rtree->state);
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
 
+  size_t len = 2 * state_dims(rtree->state);
   int err = rtree_update(rtree, update_cb, &len);
 
   if (err != 0)
@@ -169,11 +176,9 @@ static VALUE lrt_search(VALUE self, VALUE coord_obj)
 
   Check_Type(coord_obj, T_ARRAY);
 
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
 
-  rtree_t
-    *rtree = lrt->rtree;
   size_t
     len = RARRAY_LEN(coord_obj),
     dim = state_dims(rtree->state);
@@ -215,12 +220,7 @@ static VALUE deserialise(VALUE cls, VALUE io_obj, deserialise_t *f)
         rb_raise(rb_eRuntimeError, "Failed read from stream");
     }
 
-  lrt_t *lrt;
-  VALUE obj = Data_Make_Struct(cls, lrt_t, NULL, lrt_free, lrt);
-
-  lrt->rtree = rtree;
-
-  return obj;
+  return TypedData_Wrap_Struct(cls, &type, rtree);
 }
 
 static VALUE lrt_json_read(VALUE cls, VALUE io_obj)
@@ -259,12 +259,7 @@ static VALUE lrt_csv_read(VALUE cls,
         rb_raise(rb_eRuntimeError, "Failed read from stream");
     }
 
-  lrt_t *lrt;
-  VALUE obj = Data_Make_Struct(cls, lrt_t, NULL, lrt_free, lrt);
-
-  lrt->rtree = rtree;
-
-  return obj;
+  return TypedData_Wrap_Struct(cls, &type, rtree);
 }
 
 /* serialisation */
@@ -281,9 +276,8 @@ static VALUE serialise(VALUE self, VALUE io_obj, serialise_t *f)
   rb_io_check_writable(io);
   FILE *fp = rb_io_stdio_file(io);
 
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
-  rtree_t *rtree = lrt->rtree;
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
 
   int err = f(rtree, fp);
   if (err != 0)
@@ -304,12 +298,10 @@ static VALUE lrt_bsrt_write(VALUE self, VALUE io_obj)
 
 static VALUE lrt_identical(VALUE self, VALUE other)
 {
-  lrt_t *lrt_self, *lrt_other;
-  Data_Get_Struct(self, lrt_t, lrt_self);
-  Data_Get_Struct(other, lrt_t, lrt_other);
-  rtree_t
-    *rtree_self = lrt_self->rtree,
-    *rtree_other = lrt_other->rtree;
+  rtree_t *rtree_self, *rtree_other;
+
+  TypedData_Get_Struct(self, rtree_t, &type, rtree_self);
+  TypedData_Get_Struct(other, rtree_t, &type, rtree_other);
 
   if (rtree_identical(rtree_self, rtree_other))
     return Qtrue;
@@ -319,12 +311,12 @@ static VALUE lrt_identical(VALUE self, VALUE other)
 
 static VALUE lrt_clone(VALUE self)
 {
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
   rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
 
+  rtree_t *clone;
   errno = 0;
-  if ((rtree = rtree_clone(lrt->rtree)) == NULL)
+  if ((clone = rtree_clone(rtree)) == NULL)
     {
       if (errno)
         rb_sys_fail(__func__);
@@ -332,13 +324,73 @@ static VALUE lrt_clone(VALUE self)
         rb_raise(rb_eRuntimeError, "Failed clone");
     }
 
-  lrt_t *lrt_cloned;
-  VALUE cls = CLASS_OF(self);
-  VALUE obj = Data_Make_Struct(cls, lrt_t, NULL, lrt_free, lrt_cloned);
+  return TypedData_Wrap_Struct(CLASS_OF(self), &type, clone);
+}
+
+static VALUE state_size_access(VALUE self, size_t (*f)(const state_t*))
+{
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
+  return INT2NUM(f(rtree->state));
+}
+
+static VALUE lrt_dim(VALUE self)
+{
+  return state_size_access(self, state_dims);
+}
+
+static VALUE lrt_page_size(VALUE self)
+{
+  return state_size_access(self, state_page_size);
+}
+
+static VALUE lrt_node_size(VALUE self)
+{
+  return state_size_access(self, state_node_size);
+}
 
-  lrt_cloned->rtree = rtree;
+static VALUE lrt_rect_size(VALUE self)
+{
+  return state_size_access(self, state_rect_size);
+}
+
+static VALUE lrt_branch_size(VALUE self)
+{
+  return state_size_access(self, state_branch_size);
+}
+
+static VALUE lrt_branching_factor(VALUE self)
+{
+  return state_size_access(self, state_branching_factor);
+}
 
-  return obj;
+static VALUE lrt_unit_sphere_volume(VALUE self)
+{
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
+  return DBL2NUM(state_unit_sphere_volume(rtree->state));
+}
+
+static VALUE lrt_size(VALUE self)
+{
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
+  return INT2NUM(rtree_bytes(rtree));
+}
+
+static VALUE lrt_version(VALUE self)
+{
+  return rb_str_new_cstr(rtree_package_version);
+}
+
+static VALUE lrt_bugreport(VALUE self)
+{
+  return rb_str_new_cstr(rtree_package_bugreport);
+}
+
+static VALUE lrt_url(VALUE self)
+{
+  return rb_str_new_cstr(rtree_package_url);
 }
 
 void Init_rtree(void)
@@ -356,6 +408,17 @@ void Init_rtree(void)
   rb_define_method(cls, "json_write", lrt_json_write, 1);
   rb_define_method(cls, "bsrt_write", lrt_bsrt_write, 1);
   rb_define_method(cls, "eq?", lrt_identical, 1);
+  rb_define_method(cls, "dim", lrt_dim, 0);
+  rb_define_method(cls, "size", lrt_size, 0);
+  rb_define_method(cls, "page_size", lrt_page_size, 0);
+  rb_define_method(cls, "node_size", lrt_node_size, 0);
+  rb_define_method(cls, "rect_size", lrt_rect_size, 0);
+  rb_define_method(cls, "branch_size", lrt_branch_size, 0);
+  rb_define_method(cls, "branching_factor", lrt_branching_factor, 0);
+  rb_define_method(cls, "unit_sphere_volume", lrt_unit_sphere_volume, 0);
+  rb_define_singleton_method(cls, "version", lrt_version, 0);
+  rb_define_singleton_method(cls, "bugreport", lrt_bugreport, 0);
+  rb_define_singleton_method(cls, "url", lrt_url, 0);
   rb_define_singleton_method(cls, "json_read", lrt_json_read, 1);
   rb_define_singleton_method(cls, "bsrt_read", lrt_bsrt_read, 1);
   rb_define_singleton_method(cls, "csv_read", lrt_csv_read, 3);

data/lib/rtree.rb

@@ -1,4 +1,4 @@
-# The C extension
+# The Ruby/C interface, which is not documented in YARD.
 class RTreeC ; end
 
 # @author RTree J. J. Green
@@ -7,6 +7,12 @@ class RTreeC ; end
 # {http://soliton.vm.bytemark.co.uk/pub/jjg/en/code/librtree librtree}
 # implementing the R-tree spatial index of Guttman-Green.
 #
+# Use
+#
+#    require 'rtree'
+#
+# to make the {RTree} class available.
+#
 # Given a set or rectangles (or higher dimensional cuboids) and their
 # associated ids, one can build an {RTree} using the {.csv_read} class
 # method or repeated calls to the {#add_rect} instance method.  The
@@ -43,7 +49,7 @@ class RTreeC ; end
 # it as payload. In particular, the value may be non-unique and may be zero.
 # One should note that the id type used internally by the library is
 # determined at compile-time (with the RTREE_ID_TYPE variable) and by
-# default this is a 32-bit unsigned integer.
+# default this is a 64-bit unsigned integer.
 #
 class RTree < RTreeC
 
@@ -93,6 +99,11 @@ class RTree < RTreeC
     # @param split [:linear, :quadratic] See {#initialize}
     # @param node_page [Integer] See {#initialize}
     # @return [RTree] the newly built RTree
+    # @note The CSV file (without header) should have the id in the
+    #   first column, then twice as many floats as the dimension.
+    #   Extra columns may be present and will be ignored (this
+    #   useful feature is the reason that the dimension is a required
+    #   argument).
     def csv_read(io, dim, split: :quadratic, node_page: 0)
       flags = split_flag(split) | node_page_flag(node_page)
       super(io, dim, flags)
@@ -109,6 +120,21 @@ class RTree < RTreeC
       end
     end
 
+    # @return [Array<Integer>] version of librtree
+    def version
+      @version ||= super.split('.').map(&:to_i)
+    end
+
+    # @return [String] email address for librtree bug reports
+    def bugreport
+      super
+    end
+
+    # @return [String] librtree homepage
+    def url
+      super
+    end
+
     # @!visibility private
     def split_flag(split)
       case split
@@ -222,7 +248,7 @@ class RTree < RTreeC
   #   is much faster than rebuilding the R-tree; in this Ruby interface
   #   the callback must convert C floats to Ruby, yield them to the
   #   block and then convert the returned Ruby Floats to C; so we would
-  #   expect that it loses much of its competetive advantage when
+  #   expect that it loses much of its competitive advantage when
   #   compared to an R-tree rebuild.
   def update!
     super
@@ -241,7 +267,7 @@ class RTree < RTreeC
   end
 
   # Serialise to JSON stream
-  # @param io [IO] a writeable stream
+  # @param io [IO] a writable stream
   # @return [self]
   # @see .json_read
   # @example Write to file
@@ -251,7 +277,7 @@ class RTree < RTreeC
   end
 
   # Serialise to BSRT (binary serialised R-tree) stream
-  # @param io [IO] a writeable stream
+  # @param io [IO] a writable stream
   # @return [self]
   # @see .bsrt_read
   # @example Write to file
@@ -281,7 +307,7 @@ class RTree < RTreeC
   end
 
   # Equality of RTrees.  This is a rather strict equality,
-  # not only must the tree have the same rectangkes, they
+  # not only must the tree have the same rectangles, they
   # must be in the same order. Certainly {#clone} will produce
   # an instance which is equal in this sense.
   # @return [Boolean] true if the instances are identical
@@ -291,6 +317,52 @@ class RTree < RTreeC
 
   alias_method(:==, :eq?)
 
+  # @return [Integer] the dimension of the R-tree
+  def dim
+    super
+  end
+
+  # @return [Integer] the total bytes allocated for the instance
+  # @note This method traverses the entire tree summing the
+  #   contributions for each node (rather than maintaining a
+  #   running count).  Performance-minded users may wish to
+  #   cache this value (invalidating the cache when calling
+  #   {#add_rect} of course).
+  def size
+    super
+  end
+
+  # @return [Integer] the bytes in a page of memory
+  def page_size
+    super
+  end
+
+  # @return [Integer] the size in bytes of a node
+  def node_size
+    super
+  end
+
+  # @return [Integer] the size in bytes of a rectangle
+  def rect_size
+    super
+  end
+
+  # @return [Integer] the size in bytes of a branch
+  def branch_size
+    super
+  end
+
+  # @return [Integer] the number of branches from each node
+  def branching_factor
+    super
+  end
+
+  # @return [Float] the volume of the unit sphere in the R-tree's
+  #   dimension
+  def unit_sphere_volume
+    super
+  end
+
   private
 
   attr_reader :split, :node_page
@@ -323,6 +395,7 @@ class RTree < RTreeC
     result
   end
 
+
 end
 
 require 'rtree/rtree'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: librtree
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.5
 platform: ruby
 authors:
 - J.J. Green
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-17 00:00:00.000000000 Z
+date: 2021-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,8 +95,8 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1'
 description: |
-  A Ruby native extension for librtree implementing the R-tree
-  spatial-index of Guttman-Green.
+  A Ruby extension implementing the R-tree spatial-index of
+  Guttman-Green.
 email: j.j.green@gmx.co.uk
 executables: []
 extensions:
@@ -119,14 +119,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- The librtree library
+- The librtree library (1.0.5 or later)
 rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4