librtree 1.0.2 → 1.0.3

data/ext/rtree/lib/rtree/branch.h

@@ -10,94 +10,8 @@
 extern "C" {
 #endif
 
-#include <stdlib.h>
-
 typedef struct branch_t branch_t;
 
-#include <rtree/types.h>
-#include <rtree/state.h>
-#include <rtree/node.h>
-#include <rtree/rect.h>
-
-/*
-  The union is either a pointer to the child-node in the tree, or
-  if we are at level zero, the id payload.  The latter may as well
-  be the size of a pointer.
-
-  The rect is big enough to hold 2 * dims floats, understood to be
-  [x0, y0, ..., x1, y1, ...] corresponding to the (hyper-)rectangle
-  x0 < x < x1, y0 < y < y1, ..., this must be at the end of the
-  struct (since variable).
-
-  For the sake of SSE, we would like the rect member to be 16-byte
-  aligned, and this could be done with
-
-    rtree_coord_t alignas(16) rect[];
-
-  but this would force the size of branch_t to be a multiple of 16,
-  so for the dimension 2 case with rtree_coord_t a float increases
-  branch size from 24 to 32 bytes, essentially increasing the size
-  of the tree by 20%.  So we don't do that, and use non-aligned
-  variants for SSE load/save (apparently on recent CPUs the penalty
-  is pretty small).
-*/
-
-struct branch_t
-{
-  union {
-    node_t *child;
-    rtree_id_t id;
-  };
-  rtree_coord_t rect[];
-};
-
-size_t branch_sizeof(size_t);
-int branch_init(const state_t*, branch_t*);
-branch_t* branch_copy(const state_t*, const branch_t*, branch_t*);
-
-/* inline accessors */
-
-inline void branch_set_child(branch_t *branch, node_t *child)
-{
-  branch->child = child;
-}
-
-inline const node_t* branch_get_child(const branch_t *branch)
-{
-  return branch->child;
-}
-
-inline node_t* branch_get_child_mutable(branch_t *branch)
-{
-  return branch->child;
-}
-
-inline void branch_set_id(branch_t *branch, rtree_id_t id)
-{
-  branch->id = id;
-}
-
-inline rtree_id_t branch_get_id(const branch_t *branch)
-{
-  return branch->id;
-}
-
-inline void branch_set_rect(const state_t *state, branch_t *branch,
-                            const rtree_coord_t *rect)
-{
-  rect_copy(state, rect, branch->rect);
-}
-
-inline const rtree_coord_t* branch_get_rect(const branch_t *branch)
-{
-  return branch->rect;
-}
-
-inline rtree_coord_t* branch_get_rect_mutable(branch_t *branch)
-{
-  return branch->rect;
-}
-
 #ifdef __cplusplus
 }
 #endif

data/ext/rtree/lib/rtree/node.h

@@ -8,86 +8,12 @@
 
 #ifdef __cplusplus
 extern "C" {
-#if 0
-}
-#endif
 #endif
 
-#include <stdint.h>
-#include <stdbool.h>
-#include <stddef.h>
-
-typedef uint16_t node_level_t;
-typedef uint16_t node_count_t;
-typedef uint16_t node_height_t;
-
-#define NODE_LEVEL_MAX UINT16_MAX
-#define NODE_COUNT_MAX UINT16_MAX
-
-typedef struct node_t node_t;
-
 #include <rtree/types.h>
-#include <rtree/state.h>
-#include <rtree/branch.h>
-
-struct node_t
-{
-  node_level_t level;
-  node_count_t count;
-  char branches[];
-};
 
+typedef struct node_t node_t;
 typedef int (rtree_update_t)(rtree_id_t, rtree_coord_t*, void*);
-typedef int (nbe_cb_t)(const state_t*, const branch_t*, void*);
-
-int node_init(const state_t*, node_t*);
-node_t* node_new(const state_t*);
-void node_destroy(const state_t*, node_t*);
-node_t* node_clone(const state_t*, const node_t*);
-int node_branch_each(const state_t*, const node_t*, nbe_cb_t*, void*);
-int node_branch_each_level(const state_t*, const node_t*, node_level_t,
-                           nbe_cb_t*, void*);
-size_t node_num_branch(size_t, size_t);
-int node_detach_branch(const state_t*, node_t*, size_t);
-node_t* node_add_branch(const state_t*, node_t*, branch_t*);
-int node_envelope(const state_t*, const node_t*, rtree_coord_t*);
-node_t* node_add_rect(const state_t*, rtree_id_t, rtree_coord_t*,
-                      node_t*, node_level_t);
-int node_update(const state_t*, const node_t*, rtree_update_t*, void*);
-bool node_identical(const state_t*, const node_t*, const node_t*);
-node_height_t node_height(const state_t*, const node_t*);
-size_t node_bytes(const state_t*, const node_t*);
-bool node_nonempty(const state_t*, const node_t*);
-
-inline node_count_t node_count(const node_t *node)
-{
-  return node->count;
-}
-
-inline void node_count_increment(node_t *node)
-{
-  node->count++;
-}
-
-inline void node_count_decrement(node_t *node)
-{
-  node->count--;
-}
-
-inline node_level_t node_level(const node_t *node)
-{
-  return node->level;
-}
-
-inline void node_set_level(node_t *node, node_level_t level)
-{
-  node->level = level;
-}
-
-inline void* node_get_branches(node_t *node)
-{
-  return node->branches;
-}
 
 #ifdef __cplusplus
 }

data/ext/rtree/lib/rtree/postscript.h

@@ -14,42 +14,43 @@ typedef struct rtree_postscript_t rtree_postscript_t;
 
 #include <stdio.h>
 #include <rtree/node.h>
+#include <rtree/state.h>
 #include <rtree/extent.h>
 
 typedef enum
   { model_none, model_grey, model_rgb, model_cmyk }
-  colour_model_t;
+  postscript_colour_model_t;
 
 typedef struct {
-  colour_model_t model;
+  postscript_colour_model_t model;
   union {
     float grey[1];
     float rgb[3];
     float cmyk[4];
   };
-} colour_t;
+} postscript_colour_t;
 
 typedef struct {
   struct {
-    colour_t colour;
+    postscript_colour_t colour;
   } fill;
   struct {
-    colour_t colour;
+    postscript_colour_t colour;
     float width;
   } stroke;
-} style_level_t;
+} postscript_style_level_t;
 
 typedef struct {
   size_t n;
-  style_level_t *array;
-} style_t;
+  postscript_style_level_t *array;
+} postscript_style_t;
 
-style_t* postscript_style_read(FILE*);
-void postscript_style_destroy(style_t*);
+postscript_style_t* postscript_style_read(FILE*);
+void postscript_style_destroy(postscript_style_t*);
 
 struct rtree_postscript_t
 {
-  const style_t *style;
+  const postscript_style_t *style;
   extent_axis_t axis;
   float extent;
   float margin;

data/ext/rtree/lib/rtree/search.h

@@ -10,16 +10,10 @@
 extern "C" {
 #endif
 
-#include <rtree/node.h>
 #include <rtree/types.h>
-#include <rtree/state.h>
 
 typedef int (rtree_search_t)(rtree_id_t, void*);
 
-int search(const state_t*,
-           const rtree_coord_t*, const node_t*,
-           rtree_search_t*, void*);
-
 #ifdef __cplusplus
 }
 #endif

data/ext/rtree/lib/rtree/state.h

@@ -15,28 +15,10 @@
 extern "C" {
 #endif
 
-#include <stdlib.h>
 #include <stdint.h>
-#include <stdbool.h>
-
-#include <rtree/types.h>
-#include <rtree/rectf.h>
 
 typedef uint32_t state_flags_t;
-
-typedef struct
-{
-  size_t dims, factor;
-  rtree_coord_t volume;
-  struct {
-    size_t page, branch, node;
-  } size;
-  struct {
-    rectf_rsv_t *spherical_volume;
-    rectf_rc_t *combine;
-  } rectf;
-  state_flags_t flags;
-} state_t;
+typedef struct state_t state_t;
 
 #define RTREE_DEFAULT 0
 
@@ -46,66 +28,6 @@ typedef struct
 
 #define RTREE_NODE_PAGE(n) ((n) << 2)
 
-state_t* state_new(size_t, state_flags_t);
-state_t* state_clone(const state_t*);
-void state_destroy(state_t*);
-state_flags_t state_split(const state_t*);
-state_flags_t state_node_page(const state_t*);
-bool state_identical(const state_t*, const state_t*);
-
-inline rtree_coord_t state_rsv(const state_t *state, const rtree_coord_t *rect)
-{
-  return state->rectf.spherical_volume(state->dims, rect) * state->volume;
-}
-
-inline void state_rc(const state_t *state,
-                     const rtree_coord_t *rect0,
-                     const rtree_coord_t *rect1,
-                     rtree_coord_t *rect2)
-{
-  state->rectf.combine(state->dims, rect0, rect1, rect2);
-}
-
-inline size_t state_dims(const state_t *state)
-{
-  return state->dims;
-}
-
-inline size_t state_branch_size(const state_t *state)
-{
-  return state->size.branch;
-}
-
-inline size_t state_page_size(const state_t *state)
-{
-  return state->size.page;
-}
-
-inline size_t state_node_size(const state_t *state)
-{
-  return state->size.node;
-}
-
-inline size_t state_rect_size(const state_t *state)
-{
-  return state_dims(state) * 2 * sizeof(rtree_coord_t);
-}
-
-inline size_t state_branching_factor(const state_t *state)
-{
-  return state->factor;
-}
-
-inline double state_unit_sphere_volume(const state_t *state)
-{
-  return state->volume;
-}
-
-inline size_t state_bytes(const state_t *state)
-{
-  return (state ? sizeof(state_t) : 0);
-}
-
 #ifdef __cplusplus
 }
 #endif

data/ext/rtree/lib/rtree-base.c

@@ -3,11 +3,15 @@
 #endif
 
 #include "rtree.h"
-#include "rtree/error.h"
 
 #include "csv.h"
 #include "json.h"
 #include "bsrt.h"
+#include "node.h"
+#include "search.h"
+#include "state.h"
+
+#include "rtree/error.h"
 
 #include <errno.h>
 #include <stdlib.h>
@@ -189,6 +193,62 @@ size_t rtree_bytes(const rtree_t *rtree)
       node_bytes(rtree->state, rtree->root);
 }
 
+size_t rtree_dims(const rtree_t *rtree)
+{
+  if (rtree == NULL)
+    return 0;
+  else
+    return state_dims(rtree->state);
+}
+
+size_t rtree_page_size(const rtree_t *rtree)
+{
+  if (rtree == NULL)
+    return 0;
+  else
+    return state_page_size(rtree->state);
+}
+
+size_t rtree_node_size(const rtree_t *rtree)
+{
+  if (rtree == NULL)
+    return 0;
+  else
+    return state_node_size(rtree->state);
+}
+
+size_t rtree_rect_size(const rtree_t *rtree)
+{
+  if (rtree == NULL)
+    return 0;
+  else
+    return state_rect_size(rtree->state);
+}
+
+size_t rtree_branch_size(const rtree_t *rtree)
+{
+  if (rtree == NULL)
+    return 0;
+  else
+    return state_branch_size(rtree->state);
+}
+
+size_t rtree_branching_factor(const rtree_t *rtree)
+{
+  if (rtree == NULL)
+    return 0;
+  else
+    return state_branching_factor(rtree->state);
+}
+
+double rtree_unit_sphere_volume(const rtree_t *rtree)
+{
+  if (rtree == NULL)
+    return 0;
+  else
+    return state_unit_sphere_volume(rtree->state);
+}
+
 bool rtree_empty(const rtree_t *rtree)
 {
   return

data/ext/rtree/lib/rtree.h

@@ -1,10 +1,5 @@
 /*
   rtree.h
-
-  This is the bottom-level "public" header, it does not
-  include all of the rtree headers, just enough to define
-  the members of the (atypically) open structure rtree_t.
-
   Copyright (c) J.J. Green 2020
 */
 
@@ -53,6 +48,13 @@ rtree_t* rtree_bsrt_read(FILE*);
 int rtree_postscript(const rtree_t*, const rtree_postscript_t*, FILE*);
 const char* rtree_strerror(int);
 size_t rtree_bytes(const rtree_t*);
+size_t rtree_dims(const rtree_t*);
+size_t rtree_page_size(const rtree_t*);
+size_t rtree_node_size(const rtree_t*);
+size_t rtree_rect_size(const rtree_t*);
+size_t rtree_branch_size(const rtree_t*);
+size_t rtree_branching_factor(const rtree_t*);
+double rtree_unit_sphere_volume(const rtree_t*);
 bool rtree_empty(const rtree_t*);
 
 #ifdef __cplusplus

data/ext/rtree/lib/search.c

@@ -2,11 +2,13 @@
 #include "config.h"
 #endif
 
-#include "rtree/search.h"
+#include "search.h"
+#include "node.h"
+#include "branch.h"
+#include "rect.h"
 
-#include "rtree/branch.h"
 #include "rtree/error.h"
-#include "rtree/rect.h"
+
 
 typedef struct
 {

data/ext/rtree/lib/search.h

@@ -0,0 +1,21 @@
+/*
+  search.h
+  Copyright (c) J.J. Green 2023
+*/
+
+#ifndef SEARCH_H
+#define SEARCH_H
+
+#include "rtree/search.h"
+
+#include "rtree/node.h"
+#include "rtree/types.h"
+#include "rtree/state.h"
+
+int search(const state_t*,
+           const rtree_coord_t*,
+           const node_t*,
+           rtree_search_t*,
+           void*);
+
+#endif

data/ext/rtree/lib/split.c

@@ -12,10 +12,12 @@
 #endif
 
 #include "rtree/error.h"
-#include "rtree/branches.h"
 
+#include "branches.h"
+#include "branch.h"
 #include "split.h"
 #include "bindex.h"
+#include "node.h"
 
 typedef struct
 {

data/ext/rtree/lib/split.h

@@ -6,9 +6,9 @@
 #ifndef SPLIT_H
 #define SPLIT_H
 
-#include <rtree/state.h>
-#include <rtree/branch.h>
-#include <rtree/node.h>
+#include "rtree/state.h"
+#include "rtree/branch.h"
+#include "rtree/node.h"
 
 node_t* split_node(const state_t*, node_t*, branch_t*);
 

data/ext/rtree/lib/state.c

@@ -2,13 +2,13 @@
 #include "config.h"
 #endif
 
-#include "rtree/state.h"
-#include "rtree/branch.h"
-#include "rtree/node.h"
+#include "state.h"
 
+#include "branch.h"
 #include "page.h"
 #include "constants.h"
 #include "spvol.h"
+#include "node.h"
 
 #include <errno.h>
 #include <string.h>

data/ext/rtree/lib/state.h

@@ -0,0 +1,90 @@
+/*
+  state.h
+  Copyright (c) J.J. Green 2023
+*/
+
+#ifndef STATE_H
+#define STATE_H
+
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include "rtree/state.h"
+#include "rtree/types.h"
+#include "rtree/rectf.h"
+
+struct state_t
+{
+  size_t dims, factor;
+  rtree_coord_t volume;
+  struct {
+    size_t page, branch, node;
+  } size;
+  struct {
+    rectf_rsv_t *spherical_volume;
+    rectf_rc_t *combine;
+  } rectf;
+  state_flags_t flags;
+};
+
+state_t* state_new(size_t, state_flags_t);
+state_t* state_clone(const state_t*);
+void state_destroy(state_t*);
+state_flags_t state_split(const state_t*);
+state_flags_t state_node_page(const state_t*);
+bool state_identical(const state_t*, const state_t*);
+
+inline rtree_coord_t state_rsv(const state_t *state, const rtree_coord_t *rect)
+{
+  return state->rectf.spherical_volume(state->dims, rect) * state->volume;
+}
+
+inline void state_rc(const state_t *state,
+                     const rtree_coord_t *rect0,
+                     const rtree_coord_t *rect1,
+                     rtree_coord_t *rect2)
+{
+  state->rectf.combine(state->dims, rect0, rect1, rect2);
+}
+
+inline size_t state_dims(const state_t *state)
+{
+  return state->dims;
+}
+
+inline size_t state_branch_size(const state_t *state)
+{
+  return state->size.branch;
+}
+
+inline size_t state_page_size(const state_t *state)
+{
+  return state->size.page;
+}
+
+inline size_t state_node_size(const state_t *state)
+{
+  return state->size.node;
+}
+
+inline size_t state_rect_size(const state_t *state)
+{
+  return state_dims(state) * 2 * sizeof(rtree_coord_t);
+}
+
+inline size_t state_branching_factor(const state_t *state)
+{
+  return state->factor;
+}
+
+inline double state_unit_sphere_volume(const state_t *state)
+{
+  return state->volume;
+}
+
+inline size_t state_bytes(const state_t *state)
+{
+  return (state ? sizeof(state_t) : 0);
+}
+
+#endif