Handle empty arrays/trees better

interval-tree/src/lib.rs

@@ -101,10 +101,7 @@ impl IntervalTree {
             "Inputs must have the same length"
         );
         if n == 0 {
-            return Self {
-                root: None,
-                size: 0,
-            };
+            return Self::new();
         }
         let elements: Vec<(f64, f64, usize)> = (0..n).map(|i| (mins[i], maxs[i], ids[i])).collect();
         Self {
@@ -160,6 +157,15 @@ impl IntervalTree {
     pub fn root(&self) -> Option<&IntervalTreeNode> {
         self.root.as_ref()
     }
+
+    /// Returns an empty interval tree.
+    #[must_use]
+    pub fn new() -> Self {
+        Self {
+            root: None,
+            size: 0,
+        }
+    }
 }
 
 #[cfg(test)]

interval-tree/src/tests.rs

@@ -67,6 +67,13 @@ fn test_interval_tree_bulk_load() {
     assert_eq!(right_node.right, None);
 }
 
+#[test]
+fn test_interval_tree_new() {
+    let tree = IntervalTree::new();
+    assert_eq!(tree.size(), 0);
+    assert_eq!(tree.root(), None);
+}
+
 #[test]
 fn test_interval_tree_empty_bulk_load() {
     let mins = vec![];

rtree-capi/include/rtree-capi.h

@@ -9,6 +9,7 @@ enum RTreeError {
   Success = 0,
   NullPointer = 1,
   InvalidDimension = 2,
+  EmptyNodeEnvelope = 3,
 };
 typedef uint16_t RTreeError;
 
@@ -47,3 +48,5 @@ RTreeError rtree_node_envelope(const struct RTreeNodeH *node, double *min_out, d
 RTreeError rtree_node_free(struct RTreeNodeH *node);
 
 RTreeError rtree_root_node(const struct RTreeH *tree, struct RTreeNodeH **node);
+
+RTreeError rtree_size(const struct RTreeH *tree, size_t *size_out);

rtree-capi/src/error.rs

@@ -3,4 +3,5 @@ pub enum RTreeError {
     Success = 0,
     NullPointer = 1,
     InvalidDimension = 2,
+    EmptyNodeEnvelope = 3,
 }

rtree-capi/src/node.rs

@@ -10,6 +10,7 @@ enum NodeRef {
     Parent3D(*const ParentNode<Object3D>),
     Node2D(*const RTreeNode<Object2D>),
     Node3D(*const RTreeNode<Object3D>),
+    EmptyNode,  // root node of empty tree
 }
 
 pub enum RTreeNodeH {}
@@ -20,6 +21,16 @@ pub extern "C" fn rtree_root_node(tree: *const RTreeH, node: *mut *mut RTreeNode
         return RTreeError::NullPointer;
     }
     let rtree = unsafe { &*(tree as *const RTreeDim) };
+    let size = match rtree {
+        RTreeDim::D1(tree) => tree.size(),
+        RTreeDim::D2(tree) => tree.size(),
+        RTreeDim::D3(tree) => tree.size(),
+    };
+    if size == 0 {
+        let node_ref = NodeRef::EmptyNode;
+        unsafe { *node = Box::into_raw(Box::new(node_ref)) as *mut RTreeNodeH };
+        return RTreeError::Success;
+    }
     let node_ref = match rtree {
         RTreeDim::D1(tree) => NodeRef::ITreeNode(tree.root().unwrap()),
         RTreeDim::D2(tree) => NodeRef::Parent2D(tree.root() as *const _),
@@ -41,6 +52,7 @@ pub extern "C" fn rtree_node_children(
     let node_ref = unsafe { &*(node as *const NodeRef) };
 
     let child_node_refs: Vec<NodeRef> = match node_ref {
+        NodeRef::EmptyNode => Vec::new(),
         NodeRef::ITreeNode(ptr) => {
             let node = unsafe { &**ptr };
             let mut children = Vec::new();
@@ -115,6 +127,7 @@ pub extern "C" fn rtree_node_envelope(
     let node_ref = unsafe { &*(node as *const NodeRef) };
 
     match node_ref {
+        NodeRef::EmptyNode => return RTreeError::EmptyNodeEnvelope,
         NodeRef::ITreeNode(ptr) => {
             let node = unsafe { &**ptr };
             let min = node.min;

rtree-capi/src/rtree.rs

@@ -101,7 +101,22 @@ pub extern "C" fn rtree_bulk_load(
     n: usize,
     dim: u32,
 ) -> RTreeError {
-    if tree.is_null() || mins.is_null() || maxs.is_null() || ids.is_null() {
+    if tree.is_null() {
+        return RTreeError::NullPointer;
+    }
+
+    if n == 0 {
+        let rtree = match dim {
+            1 => RTreeDim::D1(IntervalTree::new()),
+            2 => RTreeDim::D2(RTree::new()),
+            3 => RTreeDim::D3(RTree::new()),
+            _ => return RTreeError::InvalidDimension,
+        };
+        unsafe { *tree = Box::into_raw(Box::new(rtree)) as *mut RTreeH };
+        return RTreeError::Success;
+    }
+
+    if mins.is_null() || maxs.is_null() || ids.is_null() {
         return RTreeError::NullPointer;
     }
 
@@ -153,6 +168,21 @@ pub extern "C" fn rtree_locate_all_at_point(
     RTreeError::Success
 }
 
+#[no_mangle]
+pub extern "C" fn rtree_size(tree: *const RTreeH, size_out: *mut usize) -> RTreeError {
+    if tree.is_null() || size_out.is_null() {
+        return RTreeError::NullPointer;
+    }
+    let rtree = unsafe { &*(tree as *const RTreeDim) };
+    let size = match rtree {
+        RTreeDim::D1(tree) => tree.size(),
+        RTreeDim::D2(tree) => tree.size(),
+        RTreeDim::D3(tree) => tree.size(),
+    };
+    unsafe { *size_out = size };
+    RTreeError::Success
+}
+
 #[no_mangle]
 pub extern "C" fn rtree_free_ids(ids: *mut usize, n: usize) -> RTreeError {
     if ids.is_null() {