X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=ceph%2Fsrc%2Fboost%2Fboost%2Fgeometry%2Falgorithms%2Fdetail%2Fdisjoint%2Finterface.hpp;fp=ceph%2Fsrc%2Fboost%2Fboost%2Fgeometry%2Falgorithms%2Fdetail%2Fdisjoint%2Finterface.hpp;h=205267db6b7b3505d17e85eb0922241e6094bafd;hb=1e59de90020f1d8d374046ef9cca56ccd4e806e2;hp=fc4aecbb03efdef1367fc3aa83ea6fa8cf5a4b7e;hpb=bd41e436e25044e8e83156060a37c23cb661c364;p=ceph.git

diff --git a/ceph/src/boost/boost/geometry/algorithms/detail/disjoint/interface.hpp b/ceph/src/boost/boost/geometry/algorithms/detail/disjoint/interface.hpp
index fc4aecbb0..205267db6 100644
--- a/ceph/src/boost/boost/geometry/algorithms/detail/disjoint/interface.hpp
+++ b/ceph/src/boost/boost/geometry/algorithms/detail/disjoint/interface.hpp
@@ -5,8 +5,8 @@
 // Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
 // Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
 
-// This file was modified by Oracle on 2013-2017.
-// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+// This file was modified by Oracle on 2013-2021.
+// Modifications copyright (c) 2013-2021, Oracle and/or its affiliates.
 
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
@@ -23,16 +23,16 @@
 
 #include <cstddef>
 
-#include <boost/variant/apply_visitor.hpp>
-#include <boost/variant/static_visitor.hpp>
-#include <boost/variant/variant_fwd.hpp>
-
 #include <boost/geometry/algorithms/detail/relate/interface.hpp>
+#include <boost/geometry/algorithms/detail/visit.hpp>
 #include <boost/geometry/algorithms/dispatch/disjoint.hpp>
 
+#include <boost/geometry/geometries/adapted/boost_variant.hpp> // For backward compatibility
 #include <boost/geometry/geometries/concepts/check.hpp>
 
-#include <boost/geometry/strategies/disjoint.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/detail.hpp>
+#include <boost/geometry/strategies/relate/services.hpp>
 
 
 namespace boost { namespace geometry
@@ -41,9 +41,14 @@ namespace boost { namespace geometry
 namespace resolve_strategy
 {
 
+template
+<
+    typename Strategy,
+    bool IsUmbrella = strategies::detail::is_umbrella_strategy<Strategy>::value
+>
 struct disjoint
 {
-    template <typename Geometry1, typename Geometry2, typename Strategy>
+    template <typename Geometry1, typename Geometry2>
     static inline bool apply(Geometry1 const& geometry1,
                              Geometry2 const& geometry2,
                              Strategy const& strategy)
@@ -53,13 +58,35 @@ struct disjoint
                     Geometry1, Geometry2
                 >::apply(geometry1, geometry2, strategy);
     }
+};
+
+template <typename Strategy>
+struct disjoint<Strategy, false>
+{
+    template <typename Geometry1, typename Geometry2>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        using strategies::relate::services::strategy_converter;
+
+        return dispatch::disjoint
+                <
+                    Geometry1, Geometry2
+                >::apply(geometry1, geometry2,
+                         strategy_converter<Strategy>::get(strategy));
+    }
+};
 
+template <>
+struct disjoint<default_strategy, false>
+{
     template <typename Geometry1, typename Geometry2>
     static inline bool apply(Geometry1 const& geometry1,
                              Geometry2 const& geometry2,
                              default_strategy)
     {
-        typedef typename strategy::disjoint::services::default_strategy
+        typedef typename strategies::relate::services::default_strategy
             <
                 Geometry1, Geometry2
             >::type strategy_type;
@@ -74,13 +101,21 @@ struct disjoint
 } // namespace resolve_strategy
 
 
-namespace resolve_variant {
+namespace resolve_dynamic {
 
-template <typename Geometry1, typename Geometry2>
+template
+<
+    typename Geometry1, typename Geometry2,
+    bool IsDynamic = util::is_dynamic_geometry<Geometry1>::value
+                  || util::is_dynamic_geometry<Geometry2>::value,
+    bool IsCollection = util::is_geometry_collection<Geometry1>::value
+                     || util::is_geometry_collection<Geometry2>::value
+>
 struct disjoint
 {
     template <typename Strategy>
-    static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2,
+                             Strategy const& strategy)
     {
         concepts::check_concepts_and_equal_dimensions
             <
@@ -88,108 +123,60 @@ struct disjoint
                 Geometry2 const
             >();
 
-        return resolve_strategy::disjoint::apply(geometry1, geometry2, strategy);
+        return resolve_strategy::disjoint
+            <
+                Strategy
+            >::apply(geometry1, geometry2, strategy);
     }
 };
 
-template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
-struct disjoint<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+template <typename Geometry1, typename Geometry2>
+struct disjoint<Geometry1, Geometry2, true, false>
 {
     template <typename Strategy>
-    struct visitor: boost::static_visitor<bool>
-    {
-        Geometry2 const& m_geometry2;
-        Strategy const& m_strategy;
-
-        visitor(Geometry2 const& geometry2, Strategy const& strategy)
-            : m_geometry2(geometry2)
-            , m_strategy(strategy)
-        {}
-
-        template <typename Geometry1>
-        bool operator()(Geometry1 const& geometry1) const
-        {
-            return disjoint<Geometry1, Geometry2>::apply(geometry1, m_geometry2, m_strategy);
-        }
-    };
-
-    template <typename Strategy>
-    static inline bool apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
-                             Geometry2 const& geometry2,
+    static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2,
                              Strategy const& strategy)
     {
-        return boost::apply_visitor(visitor<Strategy>(geometry2, strategy), geometry1);
-    }
-};
-
-template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
-struct disjoint<Geometry1, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
-{
-    template <typename Strategy>
-    struct visitor: boost::static_visitor<bool>
-    {
-        Geometry1 const& m_geometry1;
-        Strategy const& m_strategy;
-
-        visitor(Geometry1 const& geometry1, Strategy const& strategy)
-            : m_geometry1(geometry1)
-            , m_strategy(strategy)
-        {}
-
-        template <typename Geometry2>
-        bool operator()(Geometry2 const& geometry2) const
+        bool result = true;
+        detail::visit([&](auto const& g1, auto const& g2)
         {
-            return disjoint<Geometry1, Geometry2>::apply(m_geometry1, geometry2, m_strategy);
-        }
-    };
-
-    template <typename Strategy>
-    static inline bool apply(Geometry1 const& geometry1,
-                             boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
-                             Strategy const& strategy)
-    {
-        return boost::apply_visitor(visitor<Strategy>(geometry1, strategy), geometry2);
+            result = disjoint
+                <
+                    util::remove_cref_t<decltype(g1)>, util::remove_cref_t<decltype(g2)>
+                >::apply(g1, g2, strategy);
+        }, geometry1, geometry2);
+        return result;
     }
 };
 
-template
-<
-    BOOST_VARIANT_ENUM_PARAMS(typename T1),
-    BOOST_VARIANT_ENUM_PARAMS(typename T2)
->
-struct disjoint
-    <
-        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
-        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>
-    >
+// TODO: The complexity is quadratic for two GCs
+//   Decrease e.g. with spatial index
+template <typename Geometry1, typename Geometry2, bool IsDynamic>
+struct disjoint<Geometry1, Geometry2, IsDynamic, true>
 {
     template <typename Strategy>
-    struct visitor: boost::static_visitor<bool>
-    {
-        Strategy const& m_strategy;
-
-        visitor(Strategy const& strategy)
-            : m_strategy(strategy)
-        {}
-
-        template <typename Geometry1, typename Geometry2>
-        bool operator()(Geometry1 const& geometry1,
-                        Geometry2 const& geometry2) const
-        {
-            return disjoint<Geometry1, Geometry2>::apply(geometry1, geometry2, m_strategy);
-        }
-    };
-
-    template <typename Strategy>
-    static inline bool apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
-                             boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+    static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2,
                              Strategy const& strategy)
     {
-        return boost::apply_visitor(visitor<Strategy>(strategy), geometry1, geometry2);
+        bool result = true;
+        detail::visit_breadth_first([&](auto const& g1)
+        {
+            detail::visit_breadth_first([&](auto const& g2)
+            {
+                result = disjoint
+                    <
+                        util::remove_cref_t<decltype(g1)>, util::remove_cref_t<decltype(g2)>
+                    >::apply(g1, g2, strategy);
+                // If any of the combination intersects then the final result is not disjoint
+                return result;
+            }, geometry2);
+            return result;
+        }, geometry1);
+        return result;
     }
 };
 
-} // namespace resolve_variant
+} // namespace resolve_dynamic
 
 
 /*!
@@ -211,7 +198,7 @@ inline bool disjoint(Geometry1 const& geometry1,
                      Geometry2 const& geometry2,
                      Strategy const& strategy)
 {
-    return resolve_variant::disjoint
+    return resolve_dynamic::disjoint
             <
                 Geometry1, Geometry2
             >::apply(geometry1, geometry2, strategy);
@@ -238,7 +225,7 @@ template <typename Geometry1, typename Geometry2>
 inline bool disjoint(Geometry1 const& geometry1,
                      Geometry2 const& geometry2)
 {
-    return resolve_variant::disjoint
+    return resolve_dynamic::disjoint
             <
                 Geometry1, Geometry2
             >::apply(geometry1, geometry2, default_strategy());