WIP: punch feature

Author: 5cript

.gitignore

@@ -8,6 +8,7 @@ __history/
 *.cbp
 *.png
 .vscode
+.clangd
 build
 
 tests/bin

include/interval-tree/interval_tree.hpp

@@ -1347,35 +1347,164 @@ namespace lib_interval_tree
             return punch({min, max});
         }
 
+        // TODO: private
         /**
-         *  Only works with deoverlapped trees.
-         *  Removes all intervals from the given interval and produces a tree that contains the remaining intervals.
-         *  This is basically the other punch overload with ival = [tree_lowest, tree_highest]
+         * @brief Finds the first interval that is right of the given value and does not contain it.
+         *
+         * @param low
+         * @return node_type*
          */
-        interval_tree punch(interval_type const& ival) const
+        node_type* find_first_not_right_of_i(value_type search_value) const
         {
             if (empty())
-                return {};
+                return nullptr;
+
+            // There can be no interval strictly right of the value, if the value
+            // is larger than the max.
+            if (search_value > root_->max_)
+                return nullptr;
+
+            const auto is_interval_strictly_right_of_value = [search_value](node_type* node) {
+                return node->low() > search_value ||
+                    (node->low() == search_value && !node->interval()->within(search_value));
+            };
+
+            auto* node = root_;
+
+            // If the interval is not strictly right of the value, we can only go down right
+            // And dont have to check left.
+            while (!is_interval_strictly_right_of_value(node) && node->right_)
+                node = node->right_;
+
+            bool go_left = false;
+            bool go_right = false;
+            do
+            {
+                go_left = node->left_ && is_interval_strictly_right_of_value(node->left_);
+                go_right = node->right_ && is_interval_strictly_right_of_value(node->right_);
+
+                if (go_left)
+                    node = node->left_;
+                else if (go_right)
+                    node = node->right_;
+            } while (go_left || go_right);
+
+            if (is_interval_strictly_right_of_value(node))
+                return node;
+
+            // We only end up when node == root_, otherwise we never went down the tree to begin with.
+            return nullptr;
+        }
 
+        /**
+         * Only works with deoverlapped trees.
+         * Removes all intervals from the given interval and produces a tree that contains the remaining intervals.
+         * This is basically the other punch overload with ival = [tree_lowest, tree_highest]
+         *
+         * @param ival The range in which to punch out the gaps as a new tree
+         */
+        interval_tree punch(interval_type const& ival) const
+        {
             interval_tree result;
-            auto i = std::begin(*this);
-            if (ival.low() < i->interval()->low())
-                result.insert({ival.low(), i->interval()->low()});
 
-            for (auto e = end(); i != e; ++i)
+            if (empty())
             {
-                auto next = i;
-                ++next;
-                if (next != e)
-                    result.insert({i->interval()->high(), next->interval()->low()});
-                else
-                    break;
+                // Nothing to punch, so return the whole interval
+                result.insert(ival);
+                return result;
             }
 
-            if (i != end() && i->interval()->high() < ival.high())
-                result.insert({i->interval()->high(), ival.high()});
+            // These two helper functions help to offset the adjacent interval edge depending on the interval type.
 
-            return result;
+            const auto low_with_offset_1 = [](interval_type const& interval) {
+                return interval.low() + (interval.within(interval.low()) ? 1 : 0);
+            };
+            const auto low_with_offset_minus_1 = [](interval_type const& interval) {
+                INTERVAL_TREE_CONSTEXPR_IF(std::is_unsigned<value_type>::value)
+                {
+                    return static_cast<value_type>(
+                        static_cast<std::make_signed<value_type>>(interval.low()) -
+                        (interval.within(interval.low()) ? 1 : 0)
+                    );
+                }
+                return interval.low() - (interval.within(interval.low()) ? 1 : 0);
+            };
+            const auto high_with_offset_1 = [](interval_type const& interval) {
+                return interval.high() + (interval.within(interval.high()) ? 1 : 0);
+            };
+            const auto high_with_offset_minus_1 = [](interval_type const& interval) {
+                INTERVAL_TREE_CONSTEXPR_IF(std::is_unsigned<value_type>::value)
+                {
+                    return static_cast<value_type>(
+                        static_cast<std::make_signed<value_type>>(interval.high()) -
+                        (interval.within(interval.high()) ? 1 : 0)
+                    );
+                }
+                return interval.high() - (interval.within(interval.high()) ? 1 : 0);
+            };
+            const auto is_empty_interval = [](interval_type const& interval) {
+                return !interval.within(interval.low()) && !interval.within(interval.high());
+            };
+            const auto insert_if_not_empty = [&](value_type left, value_type right) {
+                if (left <= right)
+                {
+                    const auto interval = interval_type{left, right};
+                    if (!is_empty_interval(interval))
+                        result.insert(interval);
+                }
+            };
+
+            auto* first_not_right = find_first_not_right_of_i(ival.low);
+            if (first_not_right == nullptr)
+            {
+                // There is no interval not fully right of the interval. So ival is either fully right of the rest of
+                // the tree or the last interval overlaps ival.
+
+                auto last = crbegin();
+                if (!ival.overlaps(*crbegin()))
+                {
+                    // ival is fully right of the tree, so just return a tree with this interval:
+                    result.insert(ival);
+                    return result;
+                }
+
+                if (std::max(ival.high(), last->high()) == last.high())
+                {
+                    // The slice is not going beyond the last interval:
+                    return {};
+                }
+
+                // Slice off the part overlapping over the end of last:
+                // TODO:
+                // if ()
+            }
+            else
+            {
+                // There is an interval left of or inside ival.
+
+                const auto low = [&]() {
+                    if (first_not_right->interval()->overlap(ival))
+                    {
+                        const auto joined = ival.join(*first_not_right->interval()).high();
+                        return joined.high() + (joined.within(joined.high()) ? 1 : 0);
+                    }
+                    else
+                    {
+                        return ival.low();
+                    }
+                }();
+
+                auto next = increment({first_not_right});
+
+                if (next == end())
+                {
+                    value_type high = next->low() - (next->interval()->within(next->low() - 1));
+                }
+                else
+                {
+                    // TODO:
+                }
+            }
         }
 
         iterator begin()

tests/custom_interval_tests.hpp

@@ -51,6 +51,22 @@ struct custom_interval : public lib_interval_tree::interval<numerical_type, inte
             return on_join(other);
         return {std::min(low_, other.low_), std::max(high_, other.high_)};
     }
+
+    /**
+     *  Returns whether the given value is in this.
+     */
+    bool within(value_type value) const
+    {
+        return interval_kind::within(low_, high_, value);
+    }
+
+    /**
+     *  Returns whether the given interval is in this.
+     */
+    bool within(custom_interval const& other) const
+    {
+        return within(other.low_) && within(other.high_);
+    }
 };
 
 struct minimal_custom_interval : public lib_interval_tree::interval<int, lib_interval_tree::closed>

tests/interval_tree_tests.hpp

@@ -108,4 +108,50 @@ TEST_F(IntervalTreeTests, CanMoveBiggerTree)
     {
         EXPECT_EQ(i->low(), i->high() - 5);
     }
-}
+}
+
+TEST_F(IntervalTreeTests, PunchFullyRightOfTree)
+{
+    // TODO:
+}
+
+TEST_F(IntervalTreeTests, PunchOverlapsRightOfTree)
+{
+    // TODO:
+}
+
+TEST_F(IntervalTreeTests, PunchFullyLeftOfTree)
+{
+    // TODO:
+}
+
+TEST_F(IntervalTreeTests, PunchOverlapsLeftOfTree)
+{
+    // TODO:
+}
+
+TEST_F(IntervalTreeTests, PunchEncompassesTree)
+{
+    // TODO:
+}
+
+TEST_F(IntervalTreeTests, PunchWithOpenInterval)
+{}
+
+TEST_F(IntervalTreeTests, PunchWithClosedInterval)
+{}
+
+TEST_F(IntervalTreeTests, PunchWithLeftOpenInterval)
+{}
+
+TEST_F(IntervalTreeTests, PunchWithRightOpenInterval)
+{}
+
+TEST_F(IntervalTreeTests, PunchWithClosedAdjacentInterval)
+{}
+
+TEST_F(IntervalTreeTests, OverlapFreeSubtreePunch)
+{}
+
+TEST_F(IntervalTreeTests, OverlappingSubtreePunch)
+{}