update boost

linx64/include/boost/geometry/index/detail/rtree/visitors/children_box.hpp

@@ -4,6 +4,11 @@
 //
 // Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
 //
+// This file was modified by Oracle on 2019-2023.
+// Modifications copyright (c) 2019-2023 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+//
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -11,20 +16,29 @@
 #ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_CHILDREN_BOX_HPP
 #define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_CHILDREN_BOX_HPP
 
+#include <boost/geometry/index/detail/rtree/node/node.hpp>
+#include <boost/geometry/index/detail/rtree/node/node_elements.hpp>
+
 namespace boost { namespace geometry { namespace index {
 
 namespace detail { namespace rtree { namespace visitors {
 
-template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+template <typename MembersHolder>
 class children_box
-    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+    : public MembersHolder::visitor_const
 {
-    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
-    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+    typedef typename MembersHolder::parameters_type parameters_type;
+    typedef typename MembersHolder::translator_type translator_type;
+    typedef typename MembersHolder::box_type box_type;
+
+    typedef typename MembersHolder::internal_node internal_node;
+    typedef typename MembersHolder::leaf leaf;
 
 public:
-    inline children_box(Box & result, Translator const& tr)
-        : m_result(result), m_tr(tr)
+    inline children_box(box_type & result,
+                        parameters_type const& parameters,
+                        translator_type const& tr)
+        : m_result(result), m_parameters(parameters), m_tr(tr)
     {}
 
     inline void operator()(internal_node const& n)
@@ -32,7 +46,8 @@ public:
         typedef typename rtree::elements_type<internal_node>::type elements_type;
         elements_type const& elements = rtree::elements(n);
 
-        m_result = rtree::elements_box<Box>(elements.begin(), elements.end(), m_tr);
+        m_result = rtree::elements_box<box_type>(elements.begin(), elements.end(), m_tr,
+                                                 index::detail::get_strategy(m_parameters));
     }
 
     inline void operator()(leaf const& n)
@@ -40,12 +55,14 @@ public:
         typedef typename rtree::elements_type<leaf>::type elements_type;
         elements_type const& elements = rtree::elements(n);
 
-        m_result = rtree::values_box<Box>(elements.begin(), elements.end(), m_tr);
+        m_result = rtree::values_box<box_type>(elements.begin(), elements.end(), m_tr,
+                                               index::detail::get_strategy(m_parameters));
     }
 
 private:
-    Box & m_result;
-    Translator const& m_tr;
+    box_type & m_result;
+    parameters_type const& m_parameters;
+    translator_type const& m_tr;
 };
 
 }}} // namespace detail::rtree::visitors

linx64/include/boost/geometry/index/detail/rtree/visitors/copy.hpp

@@ -4,6 +4,10 @@
 //
 // Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
 //
+// This file was modified by Oracle on 2019.
+// Modifications copyright (c) 2019 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+//
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -11,30 +15,34 @@
 #ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_COPY_HPP
 #define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_COPY_HPP
 
+#include <boost/geometry/index/detail/rtree/node/subtree_destroyer.hpp>
+
 namespace boost { namespace geometry { namespace index {
 
 namespace detail { namespace rtree { namespace visitors {
 
-template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+template <typename MembersHolder>
 class copy
-    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, false>::type
+    : public MembersHolder::visitor
 {
+    typedef typename MembersHolder::allocators_type allocators_type;
+
+    typedef typename MembersHolder::node node;
+    typedef typename MembersHolder::internal_node internal_node;
+    typedef typename MembersHolder::leaf leaf;
+
+    typedef rtree::subtree_destroyer<MembersHolder> subtree_destroyer;
+    typedef typename allocators_type::node_pointer node_pointer;
+
 public:
-    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
-    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
-    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
-
-    typedef rtree::subtree_destroyer<Value, Options, Translator, Box, Allocators> subtree_destroyer;
-    typedef typename Allocators::node_pointer node_pointer;
-
-    explicit inline copy(Allocators & allocators)
+    explicit inline copy(allocators_type & allocators)
         : result(0)
         , m_allocators(allocators)
     {}
 
     inline void operator()(internal_node & n)
     {
-        node_pointer raw_new_node = rtree::create_node<Allocators, internal_node>::apply(m_allocators);      // MAY THROW, STRONG (N: alloc)
+        node_pointer raw_new_node = rtree::create_node<allocators_type, internal_node>::apply(m_allocators);      // MAY THROW, STRONG (N: alloc)
         subtree_destroyer new_node(raw_new_node, m_allocators);
 
         typedef typename rtree::elements_type<internal_node>::type elements_type;
@@ -45,7 +53,7 @@ public:
         for (typename elements_type::iterator it = elements.begin();
             it != elements.end(); ++it)
         {
-            rtree::apply_visitor(*this, *it->second);                                                   // MAY THROW (V, E: alloc, copy, N: alloc) 
+            rtree::apply_visitor(*this, *it->second);                                                   // MAY THROW (V, E: alloc, copy, N: alloc)
 
             // for exception safety
             subtree_destroyer auto_result(result, m_allocators);
@@ -61,7 +69,7 @@ public:
 
     inline void operator()(leaf & l)
     {
-        node_pointer raw_new_node = rtree::create_node<Allocators, leaf>::apply(m_allocators);                // MAY THROW, STRONG (N: alloc)
+        node_pointer raw_new_node = rtree::create_node<allocators_type, leaf>::apply(m_allocators);                // MAY THROW, STRONG (N: alloc)
         subtree_destroyer new_node(raw_new_node, m_allocators);
 
         typedef typename rtree::elements_type<leaf>::type elements_type;
@@ -82,7 +90,7 @@ public:
     node_pointer result;
 
 private:
-    Allocators & m_allocators;
+    allocators_type & m_allocators;
 };
 
 }}} // namespace detail::rtree::visitors

linx64/include/boost/geometry/index/detail/rtree/visitors/count.hpp

@@ -4,6 +4,11 @@
 //
 // Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
 //
+// This file was modified by Oracle on 2019-2023.
+// Modifications copyright (c) 2019-2023 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+//
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -11,6 +16,12 @@
 #ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_COUNT_HPP
 #define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_COUNT_HPP
 
+#include <boost/geometry/index/equal_to.hpp>
+#include <boost/geometry/index/detail/algorithms/bounds.hpp>
+#include <boost/geometry/index/detail/rtree/node/node_elements.hpp>
+#include <boost/geometry/index/detail/rtree/node/variant_visitor.hpp>
+#include <boost/geometry/index/parameters.hpp>
+
 namespace boost { namespace geometry { namespace index {
 
 namespace detail { namespace rtree { namespace visitors {
@@ -23,10 +34,10 @@ struct count_helper
     {
         return i;
     }
-    template <typename Translator>
-    static inline bool equals(Indexable const& i, Value const& v, Translator const& tr)
+    template <typename Translator, typename Strategy>
+    static inline bool equals(Indexable const& i, Value const& v, Translator const& tr, Strategy const& s)
     {
-        return geometry::equals(i, tr(v));
+        return index::detail::equals<Indexable>::apply(i, tr(v), s);
     }
 };
 
@@ -38,25 +49,29 @@ struct count_helper<Value, Value>
     {
         return tr(v);
     }
-    template <typename Translator>
-    static inline bool equals(Value const& v1, Value const& v2, Translator const& tr)
+    template <typename Translator, typename Strategy>
+    static inline bool equals(Value const& v1, Value const& v2, Translator const& tr, Strategy const& s)
     {
-        return tr.equals(v1, v2);
+        return tr.equals(v1, v2, s);
     }
 };
 
-template <typename ValueOrIndexable, typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+template <typename ValueOrIndexable, typename MembersHolder>
 struct count
-    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+    : public MembersHolder::visitor_const
 {
-    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
-    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
-    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+    typedef typename MembersHolder::value_type value_type;
+    typedef typename MembersHolder::parameters_type parameters_type;
+    typedef typename MembersHolder::translator_type translator_type;
 
-    typedef count_helper<ValueOrIndexable, Value> count_help;
+    typedef typename MembersHolder::node node;
+    typedef typename MembersHolder::internal_node internal_node;
+    typedef typename MembersHolder::leaf leaf;
 
-    inline count(ValueOrIndexable const& vori, Translator const& t)
-        : value_or_indexable(vori), tr(t), found_count(0)
+    typedef count_helper<ValueOrIndexable, value_type> count_help;
+
+    inline count(ValueOrIndexable const& vori, parameters_type const& parameters, translator_type const& t)
+        : value_or_indexable(vori), m_parameters(parameters), tr(t), found_count(0)
     {}
 
     inline void operator()(internal_node const& n)
@@ -68,10 +83,9 @@ struct count
         for (typename elements_type::const_iterator it = elements.begin();
              it != elements.end(); ++it)
         {
-            if ( geometry::covered_by(
-                    return_ref_or_bounds(
-                        count_help::indexable(value_or_indexable, tr)),
-                    it->first) )
+            if ( index::detail::covered_by_bounds(count_help::indexable(value_or_indexable, tr),
+                                                  it->first,
+                                                  index::detail::get_strategy(m_parameters)) )
             {
                 rtree::apply_visitor(*this, *it->second);
             }
@@ -88,7 +102,8 @@ struct count
              it != elements.end(); ++it)
         {
             // if value meets predicates
-            if ( count_help::equals(value_or_indexable, *it, tr) )
+            if ( count_help::equals(value_or_indexable, *it, tr,
+                                    index::detail::get_strategy(m_parameters)) )
             {
                 ++found_count;
             }
@@ -96,8 +111,9 @@ struct count
     }
 
     ValueOrIndexable const& value_or_indexable;
-    Translator const& tr;
-    typename Allocators::size_type found_count;
+    parameters_type const& m_parameters;
+    translator_type const& tr;
+    typename MembersHolder::size_type found_count;
 };
 
 }}} // namespace detail::rtree::visitors

linx64/include/boost/geometry/index/detail/rtree/visitors/destroy.hpp

@@ -4,6 +4,11 @@
 //
 // Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
 //
+// This file was modified by Oracle on 2019-2023.
+// Modifications copyright (c) 2019-2023 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+//
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -11,23 +16,28 @@
 #ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_DELETE_HPP
 #define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_DELETE_HPP
 
+#include <boost/geometry/index/detail/rtree/node/concept.hpp>
+#include <boost/geometry/index/detail/rtree/node/node_elements.hpp>
+#include <boost/geometry/index/detail/rtree/node/weak_visitor.hpp>
+
 namespace boost { namespace geometry { namespace index {
 
 namespace detail { namespace rtree { namespace visitors {
 
-template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+template <typename MembersHolder>
 class destroy
-    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, false>::type
+    : public MembersHolder::visitor
 {
 public:
-    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
-    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
-    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+    typedef typename MembersHolder::node node;
+    typedef typename MembersHolder::internal_node internal_node;
+    typedef typename MembersHolder::leaf leaf;
 
-    typedef typename Allocators::node_pointer node_pointer;
+    typedef typename MembersHolder::allocators_type allocators_type;
+    typedef typename MembersHolder::node_pointer node_pointer;
 
-    inline destroy(node_pointer root_node, Allocators & allocators)
-        : m_current_node(root_node)
+    inline destroy(node_pointer node, allocators_type & allocators)
+        : m_current_node(node)
         , m_allocators(allocators)
     {}
 
@@ -48,7 +58,7 @@ public:
             it->second = 0;
         }
 
-        rtree::destroy_node<Allocators, internal_node>::apply(m_allocators, node_to_destroy);
+        rtree::destroy_node<allocators_type, internal_node>::apply(m_allocators, node_to_destroy);
     }
 
     inline void operator()(leaf & l)
@@ -56,12 +66,18 @@ public:
         boost::ignore_unused(l);
         BOOST_GEOMETRY_INDEX_ASSERT(&l == &rtree::get<leaf>(*m_current_node), "invalid pointers");
 
-        rtree::destroy_node<Allocators, leaf>::apply(m_allocators, m_current_node);
+        rtree::destroy_node<allocators_type, leaf>::apply(m_allocators, m_current_node);
+    }
+
+    static inline void apply(node_pointer node, allocators_type & allocators)
+    {
+        destroy v(node, allocators);
+        rtree::apply_visitor(v, *node);
     }
 
 private:
     node_pointer m_current_node;
-    Allocators & m_allocators;
+    allocators_type & m_allocators;
 };
 
 }}} // namespace detail::rtree::visitors

linx64/include/boost/geometry/index/detail/rtree/visitors/insert.hpp

@@ -2,7 +2,12 @@
 //
 // R-tree inserting visitor implementation
 //
-// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2011-2023 Adam Wulkiewicz, Lodz, Poland.
+//
+// This file was modified by Oracle on 2019-2023.
+// Modifications copyright (c) 2019-2023 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 //
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -11,39 +16,53 @@
 #ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_INSERT_HPP
 #define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_INSERT_HPP
 
-#include <boost/type_traits/is_same.hpp>
+#ifdef BOOST_GEOMETRY_INDEX_EXPERIMENTAL_ENLARGE_BY_EPSILON
+#include <type_traits>
+#endif
 
 #include <boost/geometry/algorithms/detail/expand_by_epsilon.hpp>
-#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/core/static_assert.hpp>
 
+#include <boost/geometry/index/detail/algorithms/bounds.hpp>
 #include <boost/geometry/index/detail/algorithms/content.hpp>
+#include <boost/geometry/index/detail/rtree/node/node.hpp>
+#include <boost/geometry/index/detail/rtree/node/node_elements.hpp>
+#include <boost/geometry/index/detail/rtree/node/subtree_destroyer.hpp>
+#include <boost/geometry/index/detail/rtree/options.hpp>
+
+#include <boost/geometry/util/condition.hpp>
 
 namespace boost { namespace geometry { namespace index {
 
 namespace detail { namespace rtree {
 
 // Default choose_next_node
-template <typename Value, typename Options, typename Box, typename Allocators, typename ChooseNextNodeTag>
+template
+<
+    typename MembersHolder,
+    typename ChooseNextNodeTag = typename MembersHolder::options_type::choose_next_node_tag
+>
 class choose_next_node;
 
-template <typename Value, typename Options, typename Box, typename Allocators>
-class choose_next_node<Value, Options, Box, Allocators, choose_by_content_diff_tag>
+template <typename MembersHolder>
+class choose_next_node<MembersHolder, choose_by_content_diff_tag>
 {
 public:
-    typedef typename Options::parameters_type parameters_type;
+    typedef typename MembersHolder::box_type box_type;
+    typedef typename MembersHolder::parameters_type parameters_type;
 
-    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
-    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
-    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+    typedef typename MembersHolder::node node;
+    typedef typename MembersHolder::internal_node internal_node;
+    typedef typename MembersHolder::leaf leaf;
 
     typedef typename rtree::elements_type<internal_node>::type children_type;
 
-    typedef typename index::detail::default_content_result<Box>::type content_type;
+    typedef typename index::detail::default_content_result<box_type>::type content_type;
 
     template <typename Indexable>
     static inline size_t apply(internal_node & n,
                                Indexable const& indexable,
-                               parameters_type const& /*parameters*/,
+                               parameters_type const& parameters,
                                size_t /*node_relative_level*/)
     {
         children_type & children = rtree::elements(n);
@@ -64,8 +83,9 @@ public:
             child_type const& ch_i = children[i];
 
             // expanded child node's box
-            Box box_exp(ch_i.first);
-            geometry::expand(box_exp, indexable);
+            box_type box_exp(ch_i.first);
+            index::detail::expand(box_exp, indexable,
+                                  index::detail::get_strategy(parameters));
 
             // areas difference
             content_type content = index::detail::content(box_exp);
@@ -88,39 +108,49 @@ public:
 // ----------------------------------------------------------------------- //
 
 // Not implemented here
-template <typename Value, typename Options, typename Translator, typename Box, typename Allocators, typename RedistributeTag>
+template
+<
+    typename MembersHolder,
+    typename RedistributeTag = typename MembersHolder::options_type::redistribute_tag
+>
 struct redistribute_elements
 {
-    BOOST_MPL_ASSERT_MSG(
-        (false),
-        NOT_IMPLEMENTED_FOR_THIS_REDISTRIBUTE_TAG_TYPE,
-        (redistribute_elements));
+    BOOST_GEOMETRY_STATIC_ASSERT_FALSE(
+        "Not implemented for this RedistributeTag type.",
+        MembersHolder, RedistributeTag);
 };
 
 // ----------------------------------------------------------------------- //
 
 // Split algorithm
-template <typename Value, typename Options, typename Translator, typename Box, typename Allocators, typename SplitTag>
+template
+<
+    typename MembersHolder,
+    typename SplitTag = typename MembersHolder::options_type::split_tag
+>
 class split
 {
-    BOOST_MPL_ASSERT_MSG(
-        (false),
-        NOT_IMPLEMENTED_FOR_THIS_SPLIT_TAG_TYPE,
-        (split));
+    BOOST_GEOMETRY_STATIC_ASSERT_FALSE(
+        "Not implemented for this SplitTag type.",
+        MembersHolder, SplitTag);
 };
 
 // Default split algorithm
-template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
-class split<Value, Options, Translator, Box, Allocators, split_default_tag>
+template <typename MembersHolder>
+class split<MembersHolder, split_default_tag>
 {
 protected:
-    typedef typename Options::parameters_type parameters_type;
+    typedef typename MembersHolder::parameters_type parameters_type;
+    typedef typename MembersHolder::box_type box_type;
+    typedef typename MembersHolder::translator_type translator_type;
+    typedef typename MembersHolder::allocators_type allocators_type;
+    typedef typename MembersHolder::size_type size_type;
 
-    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
-    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
-    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+    typedef typename MembersHolder::node node;
+    typedef typename MembersHolder::internal_node internal_node;
+    typedef typename MembersHolder::leaf leaf;
 
-    typedef rtree::subtree_destroyer<Value, Options, Translator, Box, Allocators> subtree_destroyer;
+    typedef typename MembersHolder::node_pointer node_pointer;
 
 public:
     typedef index::detail::varray<
@@ -131,51 +161,63 @@ public:
     template <typename Node>
     static inline void apply(nodes_container_type & additional_nodes,
                              Node & n,
-                             Box & n_box,
+                             box_type & n_box,
                              parameters_type const& parameters,
-                             Translator const& translator,
-                             Allocators & allocators)
+                             translator_type const& translator,
+                             allocators_type & allocators)
     {
         // TODO - consider creating nodes always with sufficient memory allocated
 
         // create additional node, use auto destroyer for automatic destruction on exception
-        subtree_destroyer second_node(rtree::create_node<Allocators, Node>::apply(allocators), allocators);     // MAY THROW, STRONG (N: alloc)
+        node_pointer n2_ptr = rtree::create_node<allocators_type, Node>::apply(allocators);                  // MAY THROW, STRONG (N: alloc)
         // create reference to the newly created node
-        Node & n2 = rtree::get<Node>(*second_node);
+        Node & n2 = rtree::get<Node>(*n2_ptr);
 
-        // NOTE: thread-safety
-        // After throwing an exception by redistribute_elements the original node may be not changed or
-        // both nodes may be empty. In both cases the tree won't be valid r-tree.
-        // The alternative is to create 2 (or more) additional nodes here and store backup info
-        // in the original node, then, if exception was thrown, the node would always have more than max
-        // elements.
-        // The alternative is to use moving semantics in the implementations of redistribute_elements,
-        // it will be possible to throw from boost::move() in the case of e.g. static size nodes.
+        BOOST_TRY
+        {
+            // NOTE: thread-safety
+            // After throwing an exception by redistribute_elements the original node may be not changed or
+            // both nodes may be empty. In both cases the tree won't be valid r-tree.
+            // The alternative is to create 2 (or more) additional nodes here and store backup info
+            // in the original node, then, if exception was thrown, the node would always have more than max
+            // elements.
+            // The alternative is to use moving semantics in the implementations of redistribute_elements,
+            // it will be possible to throw from std::move() in the case of e.g. static size nodes.
 
-        // redistribute elements
-        Box box2;
-        redistribute_elements<
-            Value,
-            Options,
-            Translator,
-            Box,
-            Allocators,
-            typename Options::redistribute_tag
-        >::apply(n, n2, n_box, box2, parameters, translator, allocators);                                   // MAY THROW (V, E: alloc, copy, copy)
+            // redistribute elements
+            box_type box2;
+            redistribute_elements<MembersHolder>
+                ::apply(n, n2, n_box, box2, parameters, translator, allocators);                                   // MAY THROW (V, E: alloc, copy, copy)
 
-        // check numbers of elements
-        BOOST_GEOMETRY_INDEX_ASSERT(parameters.get_min_elements() <= rtree::elements(n).size() &&
-            rtree::elements(n).size() <= parameters.get_max_elements(),
-            "unexpected number of elements");
-        BOOST_GEOMETRY_INDEX_ASSERT(parameters.get_min_elements() <= rtree::elements(n2).size() &&
-            rtree::elements(n2).size() <= parameters.get_max_elements(),
-            "unexpected number of elements");
+            // check numbers of elements
+            BOOST_GEOMETRY_INDEX_ASSERT(parameters.get_min_elements() <= rtree::elements(n).size() &&
+                rtree::elements(n).size() <= parameters.get_max_elements(),
+                "unexpected number of elements");
+            BOOST_GEOMETRY_INDEX_ASSERT(parameters.get_min_elements() <= rtree::elements(n2).size() &&
+                rtree::elements(n2).size() <= parameters.get_max_elements(),
+                "unexpected number of elements");
 
-        // return the list of newly created nodes (this algorithm returns one)
-        additional_nodes.push_back(rtree::make_ptr_pair(box2, second_node.get()));                           // MAY THROW, STRONG (alloc, copy)
+            // return the list of newly created nodes (this algorithm returns one)
+            additional_nodes.push_back(rtree::make_ptr_pair(box2, n2_ptr));                                  // MAY THROW, STRONG (alloc, copy)
+        }
+        BOOST_CATCH(...)
+        {
+            // NOTE: This code is here to prevent leaving the rtree in a state
+            //  after an exception is thrown in which pushing new element could
+            //  result in assert or putting it outside the memory of node elements.
+            typename rtree::elements_type<Node>::type & elements = rtree::elements(n);
+            size_type const max_size = parameters.get_max_elements();
+            if (elements.size() > max_size)
+            {
+                rtree::destroy_element<MembersHolder>::apply(elements[max_size], allocators);
+                elements.pop_back();
+            }
 
-        // release the ptr
-        second_node.release();
+            rtree::visitors::destroy<MembersHolder>::apply(n2_ptr, allocators);
+
+            BOOST_RETHROW
+        }
+        BOOST_CATCH_END
     }
 };
 
@@ -226,30 +268,34 @@ struct insert_traverse_data
 };
 
 // Default insert visitor
-template <typename Element, typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+template <typename Element, typename MembersHolder>
 class insert
-    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, false>::type
+    : public MembersHolder::visitor
 {
 protected:
-    typedef typename Options::parameters_type parameters_type;
+    typedef typename MembersHolder::box_type box_type;
+    typedef typename MembersHolder::value_type value_type;
+    typedef typename MembersHolder::parameters_type parameters_type;
+    typedef typename MembersHolder::translator_type translator_type;
+    typedef typename MembersHolder::allocators_type allocators_type;
 
-    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
-    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
-    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+    typedef typename MembersHolder::node node;
+    typedef typename MembersHolder::internal_node internal_node;
+    typedef typename MembersHolder::leaf leaf;
 
-    typedef rtree::subtree_destroyer<Value, Options, Translator, Box, Allocators> subtree_destroyer;
-    typedef typename Allocators::node_pointer node_pointer;
-    typedef typename Allocators::size_type size_type;
+    typedef rtree::subtree_destroyer<MembersHolder> subtree_destroyer;
+    typedef typename allocators_type::node_pointer node_pointer;
+    typedef typename allocators_type::size_type size_type;
 
-    //typedef typename Allocators::internal_node_pointer internal_node_pointer;
+    //typedef typename allocators_type::internal_node_pointer internal_node_pointer;
     typedef internal_node * internal_node_pointer;
 
     inline insert(node_pointer & root,
                   size_type & leafs_level,
                   Element const& element,
                   parameters_type const& parameters,
-                  Translator const& translator,
-                  Allocators & allocators,
+                  translator_type const& translator,
+                  allocators_type & allocators,
                   size_type relative_level = 0
     )
         : m_element(element)
@@ -274,17 +320,19 @@ protected:
         // NOTE: This is actually only needed because conditionally the bounding
         //       object may be expanded below. Otherwise the indexable could be
         //       directly used instead
-        index::detail::bounds(rtree::element_indexable(m_element, m_translator), m_element_bounds);
+        index::detail::bounds(rtree::element_indexable(m_element, m_translator),
+                              m_element_bounds,
+                              index::detail::get_strategy(m_parameters));
 
 #ifdef BOOST_GEOMETRY_INDEX_EXPERIMENTAL_ENLARGE_BY_EPSILON
         // Enlarge it in case if it's not bounding geometry type.
         // It's because Points and Segments are compared WRT machine epsilon
         // This ensures that leafs bounds correspond to the stored elements
         if (BOOST_GEOMETRY_CONDITION((
-                boost::is_same<Element, Value>::value
+                std::is_same<Element, value_type>::value
              && ! index::detail::is_bounding_geometry
                     <
-                        typename indexable_type<Translator>::type
+                        typename indexable_type<translator_type>::type
                     >::value )) )
         {
             geometry::detail::expand_by_epsilon(m_element_bounds);
@@ -296,14 +344,16 @@ protected:
     inline void traverse(Visitor & visitor, internal_node & n)
     {
         // choose next node
-        size_t choosen_node_index = rtree::choose_next_node<Value, Options, Box, Allocators, typename Options::choose_next_node_tag>::
-            apply(n, rtree::element_indexable(m_element, m_translator), m_parameters, m_leafs_level - m_traverse_data.current_level);
+        size_t choosen_node_index = rtree::choose_next_node<MembersHolder>
+            ::apply(n, rtree::element_indexable(m_element, m_translator),
+                    m_parameters,
+                    m_leafs_level - m_traverse_data.current_level);
 
         // expand the node to contain value
-        geometry::expand(
+        index::detail::expand(
             rtree::elements(n)[choosen_node_index].first,
-            m_element_bounds
-            /*rtree::element_indexable(m_element, m_translator)*/);
+            m_element_bounds,
+            index::detail::get_strategy(m_parameters));
 
         // next traversing step
         traverse_apply_visitor(visitor, n, choosen_node_index);                                                 // MAY THROW (V, E: alloc, copy, N:alloc)
@@ -349,10 +399,10 @@ protected:
     template <typename Node>
     inline void split(Node & n) const
     {
-        typedef rtree::split<Value, Options, Translator, Box, Allocators, typename Options::split_tag> split_algo;
+        typedef rtree::split<MembersHolder> split_algo;
 
         typename split_algo::nodes_container_type additional_nodes;
-        Box n_box;
+        box_type n_box;
 
         split_algo::apply(additional_nodes, n, n_box, m_parameters, m_translator, m_allocators);                // MAY THROW (V, E: alloc, copy, N:alloc)
 
@@ -376,10 +426,10 @@ protected:
         // It's because Points and Segments are compared WRT machine epsilon
         // This ensures that leafs' bounds correspond to the stored elements.
         if (BOOST_GEOMETRY_CONDITION((
-                boost::is_same<Node, leaf>::value
+                std::is_same<Node, leaf>::value
              && ! index::detail::is_bounding_geometry
                     <
-                        typename indexable_type<Translator>::type
+                        typename indexable_type<translator_type>::type
                     >::value )))
         {
             geometry::detail::expand_by_epsilon(n_box);
@@ -401,7 +451,7 @@ protected:
             BOOST_GEOMETRY_INDEX_ASSERT(&n == &rtree::get<Node>(*m_root_node), "node should be the root");
 
             // create new root and add nodes
-            subtree_destroyer new_root(rtree::create_node<Allocators, internal_node>::apply(m_allocators), m_allocators); // MAY THROW, STRONG (N:alloc)
+            subtree_destroyer new_root(rtree::create_node<allocators_type, internal_node>::apply(m_allocators), m_allocators); // MAY THROW, STRONG (N:alloc)
 
             BOOST_TRY
             {
@@ -428,9 +478,9 @@ protected:
     // TODO: awulkiew - implement dispatchable split::apply to enable additional nodes creation
 
     Element const& m_element;
-    Box m_element_bounds;
+    box_type m_element_bounds;
     parameters_type const& m_parameters;
-    Translator const& m_translator;
+    translator_type const& m_translator;
     size_type const m_relative_level;
     size_type const m_level;
 
@@ -440,30 +490,39 @@ protected:
     // traversing input parameters
     insert_traverse_data<internal_node, internal_node_pointer, size_type> m_traverse_data;
 
-    Allocators & m_allocators;
+    allocators_type & m_allocators;
 };
 
 } // namespace detail
 
 // Insert visitor forward declaration
-template <typename Element, typename Value, typename Options, typename Translator, typename Box, typename Allocators, typename InsertTag>
+template
+<
+    typename Element,
+    typename MembersHolder,
+    typename InsertTag = typename MembersHolder::options_type::insert_tag
+>
 class insert;
 
 // Default insert visitor used for nodes elements
 // After passing the Element to insert visitor the Element is managed by the tree
 // I.e. one should not delete the node passed to the insert visitor after exception is thrown
 // because this visitor may delete it
-template <typename Element, typename Value, typename Options, typename Translator, typename Box, typename Allocators>
-class insert<Element, Value, Options, Translator, Box, Allocators, insert_default_tag>
-    : public detail::insert<Element, Value, Options, Translator, Box, Allocators>
+template <typename Element, typename MembersHolder>
+class insert<Element, MembersHolder, insert_default_tag>
+    : public detail::insert<Element, MembersHolder>
 {
 public:
-    typedef detail::insert<Element, Value, Options, Translator, Box, Allocators> base;
+    typedef detail::insert<Element, MembersHolder> base;
+
+    typedef typename base::parameters_type parameters_type;
+    typedef typename base::translator_type translator_type;
+    typedef typename base::allocators_type allocators_type;
+
     typedef typename base::node node;
     typedef typename base::internal_node internal_node;
     typedef typename base::leaf leaf;
 
-    typedef typename Options::parameters_type parameters_type;
     typedef typename base::node_pointer node_pointer;
     typedef typename base::size_type size_type;
 
@@ -471,8 +530,8 @@ public:
                   size_type & leafs_level,
                   Element const& element,
                   parameters_type const& parameters,
-                  Translator const& translator,
-                  Allocators & allocators,
+                  translator_type const& translator,
+                  allocators_type & allocators,
                   size_type relative_level = 0
     )
         : base(root, leafs_level, element, parameters, translator, allocators, relative_level)
@@ -500,8 +559,7 @@ public:
             {
                 // if the insert fails above, the element won't be stored in the tree
 
-                rtree::visitors::destroy<Value, Options, Translator, Box, Allocators> del_v(base::m_element.second, base::m_allocators);
-                rtree::apply_visitor(del_v, *base::m_element.second);
+                rtree::visitors::destroy<MembersHolder>::apply(base::m_element.second, base::m_allocators);
 
                 BOOST_RETHROW                                                                                     // RETHROW
             }
@@ -518,26 +576,31 @@ public:
 };
 
 // Default insert visitor specialized for Values elements
-template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
-class insert<Value, Value, Options, Translator, Box, Allocators, insert_default_tag>
-    : public detail::insert<Value, Value, Options, Translator, Box, Allocators>
+template <typename MembersHolder>
+class insert<typename MembersHolder::value_type, MembersHolder, insert_default_tag>
+    : public detail::insert<typename MembersHolder::value_type, MembersHolder>
 {
 public:
-    typedef detail::insert<Value, Value, Options, Translator, Box, Allocators> base;
+    typedef detail::insert<typename MembersHolder::value_type, MembersHolder> base;
+
+    typedef typename base::value_type value_type;
+    typedef typename base::parameters_type parameters_type;
+    typedef typename base::translator_type translator_type;
+    typedef typename base::allocators_type allocators_type;
+
     typedef typename base::node node;
     typedef typename base::internal_node internal_node;
     typedef typename base::leaf leaf;
 
-    typedef typename Options::parameters_type parameters_type;
     typedef typename base::node_pointer node_pointer;
     typedef typename base::size_type size_type;
 
     inline insert(node_pointer & root,
                   size_type & leafs_level,
-                  Value const& value,
+                  value_type const& value,
                   parameters_type const& parameters,
-                  Translator const& translator,
-                  Allocators & allocators,
+                  translator_type const& translator,
+                  allocators_type & allocators,
                   size_type relative_level = 0
     )
         : base(root, leafs_level, value, parameters, translator, allocators, relative_level)
@@ -559,7 +622,7 @@ public:
         BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level == base::m_leafs_level, "unexpected level");
         BOOST_GEOMETRY_INDEX_ASSERT(base::m_level == base::m_traverse_data.current_level ||
                                     base::m_level == (std::numeric_limits<size_t>::max)(), "unexpected level");
-        
+
         rtree::elements(n).push_back(base::m_element);                                                              // MAY THROW, STRONG (V: alloc, copy)
 
         base::post_traverse(n);                                                                                     // MAY THROW (V: alloc, copy, N: alloc)

linx64/include/boost/geometry/index/detail/rtree/visitors/is_leaf.hpp

@@ -4,6 +4,10 @@
 //
 // Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
 //
+// This file was modified by Oracle on 2019.
+// Modifications copyright (c) 2019 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+//
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -15,11 +19,12 @@ namespace boost { namespace geometry { namespace index {
 
 namespace detail { namespace rtree { namespace visitors {
 
-template <typename Value, typename Options, typename Box, typename Allocators>
-struct is_leaf : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+template <typename MembersHolder>
+struct is_leaf
+    : public MembersHolder::visitor_const
 {
-    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
-    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+    typedef typename MembersHolder::internal_node internal_node;
+    typedef typename MembersHolder::leaf leaf;
 
     is_leaf()
         : result(false)

linx64/include/boost/geometry/index/detail/rtree/visitors/iterator.hpp

@@ -4,6 +4,11 @@
 //
 // Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
 //
+// This file was modified by Oracle on 2021-2023.
+// Modifications copyright (c) 2021-2023 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+//
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -11,6 +16,10 @@
 #ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_ITERATOR_HPP
 #define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_ITERATOR_HPP
 
+#include <boost/geometry/index/detail/rtree/node/concept.hpp>
+#include <boost/geometry/index/detail/rtree/node/node_elements.hpp>
+#include <boost/geometry/index/detail/rtree/node/variant_visitor.hpp>
+
 namespace boost { namespace geometry { namespace index {
 
 namespace detail { namespace rtree { namespace visitors {

linx64/include/boost/geometry/index/detail/rtree/visitors/remove.hpp

@@ -4,6 +4,11 @@
 //
 // Copyright (c) 2011-2017 Adam Wulkiewicz, Lodz, Poland.
 //
+// This file was modified by Oracle on 2019-2023.
+// Modifications copyright (c) 2019-2023 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+//
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -11,28 +16,39 @@
 #ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_REMOVE_HPP
 #define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_REMOVE_HPP
 
-#include <boost/geometry/index/detail/rtree/visitors/is_leaf.hpp>
-
 #include <boost/geometry/algorithms/detail/covered_by/interface.hpp>
 
+#include <boost/geometry/index/parameters.hpp>
+#include <boost/geometry/index/detail/algorithms/bounds.hpp>
+#include <boost/geometry/index/detail/rtree/node/node.hpp>
+#include <boost/geometry/index/detail/rtree/node/node_elements.hpp>
+#include <boost/geometry/index/detail/rtree/node/subtree_destroyer.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/destroy.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/insert.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/is_leaf.hpp>
+
 namespace boost { namespace geometry { namespace index {
 
 namespace detail { namespace rtree { namespace visitors {
 
 // Default remove algorithm
-template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+template <typename MembersHolder>
 class remove
-    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, false>::type
+    : public MembersHolder::visitor
 {
-    typedef typename Options::parameters_type parameters_type;
+    typedef typename MembersHolder::box_type box_type;
+    typedef typename MembersHolder::value_type value_type;
+    typedef typename MembersHolder::parameters_type parameters_type;
+    typedef typename MembersHolder::translator_type translator_type;
+    typedef typename MembersHolder::allocators_type allocators_type;
 
-    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
-    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
-    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+    typedef typename MembersHolder::node node;
+    typedef typename MembersHolder::internal_node internal_node;
+    typedef typename MembersHolder::leaf leaf;
 
-    typedef rtree::subtree_destroyer<Value, Options, Translator, Box, Allocators> subtree_destroyer;
-    typedef typename Allocators::node_pointer node_pointer;
-    typedef typename Allocators::size_type size_type;
+    typedef rtree::subtree_destroyer<MembersHolder> subtree_destroyer;
+    typedef typename allocators_type::node_pointer node_pointer;
+    typedef typename allocators_type::size_type size_type;
 
     typedef typename rtree::elements_type<internal_node>::type::size_type internal_size_type;
 
@@ -42,10 +58,10 @@ class remove
 public:
     inline remove(node_pointer & root,
                   size_type & leafs_level,
-                  Value const& value,
+                  value_type const& value,
                   parameters_type const& parameters,
-                  Translator const& translator,
-                  Allocators & allocators)
+                  translator_type const& translator,
+                  allocators_type & allocators)
         : m_value(value)
         , m_parameters(parameters)
         , m_translator(translator)
@@ -71,9 +87,9 @@ public:
         internal_size_type child_node_index = 0;
         for ( ; child_node_index < children.size() ; ++child_node_index )
         {
-            if ( geometry::covered_by(
-                    return_ref_or_bounds(m_translator(m_value)),
-                    children[child_node_index].first) )
+            if ( index::detail::covered_by_bounds(m_translator(m_value),
+                                                  children[child_node_index].first,
+                                                  index::detail::get_strategy(m_parameters)) )
             {
                 // next traversing step
                 traverse_apply_visitor(n, child_node_index);                                                            // MAY THROW
@@ -112,7 +128,8 @@ public:
                 BOOST_GEOMETRY_INDEX_ASSERT((elements.size() < m_parameters.get_min_elements()) == m_is_underflow, "unexpected state");
 
                 rtree::elements(*m_parent)[m_current_child_index].first
-                    = rtree::elements_box<Box>(elements.begin(), elements.end(), m_translator);
+                    = rtree::elements_box<box_type>(elements.begin(), elements.end(), m_translator,
+                                                    index::detail::get_strategy(m_parameters));
             }
             // n is root node
             else
@@ -135,7 +152,7 @@ public:
                         m_root_node = rtree::elements(n)[0].second;
                     --m_leafs_level;
 
-                    rtree::destroy_node<Allocators, internal_node>::apply(m_allocators, root_to_destroy);
+                    rtree::destroy_node<allocators_type, internal_node>::apply(m_allocators, root_to_destroy);
                 }
             }
         }
@@ -149,7 +166,7 @@ public:
         // find value and remove it
         for ( typename elements_type::iterator it = elements.begin() ; it != elements.end() ; ++it )
         {
-            if ( m_translator.equals(*it, m_value) )
+            if ( m_translator.equals(*it, m_value, index::detail::get_strategy(m_parameters)) )
             {
                 rtree::move_from_back(elements, it);                                                           // MAY THROW (V: copy)
                 elements.pop_back();
@@ -170,7 +187,8 @@ public:
             if ( 0 != m_parent )
             {
                 rtree::elements(*m_parent)[m_current_child_index].first
-                    = rtree::values_box<Box>(elements.begin(), elements.end(), m_translator);
+                    = rtree::values_box<box_type>(elements.begin(), elements.end(), m_translator,
+                                                  index::detail::get_strategy(m_parameters));
             }
         }
     }
@@ -182,7 +200,7 @@ public:
 
 private:
 
-    typedef std::vector< std::pair<size_type, node_pointer> > UnderflowNodes;
+    typedef std::vector< std::pair<size_type, node_pointer> > underflow_nodes;
 
     void traverse_apply_visitor(internal_node &n, internal_size_type choosen_node_index)
     {
@@ -233,14 +251,14 @@ private:
 
     static inline bool is_leaf(node const& n)
     {
-        visitors::is_leaf<Value, Options, Box, Allocators> ilv;
+        visitors::is_leaf<MembersHolder> ilv;
         rtree::apply_visitor(ilv, n);
         return ilv.result;
     }
 
     void reinsert_removed_nodes_elements()
     {
-        typename UnderflowNodes::reverse_iterator it = m_underflowed_nodes.rbegin();
+        typename underflow_nodes::reverse_iterator it = m_underflowed_nodes.rbegin();
 
         BOOST_TRY
         {
@@ -256,13 +274,13 @@ private:
                 {
                     reinsert_node_elements(rtree::get<leaf>(*it->second), it->first);                        // MAY THROW (V, E: alloc, copy, N: alloc)
 
-                    rtree::destroy_node<Allocators, leaf>::apply(m_allocators, it->second);
+                    rtree::destroy_node<allocators_type, leaf>::apply(m_allocators, it->second);
                 }
                 else
                 {
                     reinsert_node_elements(rtree::get<internal_node>(*it->second), it->first);               // MAY THROW (V, E: alloc, copy, N: alloc)
 
-                    rtree::destroy_node<Allocators, internal_node>::apply(m_allocators, it->second);
+                    rtree::destroy_node<allocators_type, internal_node>::apply(m_allocators, it->second);
                 }
             }
 
@@ -273,7 +291,7 @@ private:
             // destroy current and remaining nodes
             for ( ; it != m_underflowed_nodes.rend() ; ++it )
             {
-                subtree_destroyer dummy(it->second, m_allocators);
+                rtree::visitors::destroy<MembersHolder>::apply(it->second, m_allocators);
             }
 
             //m_underflowed_nodes.clear();
@@ -294,14 +312,10 @@ private:
         {
             for ( ; it != elements.end() ; ++it )
             {
-                visitors::insert<
-                    typename elements_type::value_type,
-                    Value, Options, Translator, Box, Allocators,
-                    typename Options::insert_tag
-                > insert_v(
-                    m_root_node, m_leafs_level, *it,
-                    m_parameters, m_translator, m_allocators,
-                    node_relative_level - 1);
+                visitors::insert<typename elements_type::value_type, MembersHolder>
+                    insert_v(m_root_node, m_leafs_level, *it,
+                             m_parameters, m_translator, m_allocators,
+                             node_relative_level - 1);
 
                 rtree::apply_visitor(insert_v, *m_root_node);                                               // MAY THROW (V, E: alloc, copy, N: alloc)
             }
@@ -309,24 +323,23 @@ private:
         BOOST_CATCH(...)
         {
             ++it;
-            rtree::destroy_elements<Value, Options, Translator, Box, Allocators>
-                ::apply(it, elements.end(), m_allocators);
+            rtree::destroy_elements<MembersHolder>::apply(it, elements.end(), m_allocators);
             elements.clear();
             BOOST_RETHROW                                                                                     // RETHROW
         }
         BOOST_CATCH_END
     }
 
-    Value const& m_value;
+    value_type const& m_value;
     parameters_type const& m_parameters;
-    Translator const& m_translator;
-    Allocators & m_allocators;
+    translator_type const& m_translator;
+    allocators_type & m_allocators;
 
     node_pointer & m_root_node;
     size_type & m_leafs_level;
 
     bool m_is_value_removed;
-    UnderflowNodes m_underflowed_nodes;
+    underflow_nodes m_underflowed_nodes;
 
     // traversing input parameters
     internal_node_pointer m_parent;

linx64/include/boost/geometry/index/detail/rtree/visitors/spatial_query.hpp

@@ -4,6 +4,11 @@
 //
 // Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
 //
+// This file was modified by Oracle on 2019-2023.
+// Modifications copyright (c) 2019-2023 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+//
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -11,116 +16,145 @@
 #ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_SPATIAL_QUERY_HPP
 #define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_SPATIAL_QUERY_HPP
 
+#include <boost/geometry/index/detail/rtree/node/node_elements.hpp>
+#include <boost/geometry/index/detail/rtree/node/weak_visitor.hpp>
+#include <boost/geometry/index/detail/predicates.hpp>
+#include <boost/geometry/index/parameters.hpp>
+
 namespace boost { namespace geometry { namespace index {
 
 namespace detail { namespace rtree { namespace visitors {
 
-template <typename Value, typename Options, typename Translator, typename Box, typename Allocators, typename Predicates, typename OutIter>
+template <typename MembersHolder, typename Predicates, typename OutIter>
 struct spatial_query
-    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
 {
-    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
-    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
-    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+    typedef typename MembersHolder::parameters_type parameters_type;
+    typedef typename MembersHolder::translator_type translator_type;
+    typedef typename MembersHolder::allocators_type allocators_type;
 
-    typedef typename Allocators::size_type size_type;
+    typedef typename index::detail::strategy_type<parameters_type>::type strategy_type;
 
-    static const unsigned predicates_len = index::detail::predicates_length<Predicates>::value;
+    typedef typename MembersHolder::node node;
+    typedef typename MembersHolder::internal_node internal_node;
+    typedef typename MembersHolder::leaf leaf;
 
-    inline spatial_query(Translator const& t, Predicates const& p, OutIter out_it)
-        : tr(t), pred(p), out_iter(out_it), found_count(0)
+    typedef typename allocators_type::node_pointer node_pointer;
+    typedef typename allocators_type::size_type size_type;
+
+    spatial_query(MembersHolder const& members, Predicates const& p, OutIter out_it)
+        : m_tr(members.translator())
+        , m_strategy(index::detail::get_strategy(members.parameters()))
+        , m_pred(p)
+        , m_out_iter(out_it)
+        , m_found_count(0)
     {}
 
-    inline void operator()(internal_node const& n)
+    size_type apply(node_pointer ptr, size_type reverse_level)
     {
-        typedef typename rtree::elements_type<internal_node>::type elements_type;
-        elements_type const& elements = rtree::elements(n);
-
-        // traverse nodes meeting predicates
-        for (typename elements_type::const_iterator it = elements.begin();
-            it != elements.end(); ++it)
+        namespace id = index::detail;
+        if (reverse_level > 0)
         {
-            // if node meets predicates
-            // 0 - dummy value
-            if ( index::detail::predicates_check<index::detail::bounds_tag, 0, predicates_len>(pred, 0, it->first) )
-                rtree::apply_visitor(*this, *it->second);
-        }
-    }
-
-    inline void operator()(leaf const& n)
-    {
-        typedef typename rtree::elements_type<leaf>::type elements_type;
-        elements_type const& elements = rtree::elements(n);
-
-        // get all values meeting predicates
-        for (typename elements_type::const_iterator it = elements.begin();
-            it != elements.end(); ++it)
-        {
-            // if value meets predicates
-            if ( index::detail::predicates_check<index::detail::value_tag, 0, predicates_len>(pred, *it, tr(*it)) )
+            internal_node& n = rtree::get<internal_node>(*ptr);
+            // traverse nodes meeting predicates
+            for (auto const& p : rtree::elements(n))
             {
-                *out_iter = *it;
-                ++out_iter;
-
-                ++found_count;
+                // if node meets predicates (0 is dummy value)
+                if (id::predicates_check<id::bounds_tag>(m_pred, 0, p.first, m_strategy))
+                {
+                    apply(p.second, reverse_level - 1);
+                }
             }
         }
+        else
+        {
+            leaf& n = rtree::get<leaf>(*ptr);
+            // get all values meeting predicates
+            for (auto const& v : rtree::elements(n))
+            {
+                // if value meets predicates
+                if (id::predicates_check<id::value_tag>(m_pred, v, m_tr(v), m_strategy))
+                {
+                    *m_out_iter = v;
+                    ++m_out_iter;
+                    ++m_found_count;
+                }
+            }
+        }
+
+        return m_found_count;
     }
 
-    Translator const& tr;
+    size_type apply(MembersHolder const& members)
+    {
+        return apply(members.root, members.leafs_level);
+    }
 
-    Predicates pred;
+private:
+    translator_type const& m_tr;
+    strategy_type m_strategy;
 
-    OutIter out_iter;
-    size_type found_count;
+    Predicates const& m_pred;
+    OutIter m_out_iter;
+
+    size_type m_found_count;
 };
 
-template <typename Value, typename Options, typename Translator, typename Box, typename Allocators, typename Predicates>
+template <typename MembersHolder, typename Predicates>
 class spatial_query_incremental
-    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
 {
-public:
-    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
-    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
-    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+    typedef typename MembersHolder::value_type value_type;
+    typedef typename MembersHolder::parameters_type parameters_type;
+    typedef typename MembersHolder::translator_type translator_type;
+    typedef typename MembersHolder::allocators_type allocators_type;
 
-    typedef typename Allocators::size_type size_type;
-    typedef typename Allocators::const_reference const_reference;
-    typedef typename Allocators::node_pointer node_pointer;
+    typedef typename index::detail::strategy_type<parameters_type>::type strategy_type;
+
+    typedef typename MembersHolder::node node;
+    typedef typename MembersHolder::internal_node internal_node;
+    typedef typename MembersHolder::leaf leaf;
+
+    typedef typename allocators_type::size_type size_type;
+    typedef typename allocators_type::const_reference const_reference;
+    typedef typename allocators_type::node_pointer node_pointer;
 
     typedef typename rtree::elements_type<internal_node>::type::const_iterator internal_iterator;
     typedef typename rtree::elements_type<leaf>::type leaf_elements;
     typedef typename rtree::elements_type<leaf>::type::const_iterator leaf_iterator;
 
-    static const unsigned predicates_len = index::detail::predicates_length<Predicates>::value;
+    struct internal_data
+    {
+        internal_data(internal_iterator f, internal_iterator l, size_type rl)
+            : first(f), last(l), reverse_level(rl)
+        {}
+        internal_iterator first;
+        internal_iterator last;
+        size_type reverse_level;
+    };
 
-    inline spatial_query_incremental()
-        : m_translator(NULL)
+public:
+    spatial_query_incremental()
+        : m_translator(nullptr)
+//        , m_strategy()
 //        , m_pred()
-        , m_values(NULL)
+        , m_values(nullptr)
         , m_current()
     {}
 
-    inline spatial_query_incremental(Translator const& t, Predicates const& p)
-        : m_translator(::boost::addressof(t))
+    spatial_query_incremental(Predicates const& p)
+        : m_translator(nullptr)
+//        , m_strategy()
         , m_pred(p)
-        , m_values(NULL)
+        , m_values(nullptr)
         , m_current()
     {}
 
-    inline void operator()(internal_node const& n)
-    {
-        typedef typename rtree::elements_type<internal_node>::type elements_type;
-        elements_type const& elements = rtree::elements(n);
-
-        m_internal_stack.push_back(std::make_pair(elements.begin(), elements.end()));
-    }
-
-    inline void operator()(leaf const& n)
-    {
-        m_values = ::boost::addressof(rtree::elements(n));
-        m_current = rtree::elements(n).begin();
-    }
+    spatial_query_incremental(MembersHolder const& members, Predicates const& p)
+        : m_translator(::boost::addressof(members.translator()))
+        , m_strategy(index::detail::get_strategy(members.parameters()))
+        , m_pred(p)
+        , m_values(nullptr)
+        , m_current()
+    {}
 
     const_reference dereference() const
     {
@@ -128,9 +162,9 @@ public:
         return *m_current;
     }
 
-    void initialize(node_pointer root)
+    void initialize(MembersHolder const& members)
     {
-        rtree::apply_visitor(*this, *root);
+        apply(members.root, members.leafs_level);
         search_value();
     }
 
@@ -140,8 +174,38 @@ public:
         search_value();
     }
 
+    bool is_end() const
+    {
+        return 0 == m_values;
+    }
+
+    friend bool operator==(spatial_query_incremental const& l, spatial_query_incremental const& r)
+    {
+        return (l.m_values == r.m_values) && (0 == l.m_values || l.m_current == r.m_current);
+    }
+
+private:
+    void apply(node_pointer ptr, size_type reverse_level)
+    {
+        namespace id = index::detail;
+
+        if (reverse_level > 0)
+        {
+            internal_node& n = rtree::get<internal_node>(*ptr);
+            auto const& elements = rtree::elements(n);
+            m_internal_stack.push_back(internal_data(elements.begin(), elements.end(), reverse_level - 1));
+        }
+        else
+        {
+            leaf& n = rtree::get<leaf>(*ptr);
+            m_values = ::boost::addressof(rtree::elements(n));
+            m_current = rtree::elements(n).begin();
+        }
+    }
+
     void search_value()
     {
+        namespace id = index::detail;
         for (;;)
         {
             // if leaf is choosen, move to the next value in leaf
@@ -150,9 +214,11 @@ public:
                 if ( m_current != m_values->end() )
                 {
                     // return if next value is found
-                    Value const& v = *m_current;
-                    if ( index::detail::predicates_check<index::detail::value_tag, 0, predicates_len>(m_pred, v, (*m_translator)(v)) )
+                    value_type const& v = *m_current;
+                    if (id::predicates_check<id::value_tag>(m_pred, v, (*m_translator)(v), m_strategy))
+                    {
                         return;
+                    }
 
                     ++m_current;
                 }
@@ -166,43 +232,38 @@ public:
             else
             {
                 // return if there is no more nodes to traverse
-                if ( m_internal_stack.empty() )
+                if (m_internal_stack.empty())
+                {
                     return;
+                }
+
+                internal_data& current_data = m_internal_stack.back();
 
                 // no more children in current node, remove it from stack
-                if ( m_internal_stack.back().first == m_internal_stack.back().second )
+                if (current_data.first == current_data.last)
                 {
                     m_internal_stack.pop_back();
                     continue;
                 }
 
-                internal_iterator it = m_internal_stack.back().first;
-                ++m_internal_stack.back().first;
+                internal_iterator it = current_data.first;
+                ++current_data.first;
 
                 // next node is found, push it to the stack
-                if ( index::detail::predicates_check<index::detail::bounds_tag, 0, predicates_len>(m_pred, 0, it->first) )
-                    rtree::apply_visitor(*this, *(it->second));
+                if (id::predicates_check<id::bounds_tag>(m_pred, 0, it->first, m_strategy))
+                {
+                    apply(it->second, current_data.reverse_level);
+                }
             }
         }
     }
 
-    bool is_end() const
-    {
-        return 0 == m_values;
-    }
-
-    friend bool operator==(spatial_query_incremental const& l, spatial_query_incremental const& r)
-    {
-        return (l.m_values == r.m_values) && (0 == l.m_values || l.m_current == r.m_current );
-    }
-
-private:
-
-    const Translator * m_translator;
+    const translator_type * m_translator;
+    strategy_type m_strategy;
 
     Predicates m_pred;
 
-    std::vector< std::pair<internal_iterator, internal_iterator> > m_internal_stack;
+    std::vector<internal_data> m_internal_stack;
     const leaf_elements * m_values;
     leaf_iterator m_current;
 };