Merge pull request #1247 from awulkiew/feature/constexpr

Use if constexpr macro instead of condition macro.
boostorg · Feb 29, 2024 · 88d0076 · 88d0076
2 parents acaed28 + cb2f53d
commit 88d0076
Show file tree

Hide file tree

Showing 41 changed files with 926 additions and 824 deletions.
diff --git a/include/boost/geometry/algorithms/detail/convex_hull/interface.hpp b/include/boost/geometry/algorithms/detail/convex_hull/interface.hpp
@@ -53,7 +53,7 @@
 #include <boost/geometry/strategies/convex_hull/spherical.hpp>
 #include <boost/geometry/strategies/default_strategy.hpp>
 
-#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/constexpr.hpp>
 #include <boost/geometry/util/range.hpp>
 #include <boost/geometry/util/sequence.hpp>
 #include <boost/geometry/util/type_traits.hpp>
@@ -240,7 +240,7 @@ struct convex_hull<Box, box_tag>
         geometry::detail::assign_box_corners_oriented<Reverse>(box, arr);
 
         std::move(arr.begin(), arr.end(), range::back_inserter(out));
-        if (BOOST_GEOMETRY_CONDITION(Close))
+        if BOOST_GEOMETRY_CONSTEXPR (Close)
         {
             range::push_back(out, range::front(out));
         }

diff --git a/include/boost/geometry/algorithms/detail/distance/geometry_to_segment_or_box.hpp b/include/boost/geometry/algorithms/detail/distance/geometry_to_segment_or_box.hpp
@@ -1,7 +1,8 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2014-2021, Oracle and/or its affiliates.
+// Copyright (c) 2023 Adam Wulkiewicz, Lodz, Poland.
 
+// Copyright (c) 2014-2021, Oracle and/or its affiliates.
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 
@@ -35,7 +36,7 @@
 #include <boost/geometry/strategies/distance.hpp>
 #include <boost/geometry/strategies/tags.hpp>
 
-#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/constexpr.hpp>
 
 
 namespace boost { namespace geometry
@@ -247,26 +248,28 @@ class geometry_to_segment_or_box
             }
         }
 
-        if (BOOST_GEOMETRY_CONDITION(is_comparable<strategy_type>::value))
+        if BOOST_GEOMETRY_CONSTEXPR (is_comparable<strategy_type>::value)
         {
             return (std::min)(cd_min1, cd_min2);
         }
-
-        if (cd_min1 < cd_min2)
-        {
-            return strategy.apply(*pit_min, *it_min1, *it_min2);
-        }
-        else
+        else // else prevents unreachable code warning
         {
-            return dispatch::distance
-                <
-                    segment_or_box_point,
-                    typename std::iterator_traits
-                        <
-                            segment_iterator_type
-                        >::value_type,
-                    Strategies
-                >::apply(*it_min, *sit_min, strategies);
+            if (cd_min1 < cd_min2)
+            {
+                return strategy.apply(*pit_min, *it_min1, *it_min2);
+            }
+            else
+            {
+                return dispatch::distance
+                    <
+                        segment_or_box_point,
+                        typename std::iterator_traits
+                            <
+                                segment_iterator_type
+                            >::value_type,
+                        Strategies
+                    >::apply(*it_min, *sit_min, strategies);
+            }
         }
     }
 

diff --git a/include/boost/geometry/algorithms/detail/distance/segment_to_box.hpp b/include/boost/geometry/algorithms/detail/distance/segment_to_box.hpp
@@ -1,5 +1,7 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
+// Copyright (c) 2023-2024 Adam Wulkiewicz, Lodz, Poland.
+
 // Copyright (c) 2014-2023 Oracle and/or its affiliates.
 
 // Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
@@ -40,7 +42,7 @@
 #include <boost/geometry/policies/compare.hpp>
 
 #include <boost/geometry/util/calculation_type.hpp>
-#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/constexpr.hpp>
 #include <boost/geometry/util/has_nan_coordinate.hpp>
 #include <boost/geometry/util/math.hpp>
 #include <boost/geometry/util/numeric_cast.hpp>
@@ -154,21 +156,23 @@ class segment_to_box_2D_generic
             }
         }
 
-        if (BOOST_GEOMETRY_CONDITION(is_comparable<ps_strategy_type>::value))
+        if BOOST_GEOMETRY_CONSTEXPR (is_comparable<ps_strategy_type>::value)
         {
             return cd[imin];
         }
-
-        if (imin < 4)
-        {
-            return strategy.apply(box_points[imin], p[0], p[1]);
-        }
-        else
+        else // else prevents unreachable code warning
         {
-            unsigned int bimin = imin - 4;
-            return strategy.apply(p[bimin],
-                                  *bit_min[bimin].first,
-                                  *bit_min[bimin].second);
+            if (imin < 4)
+            {
+                return strategy.apply(box_points[imin], p[0], p[1]);
+            }
+            else
+            {
+                unsigned int bimin = imin - 4;
+                return strategy.apply(p[bimin],
+                                      *bit_min[bimin].first,
+                                      *bit_min[bimin].second);
+            }
         }
     }
 };

diff --git a/include/boost/geometry/algorithms/detail/distance/segment_to_segment.hpp b/include/boost/geometry/algorithms/detail/distance/segment_to_segment.hpp
@@ -1,7 +1,8 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2014-2021, Oracle and/or its affiliates.
+// Copyright (c) 2023 Adam Wulkiewicz, Lodz, Poland.
 
+// Copyright (c) 2014-2021, Oracle and/or its affiliates.
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 
@@ -28,7 +29,7 @@
 #include <boost/geometry/strategies/distance.hpp>
 #include <boost/geometry/strategies/tags.hpp>
 
-#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/constexpr.hpp>
 
 
 namespace boost { namespace geometry
@@ -82,21 +83,23 @@ class segment_to_segment
         std::size_t imin = std::distance(boost::addressof(d[0]),
                                          std::min_element(d, d + 4));
 
-        if (BOOST_GEOMETRY_CONDITION(is_comparable<strategy_type>::value))
+        if BOOST_GEOMETRY_CONSTEXPR (is_comparable<strategy_type>::value)
         {
             return d[imin];
         }
-
-        switch (imin)
+        else // else prevents unreachable code warning
         {
-        case 0:
-            return strategy.apply(q[0], p[0], p[1]);
-        case 1:
-            return strategy.apply(q[1], p[0], p[1]);
-        case 2:
-            return strategy.apply(p[0], q[0], q[1]);
-        default:
-            return strategy.apply(p[1], q[0], q[1]);
+            switch (imin)
+            {
+            case 0:
+                return strategy.apply(q[0], p[0], p[1]);
+            case 1:
+                return strategy.apply(q[1], p[0], p[1]);
+            case 2:
+                return strategy.apply(p[0], q[0], q[1]);
+            default:
+                return strategy.apply(p[1], q[0], q[1]);
+            }
         }
     }
 };

diff --git a/include/boost/geometry/algorithms/detail/is_valid/pointlike.hpp b/include/boost/geometry/algorithms/detail/is_valid/pointlike.hpp
@@ -1,7 +1,8 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2014-2020, Oracle and/or its affiliates.
+// Copyright (c) 2023 Adam Wulkiewicz, Lodz, Poland.
 
+// Copyright (c) 2014-2020, Oracle and/or its affiliates.
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 
@@ -20,7 +21,7 @@
 #include <boost/geometry/algorithms/detail/is_valid/has_invalid_coordinate.hpp>
 #include <boost/geometry/algorithms/dispatch/is_valid.hpp>
 
-#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/constexpr.hpp>
 
 
 namespace boost { namespace geometry
@@ -63,21 +64,21 @@ struct is_valid<MultiPoint, multi_point_tag, AllowEmptyMultiGeometries>
     {
         boost::ignore_unused(multipoint, visitor);
 
-        if (BOOST_GEOMETRY_CONDITION(
-                AllowEmptyMultiGeometries || !boost::empty(multipoint)))
-        {
-            // we allow empty multi-geometries, so an empty multipoint
-            // is considered valid
-            return ! detail::is_valid::has_invalid_coordinate
-                <
-                    MultiPoint
-                >::apply(multipoint, visitor);
-        }
-        else
+        if BOOST_GEOMETRY_CONSTEXPR (! AllowEmptyMultiGeometries)
         {
-            // we do not allow an empty multipoint
-            return visitor.template apply<failure_few_points>();
+            if (boost::empty(multipoint))
+            {
+                // we do not allow an empty multipoint
+                return visitor.template apply<failure_few_points>();
+            }
         }
+
+        // if we allow empty multi-geometries, an empty multipoint
+        // is considered valid
+        return ! detail::is_valid::has_invalid_coordinate
+            <
+                MultiPoint
+            >::apply(multipoint, visitor);
     }
 };
 

diff --git a/include/boost/geometry/algorithms/detail/is_valid/polygon.hpp b/include/boost/geometry/algorithms/detail/is_valid/polygon.hpp
@@ -450,42 +450,44 @@ class is_valid_polygon
         {
             return true;
         }
+        else // else prevents unreachable code warning
+        {
+            // compute turns and check if all are acceptable
+            typedef debug_validity_phase<Polygon> debug_phase;
+            debug_phase::apply(3);
 
-        // compute turns and check if all are acceptable
-        typedef debug_validity_phase<Polygon> debug_phase;
-        debug_phase::apply(3);
-
-        typedef has_valid_self_turns<Polygon, typename Strategy::cs_tag> has_valid_turns;
+            typedef has_valid_self_turns<Polygon, typename Strategy::cs_tag> has_valid_turns;
 
-        std::deque<typename has_valid_turns::turn_type> turns;
-        bool has_invalid_turns
-            = ! has_valid_turns::apply(polygon, turns, visitor, strategy);
-        debug_print_turns(turns.begin(), turns.end());
+            std::deque<typename has_valid_turns::turn_type> turns;
+            bool has_invalid_turns
+                = ! has_valid_turns::apply(polygon, turns, visitor, strategy);
+            debug_print_turns(turns.begin(), turns.end());
 
-        if (has_invalid_turns)
-        {
-            return false;
-        }
+            if (has_invalid_turns)
+            {
+                return false;
+            }
 
-        // check if all interior rings are inside the exterior ring
-        debug_phase::apply(4);
+            // check if all interior rings are inside the exterior ring
+            debug_phase::apply(4);
 
-        if (! has_holes_inside::apply(polygon,
-                                      turns.begin(), turns.end(),
-                                      visitor,
-                                      strategy))
-        {
-            return false;
-        }
+            if (! has_holes_inside::apply(polygon,
+                                          turns.begin(), turns.end(),
+                                          visitor,
+                                          strategy))
+            {
+                return false;
+            }
 
-        // check whether the interior of the polygon is a connected set
-        debug_phase::apply(5);
+            // check whether the interior of the polygon is a connected set
+            debug_phase::apply(5);
 
-        return has_connected_interior::apply(polygon,
-                                             turns.begin(),
-                                             turns.end(),
-                                             visitor,
-                                             strategy);
+            return has_connected_interior::apply(polygon,
+                                                 turns.begin(),
+                                                 turns.end(),
+                                                 visitor,
+                                                 strategy);
+        }
     }
 };
 

diff --git a/include/boost/geometry/algorithms/detail/overlay/append_no_dups_or_spikes.hpp b/include/boost/geometry/algorithms/detail/overlay/append_no_dups_or_spikes.hpp
@@ -1,10 +1,10 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
 // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2023 Adam Wulkiewicz, Lodz, Poland.
 
 // This file was modified by Oracle on 2014-2020.
 // Modifications copyright (c) 2014-2020 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,
@@ -29,7 +29,7 @@
 
 #include <boost/geometry/core/closure.hpp>
 
-#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/constexpr.hpp>
 #include <boost/geometry/util/range.hpp>
 
 
@@ -53,30 +53,32 @@ inline bool points_equal_or_close(Point1 const& point1,
         return true;
     }
 
-    if (BOOST_GEOMETRY_CONDITION(! RobustPolicy::enabled))
+    if BOOST_GEOMETRY_CONSTEXPR (! RobustPolicy::enabled)
     {
         return false;
     }
-
-    // Try using specified robust policy
-    typedef typename geometry::robust_point_type
-    <
-        Point1,
-        RobustPolicy
-    >::type robust_point_type;
-
-    robust_point_type point1_rob, point2_rob;
-    geometry::recalculate(point1_rob, point1, robust_policy);
-    geometry::recalculate(point2_rob, point2, robust_policy);
-
-    // Only if this is the case the same strategy can be used.
-    BOOST_STATIC_ASSERT((std::is_same
-                            <
-                                typename geometry::cs_tag<Point1>::type,
-                                typename geometry::cs_tag<robust_point_type>::type
-                            >::value));
-
-    return detail::equals::equals_point_point(point1_rob, point2_rob, strategy);
+    else // else prevents unreachable code warning
+    {
+        // Try using specified robust policy
+        using robust_point_type = typename geometry::robust_point_type
+            <
+                Point1,
+                RobustPolicy
+            >::type;
+
+        robust_point_type point1_rob, point2_rob;
+        geometry::recalculate(point1_rob, point1, robust_policy);
+        geometry::recalculate(point2_rob, point2, robust_policy);
+
+        // Only if this is the case the same strategy can be used.
+        BOOST_STATIC_ASSERT((std::is_same
+                                <
+                                    typename geometry::cs_tag<Point1>::type,
+                                    typename geometry::cs_tag<robust_point_type>::type
+                                >::value));
+
+        return detail::equals::equals_point_point(point1_rob, point2_rob, strategy);
+    }
 }
 
 
@@ -214,7 +216,7 @@ inline void remove_spikes_at_closure(Ring& ring, Strategy const& strategy,
 template <typename Ring, typename Strategy>
 inline void fix_closure(Ring& ring, Strategy const& strategy)
 {
-    if (BOOST_GEOMETRY_CONDITION(geometry::closure<Ring>::value == geometry::open))
+    if BOOST_GEOMETRY_CONSTEXPR (geometry::closure<Ring>::value == geometry::open)
     {
         if (! boost::empty(ring)
             && detail::equals::equals_point_point(range::front(ring), range::back(ring), strategy))