WIP: punch feature

Author: 5cript

README.md

@@ -61,6 +61,11 @@ Create a build folder, navigate there, run cmake and build the tree-tests target
 You might have to adapt the linker line for gtest, if you built it yourself and didn't install it into your system.
 If you want to generate the pretty drawings, install cairo, pull the submodule and pass INT_TREE_DRAW_EXAMPLES=on to the cmake command line to generate a drawings/make_drawings executeable.
 
+Some features of this library require the presence of an optional type.
+If you are using C++17 and up, it will be std::optional.
+Otherwise you can specify INTERVAL_TREE_HAVE_BOOST_OPTIONAL to use boost::optional.
+And if neither, a reduced version of optional is provided in the library, not perfectly exchangeable with std::optional, but sufficient for the library to work.
+
 ## Draw Dot Graph
 This draws a dot graph of the tree:
 ```c++
@@ -137,37 +142,73 @@ Options are:
 
 ## Members of IntervalTree<Interval>
 
-  - [Members of IntervalTree<Interval>](#members-of-intervaltreeinterval)
-    - [iterator insert(interval_type const& ival)](#iterator-insertinterval_type-const-ival)
-    - [iterator insert_overlap(interval_type const& ival, bool, bool)](#iterator-insert_overlapinterval_type-const-ival-bool-bool)
+- [interval-tree](#interval-tree)
+  - [How an interval tree looks like:](#how-an-interval-tree-looks-like)
+  - [Example](#example)
+  - [Compile \& Run Testing](#compile--run-testing)
+  - [Draw Dot Graph](#draw-dot-graph)
+  - [Free Functions](#free-functions)
+    - [interval\<NumericT, Kind\> make\_safe\_interval(NumericT border1, NumericT border2)](#intervalnumerict-kind-make_safe_intervalnumerict-border1-numerict-border2)
+    - [draw\_dot\_graph(std::ostream\& os, interval\_tree\_t const\& tree, DrawOptions const\& options)](#draw_dot_graphstdostream-os-interval_tree_t-const-tree-drawoptions-const-options)
+  - [Members of IntervalTree](#members-of-intervaltree)
+    - [iterator insert(interval\_type const\& ival)](#iterator-insertinterval_type-const-ival)
+      - [Parameters](#parameters)
+    - [iterator insert\_overlap(interval\_type const\& ival, bool, bool)](#iterator-insert_overlapinterval_type-const-ival-bool-bool)
+      - [Parameters](#parameters-1)
     - [iterator erase(iterator iter)](#iterator-eraseiterator-iter)
-    - [size_type size() const](#size_type-size-const)
-    - [(const)iterator find(interval_type const& ival)](#constiterator-findinterval_type-const-ival)
-    - [(const)iterator find(interval_type const& ival, CompareFunctionT const& compare)](#constiterator-findinterval_type-const-ival-comparefunctiont-const-compare)
-    - [(const)iterator find_all(interval_type const& ival, OnFindFunctionT const& on_find)](#constiterator-find_allinterval_type-const-ival-onfindfunctiont-const-on_find)
+      - [Parameters](#parameters-2)
+    - [size\_type size() const](#size_type-size-const)
+    - [(const)iterator find(interval\_type const\& ival)](#constiterator-findinterval_type-const-ival)
+      - [Parameters](#parameters-3)
+    - [(const)iterator find(interval\_type const\& ival, CompareFunctionT const\& compare)](#constiterator-findinterval_type-const-ival-comparefunctiont-const-compare)
+      - [Parameters](#parameters-4)
+    - [(const)iterator find\_all(interval\_type const\& ival, OnFindFunctionT const\& on\_find)](#constiterator-find_allinterval_type-const-ival-onfindfunctiont-const-on_find)
+      - [Parameters](#parameters-5)
       - [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_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)
+    - [(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)
+      - [Parameters](#parameters-6)
+    - [(const)iterator find\_next\_in\_subtree(iterator from, interval\_type const\& ival)](#constiterator-find_next_in_subtreeiterator-from-interval_type-const-ival)
+      - [Parameters](#parameters-7)
+    - [(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)
+      - [Parameters](#parameters-8)
+    - [(const)iterator overlap\_find(interval\_type const\& ival, bool exclusive)](#constiterator-overlap_findinterval_type-const-ival-bool-exclusive)
+      - [Parameters](#parameters-9)
+    - [(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)
+      - [Parameters](#parameters-10)
       - [Example](#example-2)
-    - [(const)iterator overlap_find_next_in_subtree(interval_type const& ival, bool exclusive)](#constiterator-overlap_find_next_in_subtreeinterval_type-const-ival-bool-exclusive)
-    - [interval_tree& deoverlap()](#interval_tree-deoverlap)
+    - [(const)iterator overlap\_find\_next\_in\_subtree(interval\_type const\& ival, bool exclusive)](#constiterator-overlap_find_next_in_subtreeinterval_type-const-ival-bool-exclusive)
+      - [Parameters](#parameters-11)
+    - [interval\_tree\& deoverlap()](#interval_tree-deoverlap)
     - [After deoverlap](#after-deoverlap)
-    - [interval_tree& deoverlap_copy()](#interval_tree-deoverlap_copy)
-    - [interval_tree punch(interval_type const& ival)](#interval_tree-punchinterval_type-const-ival)
-    - [After punching (with [0, 50])](#after-punching-with-0-50)
-    - [interval_tree punch()](#interval_tree-punch)
+    - [interval\_tree deoverlap\_copy()](#interval_tree-deoverlap_copy)
+    - [interval\_tree punch(interval\_type const\& ival)](#interval_tree-punchinterval_type-const-ival)
+    - [After punching (with \[0, 50\])](#after-punching-with-0-50)
+    - [interval\_tree punch()](#interval_tree-punch)
     - [bool empty() const noexcept](#bool-empty-const-noexcept)
     - [iterator begin()](#iterator-begin)
     - [iterator end()](#iterator-end)
     - [iterator cbegin()](#iterator-cbegin)
     - [iterator cend()](#iterator-cend)
-    - [reverse_iterator rbegin()](#reverse_iterator-rbegin)
-    - [reverse_iterator rend()](#reverse_iterator-rend)
-    - [reverse_iterator crbegin()](#reverse_iterator-crbegin)
-    - [reverse_iterator crend()](#reverse_iterator-crend)
+    - [reverse\_iterator rbegin()](#reverse_iterator-rbegin)
+    - [reverse\_iterator rend()](#reverse_iterator-rend)
+    - [reverse\_iterator crbegin()](#reverse_iterator-crbegin)
+    - [reverse\_iterator crend()](#reverse_iterator-crend)
+  - [Members of Interval](#members-of-interval)
+    - [using value\_type](#using-value_type)
+    - [using interval\_kind](#using-interval_kind)
+    - [friend bool operator==(interval const\& lhs, interval const\& other)](#friend-bool-operatorinterval-const-lhs-interval-const-other)
+    - [friend bool operator!=(interval const\& lhs, interval const\& other)](#friend-bool-operatorinterval-const-lhs-interval-const-other-1)
+    - [value\_type low() const](#value_type-low-const)
+    - [value\_type high() const](#value_type-high-const)
+    - [\[\[deprecated\]\] bool overlaps(value\_type l, value\_type h) const](#deprecated-bool-overlapsvalue_type-l-value_type-h-const)
+    - [bool overlaps\_exclusive(value\_type l, value\_type h) const](#bool-overlaps_exclusivevalue_type-l-value_type-h-const)
+    - [bool overlaps(interval const\& other) const](#bool-overlapsinterval-const-other-const)
+    - [bool overlaps\_exclusive(interval const\& other) const](#bool-overlaps_exclusiveinterval-const-other-const)
+    - [bool within(value\_type value) const](#bool-withinvalue_type-value-const)
+    - [bool within(interval const\& other) const](#bool-withininterval-const-other-const)
+    - [value\_type operator-(interval const\& other) const](#value_type-operator-interval-const-other-const)
+    - [value\_type size() const](#value_type-size-const)
+    - [interval join(interval const\& other) const](#interval-joininterval-const-other-const)
 
 ### iterator insert(interval_type const& ival)
 Adds an interval into the tree.

include/interval-tree/interval_tree.hpp

@@ -4,6 +4,7 @@
 #include "interval_types.hpp"
 #include "tree_hooks.hpp"
 #include "feature_test.hpp"
+#include "optional.hpp"
 
 #include <string>
 #include <stdexcept>
@@ -21,6 +22,13 @@ namespace lib_interval_tree
         double_black
     };
     // ############################################################################################################
+    template <typename interval_type>
+    struct slice_type
+    {
+        optional<interval_type> left_slice{};
+        optional<interval_type> right_slice{};
+    };
+    // ############################################################################################################
     using default_interval_value_type = int;
     // ############################################################################################################
     template <typename numerical_type, typename interval_kind_>
@@ -201,6 +209,37 @@ namespace lib_interval_tree
         {
             return interval_kind::size(low_, high_);
         }
+
+        /**
+         * @brief Extrudes other from this interval returning what is remaining.
+         *
+         * @param other
+         * @return slice_type<interval>
+         */
+        slice_type<interval> extrude(interval const& other) const
+        {
+            if (!overlaps(other))
+                return {};
+
+            slice_type<interval> slices{};
+            if (low_ < other.low_)
+            {
+                auto slice = interval{low_, interval_kind::left_slice_upper_bound(other.low_)};
+                // >= comparison avoids overflows in case of unsigned integers
+                if (slice.high_ >= slice.low_ && slice.size() > 0)
+                    slices.left_slice = std::move(slice);
+            }
+            // low_ == other.low_ does not produce a left slice in any case.
+            if (other.high_ > high_)
+            {
+                auto slice = interval{interval_kind::right_slice_lower_bound(high_), other.high_};
+                // >= comparison avoids overflows in case of unsigned integers
+                if (slice.high_ >= slice.low_ && slice.size() > 0)
+                    slices.right_slice = std::move(slice);
+            }
+            // high_ == other.high_ does not produce a right slice in any case.
+            return slices;
+        }
     };
 
     template <typename numerical_type>
@@ -323,6 +362,37 @@ namespace lib_interval_tree
             return right_border_;
         }
 
+        /**
+         * @brief Extrudes other from this interval returning what is remaining.
+         *
+         * @param other
+         * @return slice_type<interval>
+         */
+        slice_type<interval> extrude(interval const& other) const
+        {
+            if (!overlaps(other))
+                return {};
+
+            slice_type<interval> slices{};
+            if (low_ < other.low_)
+            {
+                auto slice = interval{low_, interval_kind::left_slice_upper_bound(other.low_, other.left_border())};
+                // >= comparison avoids overflows in case of unsigned integers
+                if (slice.high_ >= slice.low_ && slice.size() > 0)
+                    slices.left_slice = std::move(slice);
+            }
+            // low_ == other.low_ does not produce a left slice in any case.
+            if (other.high_ > high_)
+            {
+                auto slice = interval{interval_kind::right_slice_lower_bound(high_, right_border_), other.high_};
+                // >= comparison avoids overflows in case of unsigned integers
+                if (slice.high_ >= slice.low_ && slice.size() > 0)
+                    slices.right_slice = std::move(slice);
+            }
+            // high_ == other.high_ does not produce a right slice in any case.
+            return slices;
+        }
+
       protected:
         interval_border left_border_;
         interval_border right_border_;
@@ -1410,97 +1480,58 @@ namespace lib_interval_tree
                 return result;
             }
 
-            // These two helper functions help to offset the adjacent interval edge depending on the interval type.
-
-            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);
+            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.
+                // [LAST] [ival]
+                // or
+                // [LAST]
+                //    [ival]
+                // or
+                // [ LAST ]
+                // [ival]
 
                 auto last = crbegin();
-                if (!ival.overlaps(*crbegin()))
+                if (!ival.overlaps(*last))
                 {
+                    // [LAST] [ival]
                     // 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 ()
+                const auto slices = last->extrude(ival);
+                if (slices.right_slice)
+                    result.insert(std::move(slices.right_slice).value());
             }
             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:
-                }
+                // // 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:
+                // }
             }
+            return result;
         }
 
         iterator begin()