Merge branch 'master' of github.com:5cript/interval-tree

5cript · 5cript · commit 4dbd09ade453 · 2021-10-24T04:06:24.000+02:00
diff --git a/README.md b/README.md
@@ -67,7 +67,7 @@ Creates an interval where the borders are sorted so the lower border is the firs
       - [Example](#example-1)
     - [(const)iterator find_all(interval_type const& ival, OnFindFunctionT const& on_find, CompareFunctionT const& compare)](#constiterator-find_allinterval_type-const-ival-onfindfunctiont-const-on_find-comparefunctiont-const-compare)
     - [(const)iterator find_next_in_subtree(iterator from, interval_type const& ival)](#constiterator-find_next_in_subtreeiterator-from-interval_type-const-ival)
-    - [(const)iterator find_next(iterator from, interval_type const& ival, CompareFunctionT const& compare)](#constiterator-find_nextiterator-from-interval_type-const-ival-comparefunctiont-const-compare)
+    - [(const)iterator find_next_in_subtree(iterator from, interval_type const& ival, CompareFunctionT const& compare)](#constiterator-find_next_in_subtreeiterator-from-interval_type-const-ival-comparefunctiont-const-compare)
     - [(const)iterator overlap_find(interval_type const& ival, bool exclusive)](#constiterator-overlap_findinterval_type-const-ival-bool-exclusive)
     - [(const)iterator overlap_find_all(interval_type const& ival, OnFindFunctionT const& on_find, bool exclusive)](#constiterator-overlap_find_allinterval_type-const-ival-onfindfunctiont-const-on_find-bool-exclusive)
       - [Example](#example-2)
@@ -127,11 +127,11 @@ Finds the first interval in the interval tree that has an exact match.
 
 ---
 ### (const)iterator find(interval_type const& ival, CompareFunctionT const& compare)
-Finds the first interval in the interval tree that has the following statement evaluate to true: compare(ival, interval_in_tree);
+Finds the first interval in the interval tree that has the following statement evaluate to true: compare(interval_in_tree, ival);
 Allows for propper float comparisons.
 #### Parameters
 * `ival` The interval to find.
-* `compare` The compare function to compare intervals with.
+* `compare` The compare function to compare intervals with. Function is called like so: compare(interval_in_tree, ival).
 
 **Returns**: An iterator to the found element, or std::end(tree).
 
@@ -160,7 +160,7 @@ tree.find_all({3, 7}, [](auto iter) /* iter will be const_iterator if tree is co
 Find all intervals in the tree that the compare function returns true for.
 #### Parameters
 * `ival` The interval to find.
-* `compare` The compare function to compare intervals with.
+* `compare` The compare function to compare intervals with. Function is called like so: compare(interval_in_tree, ival).
 * `on_find` A function of type bool(iterator) that is called when an interval was found.
 Return true to continue, false to preemptively abort search.
 
@@ -177,13 +177,13 @@ You cannot find all matches this way, use find_all for that.
 **Returns**: An iterator to the found element, or std::end(tree).
 
 ---
-### (const)iterator find_next(iterator from, interval_type const& ival, CompareFunctionT const& compare)
+### (const)iterator find_next_in_subtree(iterator from, interval_type const& ival, CompareFunctionT const& compare)
 Finds the next exact match EXCLUDING from in the subtree originating from "from".
 You cannot find all matches this way, use find_all for that.
 #### Parameters
 * `from` The iterator to start from (including this iterator!)
 * `ival` The interval to find.
-* `compare` The compare function to compare intervals with.
+* `compare` The compare function to compare intervals with. Function is called like so: compare(interval_in_tree, ival).
 
 **Returns**: An iterator to the found element, or std::end(tree).
 
diff --git a/interval_tree.hpp b/interval_tree.hpp
@@ -37,13 +37,19 @@ namespace lib_interval_tree
          *  Constructs an interval. low MUST be smaller than high.
          */
 #ifndef INTERVAL_TREE_SAFE_INTERVALS
+#if __cplusplus >= 201703L
+        constexpr
+#endif
         interval(value_type low, value_type high)
             : low_{low}
             , high_{high}
         {
             assert(low <= high);
         }
 #else
+#if __cplusplus >= 201703L
+        constexpr
+#endif
         interval(value_type low, value_type high)
             : low_{std::min(low, high)}
             , high_{std::max(low, high)}
@@ -173,6 +179,9 @@ namespace lib_interval_tree
      *  Creates a safe interval that puts the lower bound left automatically.
      */
     template <typename numerical_type, typename interval_kind_ = closed>
+#if __cplusplus >= 201703L
+    constexpr
+#endif
     interval <numerical_type, interval_kind_> make_safe_interval(numerical_type lhs, numerical_type rhs)
     {
         return interval <numerical_type, interval_kind_>{std::min(lhs, rhs), std::max(lhs, rhs)};
@@ -621,6 +630,7 @@ namespace lib_interval_tree
         using iterator = interval_tree_iterator <node_type>;
         using const_iterator = const_interval_tree_iterator <node_type>;
         using size_type = long long;
+        using this_type = interval_tree<interval_type>;
 
     public:
         friend const_interval_tree_iterator <node_type>;
@@ -854,14 +864,14 @@ namespace lib_interval_tree
         {
             if (root_ == nullptr)
                 return;
-            find_all_i<iterator>(root_, ival, on_find, compare);
+            find_all_i<this_type, iterator>(this, root_, ival, on_find, compare);
         }
         template <typename FunctionT, typename CompareFunctionT>
         void find_all(interval_type const& ival, FunctionT const& on_find, CompareFunctionT const& compare) const
         {
             if (root_ == nullptr)
                 return;
-            find_all_i<const_iterator>(root_, ival, on_find, compare);
+            find_all_i<this_type, const_iterator>(this, root_, ival, on_find, compare);
         }
 
         template <typename FunctionT>
@@ -950,19 +960,19 @@ namespace lib_interval_tree
             if (root_ == nullptr)
                 return;
             if (exclusive)
-                overlap_find_all_i<true, iterator>(root_, ival, on_find);
+                overlap_find_all_i<this_type, true, iterator>(this, root_, ival, on_find);
             else
-                overlap_find_all_i<false, iterator>(root_, ival, on_find);
+                overlap_find_all_i<this_type, false, iterator>(this, root_, ival, on_find);
         }
         template <typename FunctionT>
         void overlap_find_all(interval_type const& ival, FunctionT const& on_find, bool exclusive = false) const
         {
             if (root_ == nullptr)
                 return;
             if (exclusive)
-                overlap_find_all_i<true, const_iterator>(root_, ival, on_find);
+                overlap_find_all_i<this_type, true, const_iterator>(this, root_, ival, on_find);
             else
-                overlap_find_all_i<false, const_iterator>(root_, ival, on_find);
+                overlap_find_all_i<this_type, false, const_iterator>(this, root_, ival, on_find);
         }
 
         /**
@@ -1114,36 +1124,43 @@ namespace lib_interval_tree
             return nullptr;
         };
 
-        template <typename IteratorT, typename FunctionT, typename ComparatorFunctionT>
-        bool find_all_i(node_type* ptr, interval_type const& ival, FunctionT const& on_find, ComparatorFunctionT const& compare)
+        template <typename ThisType, typename IteratorT, typename FunctionT, typename ComparatorFunctionT>
+        static bool find_all_i
+        (
+            typename std::conditional<std::is_same<IteratorT, iterator>::value, ThisType, ThisType const>::type* self,
+            node_type* ptr, 
+            interval_type const& ival, 
+            FunctionT const& on_find, 
+            ComparatorFunctionT const& compare
+        )
         {
             if (compare(ptr->interval(), ival))
             {
-                if (!on_find(IteratorT{ptr, this}))
+                if (!on_find(IteratorT{ptr, self}))
                     return false;
             }
             if (ptr->left_ && ival.high() <= ptr->left_->max())
             {
                 // no right? can only continue left
                 if (!ptr->right_ || ival.low() > ptr->right_->max())
-                    return find_all_i<IteratorT>(ptr->left_, ival, on_find, compare);
+                    return find_all_i<ThisType, IteratorT>(self, ptr->left_, ival, on_find, compare);
 
-                if (!find_all_i<IteratorT>(ptr->left_, ival, on_find, compare))
+                if (!find_all_i<ThisType, IteratorT>(self, ptr->left_, ival, on_find, compare))
                     return false;
             }
             if (ptr->right_ && ival.high() <= ptr->right_->max())
             {
                 if (!ptr->left_ || ival.low() > ptr->left_->max())
-                    return find_all_i<IteratorT>(ptr->right_, ival, on_find, compare);
+                    return find_all_i<ThisType, IteratorT>(self, ptr->right_, ival, on_find, compare);
 
-                if (!find_all_i<IteratorT>(ptr->right_, ival, on_find, compare))
+                if (!find_all_i<ThisType, IteratorT>(self, ptr->right_, ival, on_find, compare))
                     return false;
             }
             return true;
         }
 
         template <typename ComparatorFunctionT>
-        node_type* find_i(node_type* ptr, interval_type const& ival, ComparatorFunctionT const& compare)
+        node_type* find_i(node_type* ptr, interval_type const& ival, ComparatorFunctionT const& compare) const
         {
             if (compare(ptr->interval(), ival))
                 return ptr;
@@ -1153,7 +1170,7 @@ namespace lib_interval_tree
 
         // excludes ptr
         template <typename ComparatorFunctionT>
-        node_type* find_i_ex(node_type* ptr, interval_type const& ival, ComparatorFunctionT const& compare)
+        node_type* find_i_ex(node_type* ptr, interval_type const& ival, ComparatorFunctionT const& compare) const
         {
             if (ptr->left_ && ival.high() <= ptr->left_->max())
             {
@@ -1178,7 +1195,7 @@ namespace lib_interval_tree
         }
 
         template <bool Exclusive>
-        node_type* overlap_find_i(node_type* ptr, interval_type const& ival)
+        node_type* overlap_find_i(node_type* ptr, interval_type const& ival) const
         {
 #if __cplusplus >= 201703L
             if constexpr (Exclusive)
@@ -1198,8 +1215,14 @@ namespace lib_interval_tree
             return overlap_find_i_ex<Exclusive>(ptr, ival);
         }
 
-        template <bool Exclusive, typename IteratorT, typename FunctionT>
-        bool overlap_find_all_i(node_type* ptr, interval_type const& ival, FunctionT const& on_find)
+        template <typename ThisType, bool Exclusive, typename IteratorT, typename FunctionT>
+        static bool overlap_find_all_i
+        (
+            typename std::conditional<std::is_same<IteratorT, iterator>::value, ThisType, ThisType const>::type* self,
+            node_type* ptr, 
+            interval_type const& ival, 
+            FunctionT const& on_find
+        )
         {
 #if __cplusplus >= 201703L
             if constexpr (Exclusive)
@@ -1209,7 +1232,7 @@ namespace lib_interval_tree
             {
                 if (ptr->interval().overlaps_exclusive(ival))
                 {
-                    if (!on_find(IteratorT{ptr, this}))
+                    if (!on_find(IteratorT{ptr, self}))
                     {
                         return false;
                     }
@@ -1219,7 +1242,7 @@ namespace lib_interval_tree
             {
                 if (ptr->interval().overlaps(ival))
                 {
-                    if (!on_find(IteratorT{ptr, this}))
+                    if (!on_find(IteratorT{ptr, self}))
                     {
                         return false;
                     }
@@ -1230,25 +1253,25 @@ namespace lib_interval_tree
                 // no right? can only continue left
                 // or interval low is bigger than max of right branch.
                 if (!ptr->right_ || ival.low() > ptr->right_->max())
-                    return overlap_find_all_i<Exclusive, IteratorT>(ptr->left_, ival, on_find);
+                    return overlap_find_all_i<ThisType, Exclusive, IteratorT>(self, ptr->left_, ival, on_find);
 
-                if (!overlap_find_all_i<Exclusive, IteratorT>(ptr->left_, ival, on_find))
+                if (!overlap_find_all_i<ThisType, Exclusive, IteratorT>(self, ptr->left_, ival, on_find))
                     return false;
             }
             if (ptr->right_ && ptr->right_->max() >= ival.low())
             {
                 if (!ptr->left_ || ival.low() > ptr->right_->max())
-                    return overlap_find_all_i<Exclusive, IteratorT>(ptr->right_, ival, on_find);
+                    return overlap_find_all_i<ThisType, Exclusive, IteratorT>(self, ptr->right_, ival, on_find);
 
-                if (!overlap_find_all_i<Exclusive, IteratorT>(ptr->right_, ival, on_find))
+                if (!overlap_find_all_i<ThisType, Exclusive, IteratorT>(self, ptr->right_, ival, on_find))
                     return false;
             }
             return true;
         }
 
         // excludes ptr
         template <bool Exclusive>
-        node_type* overlap_find_i_ex(node_type* ptr, interval_type const& ival)
+        node_type* overlap_find_i_ex(node_type* ptr, interval_type const& ival) const
         {
             if (ptr->left_ && ptr->left_->max() >= ival.low())
             {
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
@@ -24,7 +24,7 @@ file(GLOB sources "*.cpp")
 # Add Executable
 add_executable(tree-tests ${sources})
 
-target_link_libraries(tree-tests gtest)
+target_link_libraries(tree-tests gtest gmock)
 
 # Options
 if(DRAW_EXAMPLES)
diff --git a/tests/find_tests.hpp b/tests/find_tests.hpp
@@ -32,6 +32,15 @@ TEST_F(FindTests, WillFindRoot)
     EXPECT_EQ(tree.find({0, 1}), std::begin(tree));
 }
 
+TEST_F(FindTests, WillFindRootOnConstTree)
+{
+    tree.insert({0, 1});
+    [](auto const& tree)
+    {
+        EXPECT_EQ(tree.find({0, 1}), std::begin(tree));
+    }(tree);
+}
+
 TEST_F(FindTests, WillFindInBiggerTree)
 {
     tree.insert({16, 21});
@@ -137,3 +146,23 @@ TEST_F(FindTests, CanFindAllElementsBackInStrictlyAscendingOverlappingIntervals)
         ASSERT_NE(tree.find(ival), std::end(tree));
     }
 }
+
+TEST_F(FindTests, CanFindAllOnConstTree)
+{
+    const auto targetInterval = lib_interval_tree::make_safe_interval(16, 21);
+    tree.insert(targetInterval);
+    tree.insert({8, 9});
+    tree.insert({25, 30});
+    std::vector <decltype(tree)::interval_type> intervals;
+    auto findWithConstTree = [&intervals, &targetInterval](auto const& tree)
+    {
+        tree.find_all(targetInterval, [&intervals](auto const& iter) {
+            intervals.emplace_back(*iter);
+            return true;
+        });
+    };
+    findWithConstTree(tree);
+
+    ASSERT_EQ(intervals.size(), 1);
+    EXPECT_EQ(intervals[0], targetInterval);
+}
diff --git a/tests/interval_tests.hpp b/tests/interval_tests.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <boost/preprocessor/comma.hpp>
-
 #include <limits>
 
 class IntervalTests
@@ -30,13 +28,13 @@ class DistanceTests
 {
 public:
     using types = IntervalTypes <int>;
-};
+};
 
 TEST_F(IntervalTests, FailBadBorders)
 {
     auto f = []()
     {
-        [[maybe_unused]] auto ival = types::interval_type{1 BOOST_PP_COMMA() 0};
+        [[maybe_unused]] auto ival = types::interval_type{1, 0};
     };
 
     EXPECT_DEATH(f(), "low <= high");
diff --git a/tests/overlap_find_tests.hpp b/tests/overlap_find_tests.hpp
@@ -28,6 +28,14 @@ TEST_F(OverlapFindTests, WillFindOverlapWithRoot)
     EXPECT_EQ(tree.overlap_find({2, 7}), std::begin(tree));
 }
 
+TEST_F(OverlapFindTests, WillFindOverlapWithRootOnConstTree)
+{
+    tree.insert({2, 4});
+    [](auto const& tree) {
+        EXPECT_EQ(tree.overlap_find({2, 7}), std::begin(tree));
+    }(tree);
+}
+
 TEST_F(OverlapFindTests, WillFindOverlapWithRootIfMatchingExactly)
 {
     tree.insert({2, 7});
@@ -149,4 +157,24 @@ TEST_F(OverlapFindTests, WillFindSingleOverlapInBiggerTree)
     EXPECT_NE(iter, std::end(tree));
     EXPECT_EQ(iter->low(), 1000);
     EXPECT_EQ(iter->high(), 2000);
-}
+}
+
+TEST_F(FindTests, CanOverlapFindAllOnConstTree)
+{
+    const auto targetInterval = lib_interval_tree::make_safe_interval(16, 21);
+    tree.insert(targetInterval);
+    tree.insert({8, 9});
+    tree.insert({25, 30});
+    std::vector <decltype(tree)::interval_type> intervals;
+    auto findWithConstTree = [&intervals, &targetInterval](auto const& tree)
+    {
+        tree.overlap_find_all(targetInterval, [&intervals](auto const& iter) {
+            intervals.emplace_back(*iter);
+            return true;
+        });
+    };
+    findWithConstTree(tree);
+
+    ASSERT_EQ(intervals.size(), 1);
+    EXPECT_EQ(intervals[0], targetInterval);
+}

Original file line number	Diff line number	Diff line change
`@@ -37,13 +37,19 @@ namespace lib_interval_tree`
`37`	`37`	`* Constructs an interval. low MUST be smaller than high.`
`38`	`38`	`*/`
`39`	`39`	`#ifndef INTERVAL_TREE_SAFE_INTERVALS`
	`40`	`+#if __cplusplus >= 201703L`
	`41`	`+ constexpr`
	`42`	`+#endif`
`40`	`43`	`interval(value_type low, value_type high)`
`41`	`44`	`: low_{low}`
`42`	`45`	`, high_{high}`
`43`	`46`	`{`
`44`	`47`	`assert(low <= high);`
`45`	`48`	`}`
`46`	`49`	`#else`
	`50`	`+#if __cplusplus >= 201703L`
	`51`	`+ constexpr`
	`52`	`+#endif`
`47`	`53`	`interval(value_type low, value_type high)`
`48`	`54`	`: low_{std::min(low, high)}`
`49`	`55`	`, high_{std::max(low, high)}`
`@@ -173,6 +179,9 @@ namespace lib_interval_tree`
`173`	`179`	`* Creates a safe interval that puts the lower bound left automatically.`
`174`	`180`	`*/`
`175`	`181`	`template <typename numerical_type, typename interval_kind_ = closed>`
	`182`	`+#if __cplusplus >= 201703L`
	`183`	`+ constexpr`
	`184`	`+#endif`
`176`	`185`	`interval <numerical_type, interval_kind_> make_safe_interval(numerical_type lhs, numerical_type rhs)`
`177`	`186`	`{`
`178`	`187`	`return interval <numerical_type, interval_kind_>{std::min(lhs, rhs), std::max(lhs, rhs)};`
`@@ -621,6 +630,7 @@ namespace lib_interval_tree`
`621`	`630`	`using iterator = interval_tree_iterator <node_type>;`
`622`	`631`	`using const_iterator = const_interval_tree_iterator <node_type>;`
`623`	`632`	`using size_type = long long;`
	`633`	`+ using this_type = interval_tree<interval_type>;`
`624`	`634`
`625`	`635`	`public:`
`626`	`636`	`friend const_interval_tree_iterator <node_type>;`
`@@ -854,14 +864,14 @@ namespace lib_interval_tree`
`854`	`864`	`{`
`855`	`865`	`if (root_ == nullptr)`
`856`	`866`	`return;`
`857`		`- find_all_i<iterator>(root_, ival, on_find, compare);`
	`867`	`+ find_all_i<this_type, iterator>(this, root_, ival, on_find, compare);`
`858`	`868`	`}`
`859`	`869`	`template <typename FunctionT, typename CompareFunctionT>`
`860`	`870`	`void find_all(interval_type const& ival, FunctionT const& on_find, CompareFunctionT const& compare) const`
`861`	`871`	`{`
`862`	`872`	`if (root_ == nullptr)`
`863`	`873`	`return;`
`864`		`- find_all_i<const_iterator>(root_, ival, on_find, compare);`
	`874`	`+ find_all_i<this_type, const_iterator>(this, root_, ival, on_find, compare);`
`865`	`875`	`}`
`866`	`876`
`867`	`877`	`template <typename FunctionT>`
`@@ -950,19 +960,19 @@ namespace lib_interval_tree`
`950`	`960`	`if (root_ == nullptr)`
`951`	`961`	`return;`
`952`	`962`	`if (exclusive)`
`953`		`- overlap_find_all_i<true, iterator>(root_, ival, on_find);`
	`963`	`+ overlap_find_all_i<this_type, true, iterator>(this, root_, ival, on_find);`
`954`	`964`	`else`
`955`		`- overlap_find_all_i<false, iterator>(root_, ival, on_find);`
	`965`	`+ overlap_find_all_i<this_type, false, iterator>(this, root_, ival, on_find);`
`956`	`966`	`}`
`957`	`967`	`template <typename FunctionT>`
`958`	`968`	`void overlap_find_all(interval_type const& ival, FunctionT const& on_find, bool exclusive = false) const`
`959`	`969`	`{`
`960`	`970`	`if (root_ == nullptr)`
`961`	`971`	`return;`
`962`	`972`	`if (exclusive)`
`963`		`- overlap_find_all_i<true, const_iterator>(root_, ival, on_find);`
	`973`	`+ overlap_find_all_i<this_type, true, const_iterator>(this, root_, ival, on_find);`
`964`	`974`	`else`
`965`		`- overlap_find_all_i<false, const_iterator>(root_, ival, on_find);`
	`975`	`+ overlap_find_all_i<this_type, false, const_iterator>(this, root_, ival, on_find);`
`966`	`976`	`}`
`967`	`977`
`968`	`978`	`/**`
`@@ -1114,36 +1124,43 @@ namespace lib_interval_tree`
`1114`	`1124`	`return nullptr;`
`1115`	`1125`	`};`
`1116`	`1126`
`1117`		`- template <typename IteratorT, typename FunctionT, typename ComparatorFunctionT>`
`1118`		`- bool find_all_i(node_type* ptr, interval_type const& ival, FunctionT const& on_find, ComparatorFunctionT const& compare)`
	`1127`	`+ template <typename ThisType, typename IteratorT, typename FunctionT, typename ComparatorFunctionT>`
	`1128`	`+ static bool find_all_i`
	`1129`	`+ (`
	`1130`	`+ typename std::conditional<std::is_same<IteratorT, iterator>::value, ThisType, ThisType const>::type* self,`
	`1131`	`+ node_type* ptr,`
	`1132`	`+ interval_type const& ival,`
	`1133`	`+ FunctionT const& on_find,`
	`1134`	`+ ComparatorFunctionT const& compare`
	`1135`	`+ )`
`1119`	`1136`	`{`
`1120`	`1137`	`if (compare(ptr->interval(), ival))`
`1121`	`1138`	`{`
`1122`		`- if (!on_find(IteratorT{ptr, this}))`
	`1139`	`+ if (!on_find(IteratorT{ptr, self}))`
`1123`	`1140`	`return false;`
`1124`	`1141`	`}`
`1125`	`1142`	`if (ptr->left_ && ival.high() <= ptr->left_->max())`
`1126`	`1143`	`{`
`1127`	`1144`	`// no right? can only continue left`
`1128`	`1145`	`if (!ptr->right_ \|\| ival.low() > ptr->right_->max())`
`1129`		`- return find_all_i<IteratorT>(ptr->left_, ival, on_find, compare);`
	`1146`	`+ return find_all_i<ThisType, IteratorT>(self, ptr->left_, ival, on_find, compare);`
`1130`	`1147`
`1131`		`- if (!find_all_i<IteratorT>(ptr->left_, ival, on_find, compare))`
	`1148`	`+ if (!find_all_i<ThisType, IteratorT>(self, ptr->left_, ival, on_find, compare))`
`1132`	`1149`	`return false;`
`1133`	`1150`	`}`
`1134`	`1151`	`if (ptr->right_ && ival.high() <= ptr->right_->max())`
`1135`	`1152`	`{`
`1136`	`1153`	`if (!ptr->left_ \|\| ival.low() > ptr->left_->max())`
`1137`		`- return find_all_i<IteratorT>(ptr->right_, ival, on_find, compare);`
	`1154`	`+ return find_all_i<ThisType, IteratorT>(self, ptr->right_, ival, on_find, compare);`
`1138`	`1155`
`1139`		`- if (!find_all_i<IteratorT>(ptr->right_, ival, on_find, compare))`
	`1156`	`+ if (!find_all_i<ThisType, IteratorT>(self, ptr->right_, ival, on_find, compare))`
`1140`	`1157`	`return false;`
`1141`	`1158`	`}`
`1142`	`1159`	`return true;`
`1143`	`1160`	`}`
`1144`	`1161`
`1145`	`1162`	`template <typename ComparatorFunctionT>`
`1146`		`- node_type* find_i(node_type* ptr, interval_type const& ival, ComparatorFunctionT const& compare)`
	`1163`	`+ node_type* find_i(node_type* ptr, interval_type const& ival, ComparatorFunctionT const& compare) const`
`1147`	`1164`	`{`
`1148`	`1165`	`if (compare(ptr->interval(), ival))`
`1149`	`1166`	`return ptr;`
`@@ -1153,7 +1170,7 @@ namespace lib_interval_tree`
`1153`	`1170`
`1154`	`1171`	`// excludes ptr`
`1155`	`1172`	`template <typename ComparatorFunctionT>`
`1156`		`- node_type* find_i_ex(node_type* ptr, interval_type const& ival, ComparatorFunctionT const& compare)`
	`1173`	`+ node_type* find_i_ex(node_type* ptr, interval_type const& ival, ComparatorFunctionT const& compare) const`
`1157`	`1174`	`{`
`1158`	`1175`	`if (ptr->left_ && ival.high() <= ptr->left_->max())`
`1159`	`1176`	`{`
`@@ -1178,7 +1195,7 @@ namespace lib_interval_tree`
`1178`	`1195`	`}`
`1179`	`1196`
`1180`	`1197`	`template <bool Exclusive>`
`1181`		`- node_type* overlap_find_i(node_type* ptr, interval_type const& ival)`
	`1198`	`+ node_type* overlap_find_i(node_type* ptr, interval_type const& ival) const`
`1182`	`1199`	`{`
`1183`	`1200`	`#if __cplusplus >= 201703L`
`1184`	`1201`	`if constexpr (Exclusive)`
`@@ -1198,8 +1215,14 @@ namespace lib_interval_tree`
`1198`	`1215`	`return overlap_find_i_ex<Exclusive>(ptr, ival);`
`1199`	`1216`	`}`
`1200`	`1217`
`1201`		`- template <bool Exclusive, typename IteratorT, typename FunctionT>`
`1202`		`- bool overlap_find_all_i(node_type* ptr, interval_type const& ival, FunctionT const& on_find)`
	`1218`	`+ template <typename ThisType, bool Exclusive, typename IteratorT, typename FunctionT>`
	`1219`	`+ static bool overlap_find_all_i`
	`1220`	`+ (`
	`1221`	`+ typename std::conditional<std::is_same<IteratorT, iterator>::value, ThisType, ThisType const>::type* self,`
	`1222`	`+ node_type* ptr,`
	`1223`	`+ interval_type const& ival,`
	`1224`	`+ FunctionT const& on_find`
	`1225`	`+ )`
`1203`	`1226`	`{`
`1204`	`1227`	`#if __cplusplus >= 201703L`
`1205`	`1228`	`if constexpr (Exclusive)`
`@@ -1209,7 +1232,7 @@ namespace lib_interval_tree`
`1209`	`1232`	`{`
`1210`	`1233`	`if (ptr->interval().overlaps_exclusive(ival))`
`1211`	`1234`	`{`
`1212`		`- if (!on_find(IteratorT{ptr, this}))`
	`1235`	`+ if (!on_find(IteratorT{ptr, self}))`
`1213`	`1236`	`{`
`1214`	`1237`	`return false;`
`1215`	`1238`	`}`
`@@ -1219,7 +1242,7 @@ namespace lib_interval_tree`
`1219`	`1242`	`{`
`1220`	`1243`	`if (ptr->interval().overlaps(ival))`
`1221`	`1244`	`{`
`1222`		`- if (!on_find(IteratorT{ptr, this}))`
	`1245`	`+ if (!on_find(IteratorT{ptr, self}))`
`1223`	`1246`	`{`
`1224`	`1247`	`return false;`
`1225`	`1248`	`}`
`@@ -1230,25 +1253,25 @@ namespace lib_interval_tree`
`1230`	`1253`	`// no right? can only continue left`
`1231`	`1254`	`// or interval low is bigger than max of right branch.`
`1232`	`1255`	`if (!ptr->right_ \|\| ival.low() > ptr->right_->max())`
`1233`		`- return overlap_find_all_i<Exclusive, IteratorT>(ptr->left_, ival, on_find);`
	`1256`	`+ return overlap_find_all_i<ThisType, Exclusive, IteratorT>(self, ptr->left_, ival, on_find);`
`1234`	`1257`
`1235`		`- if (!overlap_find_all_i<Exclusive, IteratorT>(ptr->left_, ival, on_find))`
	`1258`	`+ if (!overlap_find_all_i<ThisType, Exclusive, IteratorT>(self, ptr->left_, ival, on_find))`
`1236`	`1259`	`return false;`
`1237`	`1260`	`}`
`1238`	`1261`	`if (ptr->right_ && ptr->right_->max() >= ival.low())`
`1239`	`1262`	`{`
`1240`	`1263`	`if (!ptr->left_ \|\| ival.low() > ptr->right_->max())`
`1241`		`- return overlap_find_all_i<Exclusive, IteratorT>(ptr->right_, ival, on_find);`
	`1264`	`+ return overlap_find_all_i<ThisType, Exclusive, IteratorT>(self, ptr->right_, ival, on_find);`
`1242`	`1265`
`1243`		`- if (!overlap_find_all_i<Exclusive, IteratorT>(ptr->right_, ival, on_find))`
	`1266`	`+ if (!overlap_find_all_i<ThisType, Exclusive, IteratorT>(self, ptr->right_, ival, on_find))`
`1244`	`1267`	`return false;`
`1245`	`1268`	`}`
`1246`	`1269`	`return true;`
`1247`	`1270`	`}`
`1248`	`1271`
`1249`	`1272`	`// excludes ptr`
`1250`	`1273`	`template <bool Exclusive>`
`1251`		`- node_type* overlap_find_i_ex(node_type* ptr, interval_type const& ival)`
	`1274`	`+ node_type* overlap_find_i_ex(node_type* ptr, interval_type const& ival) const`
`1252`	`1275`	`{`
`1253`	`1276`	`if (ptr->left_ && ptr->left_->max() >= ival.low())`
`1254`	`1277`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,5 @@`
`1`	`1`	`#pragma once`
`2`	`2`
`3`		`-#include <boost/preprocessor/comma.hpp>`
`4`		`-`
`5`	`3`	`#include <limits>`
`6`	`4`
`7`	`5`	`class IntervalTests`
`@@ -30,13 +28,13 @@ class DistanceTests`
`30`	`28`	`{`
`31`	`29`	`public:`
`32`	`30`	`using types = IntervalTypes <int>;`
`33`		`-};`
	`31`	`+};`
`34`	`32`
`35`	`33`	`TEST_F(IntervalTests, FailBadBorders)`
`36`	`34`	`{`
`37`	`35`	`auto f = []()`
`38`	`36`	`{`
`39`		`- [[maybe_unused]] auto ival = types::interval_type{1 BOOST_PP_COMMA() 0};`
	`37`	`+ [[maybe_unused]] auto ival = types::interval_type{1, 0};`
`40`	`38`	`};`
`41`	`39`
`42`	`40`	`EXPECT_DEATH(f(), "low <= high");`