From b28a60be2a094b6c7334e2b726855e174d68dbff Mon Sep 17 00:00:00 2001
From: Michele Santullo <micheles@intelligentartefacts.com>
Date: Mon, 27 Jul 2020 11:20:27 +0100
Subject: [PATCH 1/2] Allow custom allocator for vector

Signed-off-by: Michele Santullo <micheles@intelligentartefacts.com>
---
 include/Quadtree.h | 29 +++++++++++++++++++----------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/include/Quadtree.h b/include/Quadtree.h
index f4af30f..7b1665c 100644
--- a/include/Quadtree.h
+++ b/include/Quadtree.h
@@ -10,7 +10,13 @@
 namespace quadtree
 {
 
-template<typename T, typename GetBox, typename Equal = std::equal_to<T>, typename Float = float>
+template<
+    typename T,
+    typename GetBox,
+    typename Equal = std::equal_to<T>,
+    typename Float = float,
+    template <typename> class Allocator = std::allocator
+>
 class Quadtree
 {
     static_assert(std::is_convertible_v<std::invoke_result_t<GetBox, const T&>, Box<Float>>,
@@ -20,6 +26,9 @@ class Quadtree
     static_assert(std::is_arithmetic_v<Float>);
 
 public:
+    template <typename U>
+    using vector_type = std::vector< U, Allocator<U> >;
+
     Quadtree(const Box<Float>& box, const GetBox& getBox = GetBox(),
         const Equal& equal = Equal()) :
         mBox(box), mRoot(std::make_unique<Node>()), mGetBox(getBox), mEqual(equal)
@@ -37,16 +46,16 @@ class Quadtree
         remove(mRoot.get(), nullptr, mBox, value);
     }
 
-    std::vector<T> query(const Box<Float>& box) const
+    vector_type<T> query(const Box<Float>& box) const
     {
-        auto values = std::vector<T>();
+        auto values = vector_type<T>();
         query(mRoot.get(), mBox, box, values);
         return values;
     }
 
-    std::vector<std::pair<T, T>> findAllIntersections() const
+    vector_type<std::pair<T, T>> findAllIntersections() const
     {
-        auto intersections = std::vector<std::pair<T, T>>();
+        auto intersections = vector_type<std::pair<T, T>>();
         findAllIntersections(mRoot.get(), intersections);
         return intersections;
     }
@@ -58,7 +67,7 @@ class Quadtree
     struct Node
     {
         std::array<std::unique_ptr<Node>, 4> children;
-        std::vector<T> values;
+        vector_type<T> values;
     };
 
     Box<Float> mBox;
@@ -165,7 +174,7 @@ class Quadtree
         for (auto& child : node->children)
             child = std::make_unique<Node>();
         // Assign values to children
-        auto newValues = std::vector<T>(); // New values for this node
+        auto newValues = vector_type<T>(); // New values for this node
         for (const auto& value : node->values)
         {
             auto i = getQuadrant(box, mGetBox(value));
@@ -238,7 +247,7 @@ class Quadtree
         }
     }
 
-    void query(Node* node, const Box<Float>& box, const Box<Float>& queryBox, std::vector<T>& values) const
+    void query(Node* node, const Box<Float>& box, const Box<Float>& queryBox, vector_type<T>& values) const
     {
         assert(node != nullptr);
         assert(queryBox.intersects(box));
@@ -258,7 +267,7 @@ class Quadtree
         }
     }
 
-    void findAllIntersections(Node* node, std::vector<std::pair<T, T>>& intersections) const
+    void findAllIntersections(Node* node, vector_type<std::pair<T, T>>& intersections) const
     {
         // Find intersections between values stored in this node
         // Make sure to not report the same intersection twice
@@ -284,7 +293,7 @@ class Quadtree
         }
     }
 
-    void findIntersectionsInDescendants(Node* node, const T& value, std::vector<std::pair<T, T>>& intersections) const
+    void findIntersectionsInDescendants(Node* node, const T& value, vector_type<std::pair<T, T>>& intersections) const
     {
         // Test against the values stored in this node
         for (const auto& other : node->values)

From 0c512f8eb29f3d58c9d6cb0d3dbe8365cca91e9f Mon Sep 17 00:00:00 2001
From: Michele Santullo <micheles@intelligentartefacts.com>
Date: Mon, 27 Jul 2020 11:55:59 +0100
Subject: [PATCH 2/2] Accept functor for overriding usage of std::make_unique

Signed-off-by: Michele Santullo <micheles@intelligentartefacts.com>
---
 include/Quadtree.h | 32 +++++++++++++++++++++++++++-----
 1 file changed, 27 insertions(+), 5 deletions(-)

diff --git a/include/Quadtree.h b/include/Quadtree.h
index 7b1665c..010b069 100644
--- a/include/Quadtree.h
+++ b/include/Quadtree.h
@@ -10,12 +10,26 @@
 namespace quadtree
 {
 
+namespace detail
+{
+    template <typename T>
+    struct StdMakeUnique
+    {
+        template <typename... Args>
+        std::unique_ptr<T> operator() (Args&&... args)
+        {
+            return std::make_unique<T>(std::forward<Args>(args)...);
+        }
+    };
+}
+
 template<
     typename T,
     typename GetBox,
     typename Equal = std::equal_to<T>,
     typename Float = float,
-    template <typename> class Allocator = std::allocator
+    template <typename> class Allocator = std::allocator,
+    template <typename> class MakeUnique = detail::StdMakeUnique
 >
 class Quadtree
 {
@@ -31,7 +45,7 @@ class Quadtree
 
     Quadtree(const Box<Float>& box, const GetBox& getBox = GetBox(),
         const Equal& equal = Equal()) :
-        mBox(box), mRoot(std::make_unique<Node>()), mGetBox(getBox), mEqual(equal)
+        mBox(box), mMakeUnique(), mRoot(mMakeUnique()), mGetBox(getBox), mEqual(equal)
     {
 
     }
@@ -64,14 +78,22 @@ class Quadtree
     static constexpr auto Threshold = std::size_t(16);
     static constexpr auto MaxDepth = std::size_t(8);
 
+    struct Node;
+#if __cplusplus < 201703L
+    typedef typename std::result_of<MakeUnique<Node>()>::type UniqueNodePtr;
+#else
+    typedef std::invoke_result_t<MakeUnique<Node>> UniqueNodePtr;
+#endif
+
     struct Node
     {
-        std::array<std::unique_ptr<Node>, 4> children;
+        std::array<UniqueNodePtr, 4> children;
         vector_type<T> values;
     };
 
     Box<Float> mBox;
-    std::unique_ptr<Node> mRoot;
+    MakeUnique<Node> mMakeUnique;
+    UniqueNodePtr mRoot;
     GetBox mGetBox;
     Equal mEqual;
 
@@ -172,7 +194,7 @@ class Quadtree
         assert(isLeaf(node) && "Only leaves can be split");
         // Create children
         for (auto& child : node->children)
-            child = std::make_unique<Node>();
+            child = mMakeUnique();
         // Assign values to children
         auto newValues = vector_type<T>(); // New values for this node
         for (const auto& value : node->values)