[setops] Add suport for tupled-output in difference, sym_difference and union_.

Author: awulkiew

include/boost/geometry/algorithms/difference.hpp

@@ -2,8 +2,8 @@
 
 // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
 
-// This file was modified by Oracle on 2017, 2019.
-// Modifications copyright (c) 2017, 2019, Oracle and/or its affiliates.
+// This file was modified by Oracle on 2017, 2019, 2020.
+// Modifications copyright (c) 2017-2020, Oracle and/or its affiliates.
 
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 
@@ -19,6 +19,7 @@
 #include <boost/variant/static_visitor.hpp>
 #include <boost/variant/variant_fwd.hpp>
 
+#include <boost/geometry/algorithms/detail/intersection/multi.hpp>
 #include <boost/geometry/algorithms/detail/overlay/intersection_insert.hpp>
 #include <boost/geometry/policies/robustness/get_rescale_policy.hpp>
 #include <boost/geometry/strategies/default_strategy.hpp>
@@ -32,6 +33,146 @@ namespace boost { namespace geometry
 namespace detail { namespace difference
 {
 
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename SingleOut,
+    typename OutTag = typename detail::setop_insert_output_tag<SingleOut>::type,
+    bool ReturnGeometry1 = (topological_dimension<Geometry1>::value
+                            > topological_dimension<Geometry2>::value)
+>
+struct call_intersection_insert
+{
+    template
+    <
+        typename OutputIterator,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline OutputIterator apply(Geometry1 const& geometry1,
+                                       Geometry2 const& geometry2,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator out,
+                                       Strategy const& strategy)
+    {
+        return geometry::dispatch::intersection_insert
+            <
+                Geometry1, Geometry2,
+                SingleOut,
+                overlay_difference,
+                geometry::detail::overlay::do_reverse<geometry::point_order<Geometry1>::value>::value,
+                geometry::detail::overlay::do_reverse<geometry::point_order<Geometry2>::value, true>::value
+            >::apply(geometry1, geometry2, robust_policy, out, strategy);
+    }
+};
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename SingleOut
+>
+struct call_intersection_insert_tupled_base
+{
+    typedef typename geometry::detail::casted_tag_to_single_tag
+        <
+            typename geometry::tag_cast
+                <
+                    typename geometry::tag<Geometry1>::type,
+                    pointlike_tag, linear_tag, areal_tag
+                >::type
+        >::type single_tag;
+
+    typedef detail::expect_output
+        <
+            Geometry1, Geometry2, SingleOut, single_tag
+        > expect_check;
+
+    typedef typename geometry::detail::output_geometry_access
+        <
+            SingleOut, single_tag, single_tag
+        > access;
+};
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename SingleOut
+>
+struct call_intersection_insert
+    <
+        Geometry1, Geometry2, SingleOut,
+        detail::tupled_output_tag,
+        false
+    >
+    : call_intersection_insert_tupled_base<Geometry1, Geometry2, SingleOut>
+{
+    typedef call_intersection_insert_tupled_base<Geometry1, Geometry2, SingleOut> base_t;
+
+    template
+    <
+        typename OutputIterator,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline OutputIterator apply(Geometry1 const& geometry1,
+                                       Geometry2 const& geometry2,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator out,
+                                       Strategy const& strategy)
+    {
+        base_t::access::get(out) = call_intersection_insert
+            <
+                Geometry1, Geometry2,
+                typename base_t::access::type
+            >::apply(geometry1, geometry2, robust_policy,
+                     base_t::access::get(out), strategy);
+
+        return out;
+    }
+};
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename SingleOut
+>
+struct call_intersection_insert
+    <
+        Geometry1, Geometry2, SingleOut,
+        detail::tupled_output_tag,
+        true
+    >
+    : call_intersection_insert_tupled_base<Geometry1, Geometry2, SingleOut>
+{
+    typedef call_intersection_insert_tupled_base<Geometry1, Geometry2, SingleOut> base_t;
+
+    template
+    <
+        typename OutputIterator,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline OutputIterator apply(Geometry1 const& geometry1,
+                                       Geometry2 const& geometry2,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator out,
+                                       Strategy const& strategy)
+    {
+        base_t::access::get(out) = geometry::detail::convert_to_output
+            <
+                Geometry1,
+                typename base_t::access::type
+            >::apply(geometry1, base_t::access::get(out));
+
+        return out;
+    }
+};
+
+
 /*!
 \brief_calc2{difference} \brief_strategy
 \ingroup difference
@@ -65,7 +206,8 @@ inline OutputIterator difference_insert(Geometry1 const& geometry1,
 {
     concepts::check<Geometry1 const>();
     concepts::check<Geometry2 const>();
-    concepts::check<GeometryOut>();
+    //concepts::check<GeometryOut>();
+    geometry::detail::output_geometry_concept_check<GeometryOut>::apply();
 
     typedef typename geometry::rescale_overlay_policy_type
         <
@@ -75,16 +217,12 @@ inline OutputIterator difference_insert(Geometry1 const& geometry1,
         >::type rescale_policy_type;
 
     rescale_policy_type robust_policy
-            = geometry::get_rescale_policy<rescale_policy_type>(
-                geometry1, geometry2, strategy);
+        = geometry::get_rescale_policy<rescale_policy_type>(
+            geometry1, geometry2, strategy);
 
-    return geometry::dispatch::intersection_insert
+    return geometry::detail::difference::call_intersection_insert
         <
-            Geometry1, Geometry2,
-            GeometryOut,
-            overlay_difference,
-            geometry::detail::overlay::do_reverse<geometry::point_order<Geometry1>::value>::value,
-            geometry::detail::overlay::do_reverse<geometry::point_order<Geometry2>::value, true>::value
+            Geometry1, Geometry2, GeometryOut
         >::apply(geometry1, geometry2, robust_policy, out, strategy);
 }
 
@@ -146,11 +284,14 @@ struct difference
                              Collection & output_collection,
                              Strategy const& strategy)
     {
-        typedef typename boost::range_value<Collection>::type geometry_out;
+        typedef typename geometry::detail::output_geometry_value
+            <
+                Collection
+            >::type single_out;
 
-        detail::difference::difference_insert<geometry_out>(
+        detail::difference::difference_insert<single_out>(
             geometry1, geometry2,
-            range::back_inserter(output_collection),
+            geometry::detail::output_geometry_back_inserter(output_collection),
             strategy);
     }
 
@@ -165,11 +306,13 @@ struct difference
                              Collection & output_collection,
                              default_strategy)
     {
-        typedef typename boost::range_value<Collection>::type geometry_out;
+        typedef typename strategy::relate::services::default_strategy
+            <
+                Geometry1,
+                Geometry2
+            >::type strategy_type;
 
-        detail::difference::difference_insert<geometry_out>(
-            geometry1, geometry2,
-            range::back_inserter(output_collection));
+        apply(geometry1, geometry2, output_collection, strategy_type());
     }
 };