Find functions no longer start at the root and dont include their given iterator.

Author: 5cript

draw.hpp

@@ -3,7 +3,7 @@
 #include "interval_types.hpp"
 #include "interval_tree.hpp"
 
-#include "cairo-wrap/cairo_wrap.hpp"
+#include <cairo-wrap/cairo_wrap.hpp>
 
 #include <string>
 #include <sstream>

interval_tree.hpp

@@ -277,6 +277,22 @@ namespace lib_interval_tree
             return counter;
         }
 
+        /**
+         *  Returns the lower bound of the interval of this node
+         */
+        value_type low() const
+        {
+            return interval_.low();
+        }
+
+        /**
+         *  Returns the upper bound of the interval of this node
+         */
+        value_type high() const
+        {
+            return interval_.high();
+        }
+
 private:
         void set_interval(interval_type const& ival)
         {
@@ -432,7 +448,7 @@ namespace lib_interval_tree
             if (node_)
                 return node_->interval();
             else
-                throw std::out_of_range("interval_tree_iterator out of bounds");
+                throw std::out_of_range("dereferencing interval_tree_iterator out of bounds");
         }
 
         /**
@@ -799,15 +815,15 @@ namespace lib_interval_tree
         }
 
         /**
-         *  Finds the next exact match INCLUDING from.
+         *  Finds the next exact match EXCLUDING from.
          *
-         *  @param from The iterator to search from, INCLUSIVE!
+         *  @param from The iterator to search from, EXCLUCISVE!
          *  @param ival The interval to find an exact match for within the tree.
          *  @param compare A comparison function to use.
          */
         iterator find_next(iterator from, interval_type const& ival)
         {
-            return find_next(from, ival, [](auto const& lhs, auto const& rhs){return lhs == rhs;});
+            return find_next(++from, ival, [](auto const& lhs, auto const& rhs){return lhs == rhs;});
         }
 
         /**
@@ -820,21 +836,21 @@ namespace lib_interval_tree
         {
             if (root_ == nullptr)
                 return end();
-            return iterator{overlap_find_i(root_, ival, exclusive), this};
+            return iterator{overlap_find_i(begin().node_, ival, exclusive), this};
         }
 
         /**
-         *  Finds the next interval that overlaps with ival INCLUDING from.
+         *  Finds the next interval that overlaps with ival
          *
-         *  @param from The iterator to start from, INCLUSIVE!
+         *  @param from The iterator to start from, EXCLUSIVE!
          *  @param ival The interval to find an overlap for within the tree.
          *  @param exclusive Exclude edges?
          */
         iterator overlap_find_next(iterator from, interval_type const& ival, bool exclusive = false)
         {
             if (root_ == nullptr)
                 return end();
-            return iterator{overlap_find_i(from.node_, ival, exclusive), this};
+            return iterator{overlap_find_i((++from).node_, ival, exclusive), this};
         }
 
         /**

tests/overlap_tests.hpp

@@ -0,0 +1,81 @@
+#pragma once
+
+#include "test_utility.hpp"
+
+class OverlapFindTests
+    : public ::testing::Test
+{
+public:
+    using types = IntervalTypes <int>;
+protected:
+    IntervalTypes <int>::tree_type tree;
+};
+
+TEST_F(OverlapFindTests, WillReturnEndIfTreeIsEmpty)
+{
+    EXPECT_EQ(tree.overlap_find({2, 7}), std::end(tree));
+}
+
+TEST_F(OverlapFindTests, WillNotFindOverlapWithRootIfItDoesntOverlap)
+{
+    tree.insert({0, 1});
+    EXPECT_EQ(tree.overlap_find({2, 7}), std::end(tree));
+}
+
+TEST_F(OverlapFindTests, WillFindOverlapWithRoot)
+{
+    tree.insert({2, 4});
+    EXPECT_EQ(tree.overlap_find({2, 7}), std::begin(tree));
+}
+
+TEST_F(OverlapFindTests, WillFindOverlapWithRootIfMatchingExactly)
+{
+    tree.insert({2, 7});
+    EXPECT_EQ(tree.overlap_find({2, 7}), std::begin(tree));
+}
+
+TEST_F(OverlapFindTests, WillFindOverlapWithRootIfTouching)
+{
+    tree.insert({2, 7});
+    EXPECT_EQ(tree.overlap_find({7, 9}), std::begin(tree));
+}
+
+TEST_F(OverlapFindTests, WillFindMultipleOverlaps)
+{
+    tree.insert({ 0, 5 });
+    tree.insert({ 5, 10 });
+    tree.insert({ 10, 15 });
+    tree.insert({ 15, 20 });
+
+    auto iter = tree.overlap_find({0, 9}), end = tree.end();
+    EXPECT_EQ(iter->low(), 0);
+    EXPECT_EQ(iter->high(), 5);
+
+    iter = tree.overlap_find_next(iter, {0, 9});
+    EXPECT_EQ(iter->low(), 5);
+    EXPECT_EQ(iter->high(), 10);
+
+    iter = tree.overlap_find_next(iter, {0, 9});
+    EXPECT_EQ(iter, end);
+}
+
+TEST_F(OverlapFindTests, WillFindMultipleOverlapsIfTouching)
+{
+    tree.insert({ 0, 5 });
+    tree.insert({ 5, 10 });
+    tree.insert({ 10, 15 });
+    tree.insert({ 15, 20 });
+
+    auto iter = tree.overlap_find({5, 5}), end = tree.end();
+    EXPECT_EQ(iter->low(), 0);
+    EXPECT_EQ(iter->high(), 5);
+
+    iter = tree.overlap_find_next(iter, {5, 5});
+    EXPECT_EQ(iter->low(), 5);
+    EXPECT_EQ(iter->high(), 10);
+
+    iter = tree.overlap_find_next(iter, {5, 5});
+    EXPECT_EQ(iter, end);
+}
+
+

tests/tests.cpp

@@ -7,7 +7,8 @@
 // following headers expect to be included after gtest headers and interval_tree
 #include "interval_tests.hpp"
 #include "insert_tests.hpp"
-#include "erase_tests.hpp"
+#include "erase_tests.hpp"
+#include "overlap_tests.hpp"
 
 int main(int argc, char** argv)
 {