update ceph source to reef 18.1.2

[ceph.git] / ceph / src / boost / boost / geometry / algorithms / detail / overlay / get_turn_info_ll.hpp

diff --git a/ceph/src/boost/boost/geometry/algorithms/detail/overlay/get_turn_info_ll.hpp b/ceph/src/boost/boost/geometry/algorithms/detail/overlay/get_turn_info_ll.hpp
index 0ea937a1e4e297a5bb5e38d2e46507a9c762dc1a..396a941c124a9bc37203c4fb09b345083bcef88a 100644 (file)
--- a/ceph/src/boost/boost/geometry/algorithms/detail/overlay/get_turn_info_ll.hpp
+++ b/ceph/src/boost/boost/geometry/algorithms/detail/overlay/get_turn_info_ll.hpp
@@ -75,7 +75,7 @@ struct get_turn_info_linear_linear
                 get_turn_info_for_endpoint<true, true>
                     ::apply(range_p, range_q,
                             tp_model, inters, method_none, out,
-                            umbrella_strategy.get_point_in_point_strategy());
+                            umbrella_strategy);
                 break;
 
             case 'd' : // disjoint: never do anything
@@ -83,24 +83,21 @@ struct get_turn_info_linear_linear
 
             case 'm' :
             {
+                using handler = touch_interior<TurnInfo, verify_policy_ll>;
+
                 if ( get_turn_info_for_endpoint<false, true>
                         ::apply(range_p, range_q,
                                 tp_model, inters, method_touch_interior, out,
-                                umbrella_strategy.get_point_in_point_strategy()) )
+                                umbrella_strategy) )
                 {
                     // do nothing
                 }
                 else
                 {
-                    typedef touch_interior
-                        <
-                            TurnInfo
-                        > policy;
-
                     // If Q (1) arrives (1)
                     if ( inters.d_info().arrival[1] == 1)
                     {
-                        policy::template apply<0>(range_p, range_q, tp,
+                        handler::template apply<0>(range_p, range_q, tp,
                                                   inters.i_info(), inters.d_info(),
                                                   inters.sides(),
                                                   umbrella_strategy);
@@ -108,9 +105,9 @@ struct get_turn_info_linear_linear
                     else
                     {
                         // Swap p/q
-                        policy::template apply<1>(range_q, range_p, tp,
+                        handler::template apply<1>(range_q, range_p, tp,
                                                   inters.i_info(), inters.d_info(),
-                                                  inters.get_swapped_sides(),
+                                                  inters.swapped_sides(),
                                                   umbrella_strategy);
                     }
                     
@@ -142,20 +139,22 @@ struct get_turn_info_linear_linear
             break;
             case 't' :
             {
+                using handler = touch<TurnInfo, verify_policy_ll>;
+
                 // Both touch (both arrive there)
                 if ( get_turn_info_for_endpoint<false, true>
                         ::apply(range_p, range_q,
                                 tp_model, inters, method_touch, out,
-                                umbrella_strategy.get_point_in_point_strategy()) )
+                                umbrella_strategy) )
                 {
                     // do nothing
                 }
                 else 
                 {
-                    touch<TurnInfo>::apply(range_p, range_q, tp,
-                                           inters.i_info(), inters.d_info(),
-                                           inters.sides(),
-                                           umbrella_strategy);
+                    handler::apply(range_p, range_q, tp,
+                                   inters.i_info(), inters.d_info(),
+                                   inters.sides(),
+                                   umbrella_strategy);
 
                     // workarounds for touch<> not taking spikes into account starts here
                     // those was discovered empirically
@@ -275,10 +274,12 @@ struct get_turn_info_linear_linear
             break;
             case 'e':
             {
+                using handler = equal<TurnInfo, verify_policy_ll>;
+
                 if ( get_turn_info_for_endpoint<true, true>
                         ::apply(range_p, range_q,
                                 tp_model, inters, method_equal, out,
-                                umbrella_strategy.get_point_in_point_strategy()) )
+                                umbrella_strategy) )
                 {
                     // do nothing
                 }
@@ -291,7 +292,7 @@ struct get_turn_info_linear_linear
                     {
                         // Both equal
                         // or collinear-and-ending at intersection point
-                        equal<TurnInfo>::apply(range_p, range_q, tp,
+                        handler::apply(range_p, range_q, tp,
                             inters.i_info(), inters.d_info(), inters.sides(),
                             umbrella_strategy);
 
@@ -333,7 +334,7 @@ struct get_turn_info_linear_linear
                 if ( get_turn_info_for_endpoint<true, true>
                         ::apply(range_p, range_q,
                                 tp_model, inters,  method_collinear, out,
-                                umbrella_strategy.get_point_in_point_strategy()) )
+                                umbrella_strategy) )
                 {
                     // do nothing
                 }
@@ -351,7 +352,9 @@ struct get_turn_info_linear_linear
                         if ( inters.d_info().arrival[0] == 0 )
                         {
                             // Collinear, but similar thus handled as equal
-                            equal<TurnInfo>::apply(range_p, range_q, tp,
+                            using handler = equal<TurnInfo, verify_policy_ll>;
+
+                            handler::apply(range_p, range_q, tp,
                                 inters.i_info(), inters.d_info(), inters.sides(),
                                 umbrella_strategy);
 
@@ -364,8 +367,10 @@ struct get_turn_info_linear_linear
                         }
                         else
                         {
-                            collinear<TurnInfo>::apply(range_p, range_q,
-                                    tp, inters.i_info(), inters.d_info(), inters.sides());
+                            using handler = collinear<TurnInfo, verify_policy_ll>;
+                            handler::apply(range_p, range_q, tp,
+                                           inters.i_info(), inters.d_info(),
+                                           inters.sides());
 
                             //method_replace = method_touch_interior;
                             //spike_op = operation_continue;
@@ -416,29 +421,26 @@ struct get_turn_info_linear_linear
                 // degenerate points
                 if ( BOOST_GEOMETRY_CONDITION(AssignPolicy::include_degenerate) )
                 {
-                    typedef typename UmbrellaStrategy::point_in_point_strategy_type
-                        equals_strategy_type;
-
                     only_convert::apply(tp, inters.i_info());
 
                     // if any, only one of those should be true
                     if ( range_p.is_first_segment()
-                      && equals::equals_point_point(range_p.at(0), tp.point, equals_strategy_type()) )
+                      && equals::equals_point_point(range_p.at(0), tp.point, umbrella_strategy) )
                     {
                         tp.operations[0].position = position_front;
                     }
                     else if ( range_p.is_last_segment()
-                           && equals::equals_point_point(range_p.at(1), tp.point, equals_strategy_type()) )
+                           && equals::equals_point_point(range_p.at(1), tp.point, umbrella_strategy) )
                     {
                         tp.operations[0].position = position_back;
                     }
                     else if ( range_q.is_first_segment()
-                           && equals::equals_point_point(range_q.at(0), tp.point, equals_strategy_type()) )
+                           && equals::equals_point_point(range_q.at(0), tp.point, umbrella_strategy) )
                     {
                         tp.operations[1].position = position_front;
                     }
                     else if ( range_q.is_last_segment()
-                           && equals::equals_point_point(range_q.at(1), tp.point, equals_strategy_type()) )
+                           && equals::equals_point_point(range_q.at(1), tp.point, umbrella_strategy) )
                     {
                         tp.operations[1].position = position_back;
                     }