librtree 0.9.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ea7105c3090ca70b99cec081b01ed6f46490208e79ee6ecdaf9045b827280ca
-  data.tar.gz: 7071f07e2e9ced00f34d48764e229057a9b69cec6e57b003babc27b5577e5372
+  metadata.gz: f4cc8665ba0560f3258c4857556efa67195cc699915adc9d2297a78d0f41c3cc
+  data.tar.gz: 1b20b6f067a37c4f3265c9f9d7084d4736a8367aa05613e075a4589ba1dc0259
 SHA512:
-  metadata.gz: f96d9eb0c8d21ef03a8d716f544ec34d84dabe4f598e606af99184e7cfb951c5a80f55e058b0d20ebafd4d2f173bae76bf230fac8489d8e71cbbe2a57c5170fa
-  data.tar.gz: cd2d89976e36b6c0aadf7b0d95c823c4f39869d480886746aa8e1f2a402bdaf7e9f7e0b87695beacd75aad7655bfeaa8b65bca11fed80e9a15464de854da3a94
+  metadata.gz: c0ae30faf7cba617f9ab96be3d9ec5325505a9b97b9591fc64bcbd8e2de327def4bca47386992c80f6c1d6021211cdd660ca10cfa1ed8f75d82b67cc6a33f1a0
+  data.tar.gz: d561ecb375d69cb78a1f2681c43e430692c4f191bc9555cd317e8b0b76d726740154aa2befb6bdc9f35aa56adf0686c5030593ac81fff9fc3ce167ecdd9eeef4

data/CHANGELOG.md

@@ -0,0 +1,72 @@
+Changelog
+---------
+
+### 1.0.0, 24-02-2023
+
+- The `librtree` library is no longer a requirement: the code
+  for the library is it is embedded in the gem itself
+
+### 0.9.1, 21-01-2023
+
+- Tidying
+- Fix warning "undefining the allocator of T_DATA class" on
+  Ruby 3,2
+- No functional changes
+
+### 0.9.0, 07-11-2021
+
+- Code reorganisation
+- RuboCop style fixes
+- No functional changes
+
+### 0.8.9, 24-08-2021
+
+- Unset `O_NONBLOCK` on `IO.pipe` readers, to allow the gem to
+  work with Ruby 3
+
+### 0.8.8, 14-07-2021
+
+- De-nest C base-class for neater documentation
+- Adopt "standard" naming-convention for the benfit of Yard
+  introspection
+- No functional changes
+
+### 0.8.7, 24-06-2021
+
+- Added the `#postscript` method, for plotting
+
+### 0.8.6, 17-06-2021
+
+- Support for the Greene-split of librtree 1.0.6
+
+### 0.8.5, 13-06-2021
+
+- Removed check for `libcsv`, needs librtee version 1.0.5
+
+### 0.8.4, 24-05-2021
+
+- Replace deprecated `Data_*_Struct` API functions
+- Implement the `version`, `bugreport`, `url` class methods
+- Add `dsize` to the base `rb_data_type_t` struct (using a call to
+  the C `rtree_bytes` function introduced in librtree 1.0.3)
+- Add the `#size` methods using the same C function
+
+### 0.8.3, 23-05-2021
+
+- Fix a memory leak
+- C code uses `Data_Wrap_Struct` rather than `Data_Make_Struct`,
+  this needs librtree version at least 1.0.2
+
+### 0.8.2, 22-05-2021
+
+- Added a number of read-accessors for the R-tree state
+
+### 0.8.1, 19-05-2021
+
+- Added changelog
+- Updated user documentation
+- No code changes
+
+### 0.8.0, 17-05-2021
+
+- First public release

data/COPYING

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 J.J. Green
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+librtree-ruby
+-------------
+
+A Ruby native extension for [librtree][3] implementing the R-tree
+spatial index of Guttman-Green.
+
+
+### Installing dependencies
+
+Just [jansson][1]: this common library may be in your operating-system's
+repositories. On Debian, Ubuntu and derivatives:
+
+    apt-get install libjansson-dev
+
+On RedHat, CentOS:
+
+    yum install jansson-devel
+
+On OSX:
+
+    brew install jansson
+
+One does not need to install `librtree` itself, the library-code is
+embedded within the gem (as of version 1.0.0).
+
+
+### Install the Gem
+
+Add
+
+    gem 'librtree'
+
+to your project's `Gemfile` and run `bundle install`.
+
+
+### Use the RTree class
+
+In your Ruby code
+
+    require 'rtree'
+
+will import the **RTree** class, its usage is described [here][5].
+
+
+### Development setup
+
+This is only needed if you want work on the extension, not for
+a Gem install.
+
+First install the dependencies and [librtree][3] as above.  Then
+clone the repository and install the extension's Ruby dependencies,
+there are several ways to do this.
+
+If using [rbenv][4], then first set a local version of Ruby to
+use, then install the gems into your local cache
+
+    rbenv local 2.7.0
+    bundle install
+
+The repository's `.gitignore` ignores **rbenv**'s `.ruby-version`
+file, since we don't want to mandate a particular Ruby version
+for the package.
+
+If not using **rbenv** then just
+
+    bundle install
+
+should attempt to install the gems into your system location, which
+will typically require `sudo`.  If you don't want to (or cannot) do
+this, then
+
+    bundle install --path vendor/bundle
+
+will install into `vendor` and set the location in `.bundle/config`,
+both of these are ignored by the repository's Git configuration.
+
+Finally, you should be in a position to compile the package and
+run the tests:
+
+    bundle exec rake compile
+    bundle exec rake spec
+
+[1]: http://www.digip.org/jansson/
+[3]: http://soliton.vm.bytemark.co.uk/pub/jjg/en/code/librtree/
+[4]: https://github.com/rbenv/rbenv
+[5]: https://www.rubydoc.info/gems/librtree/RTree

data/ext/rtree/extconf.rb

@@ -1,27 +1,45 @@
 require 'mkmf'
 
-$CFLAGS << ' -std=c99'
+$VPATH << "$(srcdir)/lib"
+$srcs =
+  Dir.glob("#{$srcdir}/{,lib/}*.c")
+    .map { |path| File.basename(path) }
+    .sort
 
-INCLUDEDIR = RbConfig::CONFIG['includedir']
-HEADER_DIRS = [
-  '/usr/local/include',
-  INCLUDEDIR,
-  '/usr/include',
-]
+append_cppflags('-I$(srcdir)/lib')
+append_cppflags('-DHAVE_CONFIG_H')
 
-LIBDIR = RbConfig::CONFIG['libdir']
-LIB_DIRS = [
-  '/usr/local/lib',
-  LIBDIR,
-  '/usr/lib'
-]
+check_sizeof('rtree_coord_t', 'rtree/types.h')
+check_sizeof('rtree_id_t', 'rtree/types.h')
 
-dir_config('librtree', HEADER_DIRS, LIB_DIRS)
+if have_header('endian.h') ||
+   have_header('sys/endian.h') ||
+   have_header('libkern/OSByteOrder.h') ||
+   have_header('winsock2.h')
+then
+  append_cflags("-DWITH_BSRT")
+else
+  warn('cannot determine endianness, no BSRT support')
+end
 
-abort 'missing jansson.h' unless find_header('jansson.h')
-abort 'missing rtree.h' unless find_header('rtree.h')
+if have_header('jansson.h') &&
+   have_library('jansson', 'json_pack')
+then
+  append_cflags("-DWITH_JSON")
+else
+  warn('cannot find jansson, no JSON support')
+end
 
-abort 'libjansson is missing' unless find_library('jansson', 'json_pack')
-abort 'librtree is missing' unless find_library('rtree', 'rtree_new')
+unless have_header('unistd.h') &&
+       (
+         have_func('sysconf', 'unistd.h') ||
+         have_func('getpagesize', 'unistd.h')
+       )
+then
+  warn('cannot find page-size functions, will guess')
+end
 
-create_makefile 'rtree/rtree'
+have_header('features.h')
+
+create_header('config.h')
+create_makefile("rtree")

data/ext/rtree/lib/bindex.c

@@ -0,0 +1,157 @@
+/*
+  An array of binary values which are to be used as indexes
+  for an array; so we can store each value in a bit, but the
+  functions return size_t (since the array-index type)
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "bindex.h"
+#include "rtree/error.h"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <stdalign.h>
+#include <string.h>
+
+#define UL_BYTES sizeof(unsigned long)
+#define UL_BITS (UL_BYTES << 3)
+
+/* see note on branch_sizeof in branch.c */
+
+static size_t bindex_sizeof(size_t n)
+{
+  const size_t s = offsetof(bindex_t, word) + n * UL_BYTES;
+  return ((s - 1) / alignof(bindex_t) + 1) * alignof(bindex_t);
+}
+
+bindex_t* bindex_new(size_t n)
+{
+  size_t k = n / UL_BITS + 1;
+  bindex_t *bindex;
+
+  if ((bindex = malloc(bindex_sizeof(k))) != NULL)
+    {
+      bindex->n = n;
+      memset(bindex->word, 0, k * UL_BYTES);
+      return bindex;
+    }
+
+  return NULL;
+}
+
+void bindex_destroy(bindex_t *bindex)
+{
+  free(bindex);
+}
+
+static size_t first_unset(const unsigned long *words, size_t n_bits)
+{
+  size_t n_words = n_bits / UL_BITS + 1;
+
+  for (size_t j = 0 ; j < n_words ; j++)
+    {
+      unsigned long word = ~words[j];
+
+      if (word)
+        {
+
+#ifdef HAVE___BUILTIN_CTZL
+
+          return j * UL_BITS + __builtin_ctzl(word);
+
+#else
+
+          for (size_t k = 0 ; k < UL_BITS ; k++)
+            {
+              if (1UL & (word >> k))
+                return j * UL_BITS + k;
+            }
+#endif
+        }
+    }
+
+  return n_bits;
+}
+
+static size_t next_unset(const unsigned long *words, size_t n_bits, size_t i)
+{
+  if (i < n_bits)
+    {
+      size_t
+        j0 = i / UL_BITS,
+        k0 = i % UL_BITS;
+      unsigned long word;
+
+#ifdef HAVE___BUILTIN_CTZL
+
+      if ((word = ~words[j0] >> k0) != 0UL)
+        return j0 * UL_BITS + __builtin_ctzl(word) + k0;
+
+#else
+
+      if ((word = ~words[j0]) != 0UL)
+        {
+          for (size_t k = k0 ; k < UL_BITS ; k++)
+            {
+              if (1UL & (word >> k))
+                return j0 * UL_BITS + k;
+            }
+        }
+
+#endif
+
+      size_t j1 = j0 + 1;
+
+      return first_unset(words + j1, n_bits - j1 * UL_BITS) + j1 * UL_BITS;
+    }
+
+  return n_bits;
+}
+
+size_t bindex_first_unset(const bindex_t *bindex)
+{
+  return first_unset(bindex->word, bindex->n);
+}
+
+size_t bindex_next_unset(const bindex_t *bindex, size_t i)
+{
+  return next_unset(bindex->word, bindex->n, i);
+}
+
+size_t bindex_get(const bindex_t *bindex, size_t i)
+{
+  if (i >= bindex->n)
+    {
+      errno = EDOM;
+      return 0;
+    }
+
+  size_t
+    j = i / UL_BITS,
+    k = i % UL_BITS;
+
+  return 1UL & (bindex->word[j] >> k);
+}
+
+int bindex_set(bindex_t *bindex, size_t i, size_t v)
+{
+  if (v > 1)
+    return RTREE_ERR_INVAL;
+
+  if (i >= bindex->n)
+    return RTREE_ERR_DOM;
+
+  size_t
+    j = i / UL_BITS,
+    k = i % UL_BITS;
+
+  if (v)
+    bindex->word[j] |= (1UL << k);
+  else
+    bindex->word[j] &= ~(1UL << k);
+
+  return 0;
+}

data/ext/rtree/lib/bindex.h

@@ -0,0 +1,31 @@
+/*
+  bindex.h
+  Copyright (c) J.J. Green 2020
+*/
+
+#ifndef BINDEX_H
+#define BINDEX_H
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stddef.h>
+
+typedef struct
+{
+  size_t n;
+  unsigned long word[];
+} bindex_t;
+
+bindex_t* bindex_new(size_t);
+void bindex_destroy(bindex_t*);
+
+size_t bindex_get(const bindex_t*, size_t);
+int bindex_set(bindex_t*, size_t, size_t);
+
+size_t bindex_first_unset(const bindex_t*);
+size_t bindex_next_unset(const bindex_t*, size_t);
+
+
+#endif

data/ext/rtree/lib/bounds.h

@@ -0,0 +1,21 @@
+/*
+  bounds.h
+  Copyright (c) J.J. Green 2022
+*/
+
+#ifndef BOUNDS_H
+#define BOUNDS_H
+
+#ifndef RTREE_DIMS_MAX
+#define RTREE_DIMS_MAX 256
+#endif
+
+#ifndef RTREE_LEVELS_MAX
+#define RTREE_LEVELS_MAX 1024
+#endif
+
+#ifndef RTREE_BRANCHES_MAX
+#define RTREE_BRANCHES_MAX 4096
+#endif
+
+#endif

data/ext/rtree/lib/branch.c

@@ -0,0 +1,51 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "rtree/branch.h"
+
+#include <stddef.h>
+#include <stdalign.h>
+#include <string.h>
+
+/*
+  The size of branch_t with n rect elements, with padding taken into
+  account: kindly provided by Eric Postpischil in the stackoverflow
+  question https://stackoverflow.com/questions/59435697/
+
+  Atypically this takes the total number of rect elements (so 2 * dims)
+  rather than the state, this is because it is used in state_new().
+*/
+
+size_t branch_sizeof(size_t n)
+{
+  const size_t s = offsetof(branch_t, rect) + n * sizeof(rtree_coord_t);
+  return ((s - 1) / alignof(branch_t) + 1) * alignof(branch_t);
+}
+
+int branch_init(const state_t *state, branch_t *branch)
+{
+  branch->child = NULL;
+  return rect_init(state, branch->rect);
+}
+
+branch_t* branch_copy(const state_t *state,
+                      const branch_t *src, branch_t *dest)
+{
+  const size_t branch_size = state_branch_size(state);
+  if ((dest = memcpy(dest, src, branch_size)) == NULL)
+    return NULL;
+  rect_copy(state, src->rect, dest->rect);
+  return dest;
+}
+
+/* inline accessors */
+
+extern void branch_set_child(branch_t*, node_t*);
+extern const node_t* branch_get_child(const branch_t*);
+extern node_t* branch_get_child_mutable(branch_t*);
+extern void branch_set_id(branch_t*, rtree_id_t);
+extern rtree_id_t branch_get_id(const branch_t*);
+extern void branch_set_rect(const state_t*, branch_t*, const rtree_coord_t*);
+extern const rtree_coord_t* branch_get_rect(const branch_t*);
+extern rtree_coord_t* branch_get_rect_mutable(branch_t*);

data/ext/rtree/lib/branches.c

@@ -0,0 +1,17 @@
+/*
+  The code here is to handle a void* buffer as an array of branch,
+  we can't actually create an array of branch since its size is
+  not known until runtime, so we have to perform those calculations
+  ourselves.  Note that we just do the arithmatic here, no error
+  checking -- so a over-sized index to branches_get()  will lead to
+  a memory error, the caller is epected to do this check themselves
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "rtree/branches.h"
+
+extern branch_t* branches_get(const state_t*, void*, size_t);
+extern void branches_set(const state_t*, void*, size_t, const branch_t*);