Reimplemented punch feature properly.

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.

drawings/example_drawings.hpp

@@ -2,7 +2,9 @@
 
 #include <interval-tree/draw.hpp>
 
+#include <random>
 #include <string>
+#include <iostream>
 
 static void drawDocExample()
 {
@@ -31,7 +33,7 @@ static void drawFromTests1()
 
     interval_tree_t<int> tree;
 
-    std::vector <interval_tree_t<int>::interval_type> intervalCollection;
+    std::vector<interval_tree_t<int>::interval_type> intervalCollection;
 
     intervalCollection.push_back({-51, 11});
     intervalCollection.push_back({26, 68});
@@ -67,8 +69,120 @@ static void drawFromTests1()
     drawTree("drawings/from_tests_1_deoverlapped.png", tree, false, false);
 }
 
+static void drawLargeOverlapFree()
+{
+    using namespace lib_interval_tree;
+
+    interval_tree_t<int> tree;
+
+    for (int i = 0; i < 30; ++i)
+    {
+        tree.insert({i * 10, i * 10 + 5});
+    }
+
+    drawTree("drawings/large_overlap_free.png", tree, false, false);
+
+    std::vector<std::pair<int, int>> intervals;
+    for (int i = 0; i < 30; ++i)
+    {
+        intervals.emplace_back(i * 10, i * 10 + 5);
+    }
+
+    // insert shuffled into new tree
+    interval_tree_t<int> tree2;
+    std::mt19937 rng(std::random_device{}());
+    std::shuffle(intervals.begin(), intervals.end(), rng);
+    for (const auto& interval : intervals)
+    {
+        tree2.insert({interval.first, interval.second});
+    }
+    drawTree("drawings/large_overlap_free_shuffled.png", tree2, false, false);
+}
+
+static void drawOpenPunchExample()
+{
+    constexpr int iterations = 5;
+    using namespace lib_interval_tree;
+
+    interval_tree<interval<int, open>> tree;
+
+    // insert shuffled into new tree
+    std::vector<std::pair<int, int>> intervals;
+    for (int i = 0; i < iterations; ++i)
+    {
+        intervals.emplace_back(i * 10, i * 10 + 5);
+    }
+
+    std::mt19937 rng(std::random_device{}());
+    std::shuffle(intervals.begin(), intervals.end(), rng);
+    for (const auto& interval : intervals)
+    {
+        tree.insert({interval.first, interval.second});
+    }
+
+    drawTree("drawings/open_punch_source.png", tree, false, false);
+    const auto punched = tree.punch({-10, iterations * 10 + 10});
+    drawTree("drawings/open_punched.png", punched, false, false);
+}
+
+static void drawClosedPunchExample()
+{
+    constexpr int iterations = 5;
+    using namespace lib_interval_tree;
+
+    interval_tree<interval<int, closed>> tree;
+
+    // insert shuffled into new tree
+    std::vector<std::pair<int, int>> intervals;
+    for (int i = 0; i < iterations; ++i)
+    {
+        intervals.emplace_back(i * 10, i * 10 + 5);
+    }
+
+    std::mt19937 rng(std::random_device{}());
+    std::shuffle(intervals.begin(), intervals.end(), rng);
+    for (const auto& interval : intervals)
+    {
+        tree.insert({interval.first, interval.second});
+    }
+
+    drawTree("drawings/closed_punch_source.png", tree, false, false);
+    const auto punched = tree.punch({-10, iterations * 10 + 10});
+    drawTree("drawings/closed_punched.png", punched, false, false);
+}
+
+static void drawFloatPunchExample()
+{
+    constexpr int iterations = 5;
+    using namespace lib_interval_tree;
+
+    interval_tree<interval<float, closed>> tree;
+
+    // insert shuffled into new tree
+    std::vector<std::pair<float, float>> intervals;
+    for (int i = 0; i < iterations; ++i)
+    {
+        intervals.emplace_back(i * 10.0f, i * 10.0f + 5.0f);
+    }
+
+    std::mt19937 rng(std::random_device{}());
+    std::shuffle(intervals.begin(), intervals.end(), rng);
+    for (const auto& interval : intervals)
+    {
+        tree.insert({interval.first, interval.second});
+    }
+
+    drawTree("drawings/float_punch_source.png", tree, false, false);
+    const auto punched = tree.punch({-10.0f, iterations * 10.0f + 10.0f});
+    drawTree("drawings/float_punched.png", punched, false, false);
+}
+
 static void drawAll()
 {
     drawDocExample();
     drawFromTests1();
+    drawLargeOverlapFree();
+    drawOpenPunchExample();
+    drawClosedPunchExample();
+    drawFloatPunchExample();
 }