add boost on mac

macx64/include/boost/geometry/algorithms/detail/within/implementation.hpp

@@ -0,0 +1,306 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013, 2014, 2017, 2019.
+// Modifications copyright (c) 2013-2019 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_IMPLEMENTATION_HPP
+
+#include <cstddef>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/within/interface.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/order_as_direction.hpp>
+#include <boost/geometry/views/closeable_view.hpp>
+#include <boost/geometry/views/reversible_view.hpp>
+
+#include <boost/geometry/algorithms/detail/within/multi_point.hpp>
+#include <boost/geometry/algorithms/detail/within/point_in_geometry.hpp>
+#include <boost/geometry/algorithms/relate.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/get_turns.hpp>
+#include <boost/geometry/algorithms/detail/overlay/do_reverse.hpp>
+#include <deque>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace within {
+
+struct use_point_in_geometry
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        return detail::within::within_point_geometry(geometry1, geometry2, strategy);
+    }
+};
+
+struct use_relate
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        typedef typename detail::de9im::static_mask_within_type
+            <
+                Geometry1, Geometry2
+            >::type within_mask;
+        return geometry::relate(geometry1, geometry2, within_mask(), strategy);
+    }
+};
+
+}} // namespace detail::within
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Point, typename Box>
+struct within<Point, Box, point_tag, box_tag>
+{
+    template <typename Strategy>
+    static inline bool apply(Point const& point, Box const& box, Strategy const& strategy)
+    {
+        boost::ignore_unused(strategy);
+        return strategy.apply(point, box);
+    }
+};
+
+template <typename Box1, typename Box2>
+struct within<Box1, Box2, box_tag, box_tag>
+{
+    template <typename Strategy>
+    static inline bool apply(Box1 const& box1, Box2 const& box2, Strategy const& strategy)
+    {
+        assert_dimension_equal<Box1, Box2>();
+        boost::ignore_unused(strategy);
+        return strategy.apply(box1, box2);
+    }
+};
+
+// P/P
+
+template <typename Point1, typename Point2>
+struct within<Point1, Point2, point_tag, point_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename Point, typename MultiPoint>
+struct within<Point, MultiPoint, point_tag, multi_point_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename MultiPoint, typename Point>
+struct within<MultiPoint, Point, multi_point_tag, point_tag>
+    : public detail::within::multi_point_point
+{};
+
+template <typename MultiPoint1, typename MultiPoint2>
+struct within<MultiPoint1, MultiPoint2, multi_point_tag, multi_point_tag>
+    : public detail::within::multi_point_multi_point
+{};
+
+// P/L
+
+template <typename Point, typename Segment>
+struct within<Point, Segment, point_tag, segment_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename Point, typename Linestring>
+struct within<Point, Linestring, point_tag, linestring_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename Point, typename MultiLinestring>
+struct within<Point, MultiLinestring, point_tag, multi_linestring_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename MultiPoint, typename Segment>
+struct within<MultiPoint, Segment, multi_point_tag, segment_tag>
+    : public detail::within::multi_point_single_geometry<true>
+{};
+
+template <typename MultiPoint, typename Linestring>
+struct within<MultiPoint, Linestring, multi_point_tag, linestring_tag>
+    : public detail::within::multi_point_single_geometry<true>
+{};
+
+template <typename MultiPoint, typename MultiLinestring>
+struct within<MultiPoint, MultiLinestring, multi_point_tag, multi_linestring_tag>
+    : public detail::within::multi_point_multi_geometry<true>
+{};
+
+// P/A
+
+template <typename Point, typename Ring>
+struct within<Point, Ring, point_tag, ring_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename Point, typename Polygon>
+struct within<Point, Polygon, point_tag, polygon_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename Point, typename MultiPolygon>
+struct within<Point, MultiPolygon, point_tag, multi_polygon_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename MultiPoint, typename Ring>
+struct within<MultiPoint, Ring, multi_point_tag, ring_tag>
+    : public detail::within::multi_point_single_geometry<true>
+{};
+
+template <typename MultiPoint, typename Polygon>
+struct within<MultiPoint, Polygon, multi_point_tag, polygon_tag>
+    : public detail::within::multi_point_single_geometry<true>
+{};
+
+template <typename MultiPoint, typename MultiPolygon>
+struct within<MultiPoint, MultiPolygon, multi_point_tag, multi_polygon_tag>
+    : public detail::within::multi_point_multi_geometry<true>
+{};
+
+// L/L
+
+template <typename Linestring1, typename Linestring2>
+struct within<Linestring1, Linestring2, linestring_tag, linestring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Linestring, typename MultiLinestring>
+struct within<Linestring, MultiLinestring, linestring_tag, multi_linestring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiLinestring, typename Linestring>
+struct within<MultiLinestring, Linestring, multi_linestring_tag, linestring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiLinestring1, typename MultiLinestring2>
+struct within<MultiLinestring1, MultiLinestring2, multi_linestring_tag, multi_linestring_tag>
+    : public detail::within::use_relate
+{};
+
+// L/A
+
+template <typename Linestring, typename Ring>
+struct within<Linestring, Ring, linestring_tag, ring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiLinestring, typename Ring>
+struct within<MultiLinestring, Ring, multi_linestring_tag, ring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Linestring, typename Polygon>
+struct within<Linestring, Polygon, linestring_tag, polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiLinestring, typename Polygon>
+struct within<MultiLinestring, Polygon, multi_linestring_tag, polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Linestring, typename MultiPolygon>
+struct within<Linestring, MultiPolygon, linestring_tag, multi_polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiLinestring, typename MultiPolygon>
+struct within<MultiLinestring, MultiPolygon, multi_linestring_tag, multi_polygon_tag>
+    : public detail::within::use_relate
+{};
+
+// A/A
+
+template <typename Ring1, typename Ring2>
+struct within<Ring1, Ring2, ring_tag, ring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Ring, typename Polygon>
+struct within<Ring, Polygon, ring_tag, polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Polygon, typename Ring>
+struct within<Polygon, Ring, polygon_tag, ring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Polygon1, typename Polygon2>
+struct within<Polygon1, Polygon2, polygon_tag, polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Ring, typename MultiPolygon>
+struct within<Ring, MultiPolygon, ring_tag, multi_polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiPolygon, typename Ring>
+struct within<MultiPolygon, Ring, multi_polygon_tag, ring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Polygon, typename MultiPolygon>
+struct within<Polygon, MultiPolygon, polygon_tag, multi_polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiPolygon, typename Polygon>
+struct within<MultiPolygon, Polygon, multi_polygon_tag, polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiPolygon1, typename MultiPolygon2>
+struct within<MultiPolygon1, MultiPolygon2, multi_polygon_tag, multi_polygon_tag>
+    : public detail::within::use_relate
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#include <boost/geometry/index/rtree.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_IMPLEMENTATION_HPP

macx64/include/boost/geometry/algorithms/detail/within/interface.hpp

@@ -0,0 +1,298 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013, 2014, 2017, 2018.
+// Modifications copyright (c) 2013-2018 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_INTERFACE_HPP
+
+
+#include <boost/concept_check.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/strategies/concepts/within_concept.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Tag1 = typename tag<Geometry1>::type,
+    typename Tag2 = typename tag<Geometry2>::type
+>
+struct within
+    : not_implemented<Tag1, Tag2>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy
+{
+
+struct within
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        concepts::within::check<Geometry1, Geometry2, Strategy>();
+
+        return dispatch::within<Geometry1, Geometry2>::apply(geometry1, geometry2, strategy);
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             default_strategy)
+    {
+        typedef typename strategy::within::services::default_strategy
+            <
+                Geometry1,
+                Geometry2
+            >::type strategy_type;
+
+        return apply(geometry1, geometry2, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant
+{
+
+template <typename Geometry1, typename Geometry2>
+struct within
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        concepts::check<Geometry1 const>();
+        concepts::check<Geometry2 const>();
+        assert_dimension_equal<Geometry1, Geometry2>();
+
+        return resolve_strategy::within::apply(geometry1,
+                                               geometry2,
+                                               strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct within<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    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 within<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,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry2, strategy),
+                                    geometry1);
+    }
+};
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct within<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
+        {
+            return within<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
+        );
+    }
+};
+
+template <
+    BOOST_VARIANT_ENUM_PARAMS(typename T1),
+    BOOST_VARIANT_ENUM_PARAMS(typename T2)
+>
+struct within<
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>
+>
+{
+    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 within<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,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(strategy),
+                                    geometry1,
+                                    geometry2);
+    }
+};
+
+}
+
+
+/*!
+\brief \brief_check12{is completely inside}
+\ingroup within
+\details \details_check12{within, is completely inside}.
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry which might be within the second geometry
+\param geometry2 \param_geometry which might contain the first geometry
+\return true if geometry1 is completely contained within geometry2,
+    else false
+\note The default strategy is used for within detection
+
+
+\qbk{[include reference/algorithms/within.qbk]}
+
+\qbk{
+[heading Example]
+[within]
+[within_output]
+}
+ */
+template<typename Geometry1, typename Geometry2>
+inline bool within(Geometry1 const& geometry1, Geometry2 const& geometry2)
+{
+    return resolve_variant::within
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, default_strategy());
+}
+
+/*!
+\brief \brief_check12{is completely inside} \brief_strategy
+\ingroup within
+\details \details_check12{within, is completely inside}, \brief_strategy. \details_strategy_reasons
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry which might be within the second geometry
+\param geometry2 \param_geometry which might contain the first geometry
+\param strategy strategy to be used
+\return true if geometry1 is completely contained within geometry2,
+    else false
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/within.qbk]}
+\qbk{
+[heading Available Strategies]
+\* [link geometry.reference.strategies.strategy_within_winding Winding (coordinate system agnostic)]
+\* [link geometry.reference.strategies.strategy_within_franklin Franklin (cartesian)]
+\* [link geometry.reference.strategies.strategy_within_crossings_multiply Crossings Multiply (cartesian)]
+
+[heading Example]
+[within_strategy]
+[within_strategy_output]
+
+}
+*/
+template<typename Geometry1, typename Geometry2, typename Strategy>
+inline bool within(Geometry1 const& geometry1,
+                   Geometry2 const& geometry2,
+                   Strategy const& strategy)
+{
+    return resolve_variant::within
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, strategy);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_INTERFACE_HPP

macx64/include/boost/geometry/algorithms/detail/within/multi_point.hpp

@@ -0,0 +1,269 @@
+// Boost.Geometry
+
+// Copyright (c) 2017 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_MULTI_POINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_MULTI_POINT_HPP
+
+
+#include <algorithm>
+#include <vector>
+
+#include <boost/range.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_box.hpp>
+#include <boost/geometry/algorithms/detail/expand_by_epsilon.hpp>
+#include <boost/geometry/algorithms/detail/within/point_in_geometry.hpp>
+#include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/detail/partition.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+
+#include <boost/geometry/index/rtree.hpp>
+
+#include <boost/geometry/policies/compare.hpp>
+
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/disjoint.hpp>
+
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace within {
+
+struct multi_point_point
+{
+    template <typename MultiPoint, typename Point, typename Strategy>
+    static inline bool apply(MultiPoint const& multi_point,
+                             Point const& point,
+                             Strategy const& strategy)
+    {
+        typedef typename boost::range_const_iterator<MultiPoint>::type iterator;
+        for ( iterator it = boost::begin(multi_point) ; it != boost::end(multi_point) ; ++it )
+        {
+            if (! strategy.apply(*it, point))
+            {
+                return false;
+            }
+        }
+
+        // all points of MultiPoint inside Point
+        return true;
+    }
+};
+
+// NOTE: currently the strategy is ignored, math::equals() is used inside geometry::less<>
+struct multi_point_multi_point
+{
+    template <typename MultiPoint1, typename MultiPoint2, typename Strategy>
+    static inline bool apply(MultiPoint1 const& multi_point1,
+                             MultiPoint2 const& multi_point2,
+                             Strategy const& /*strategy*/)
+    {
+        typedef typename boost::range_value<MultiPoint2>::type point2_type;
+
+        geometry::less<> const less = geometry::less<>();
+
+        std::vector<point2_type> points2(boost::begin(multi_point2), boost::end(multi_point2));
+        std::sort(points2.begin(), points2.end(), less);
+
+        bool result = false;
+
+        typedef typename boost::range_const_iterator<MultiPoint1>::type iterator;
+        for ( iterator it = boost::begin(multi_point1) ; it != boost::end(multi_point1) ; ++it )
+        {
+            if (! std::binary_search(points2.begin(), points2.end(), *it, less))
+            {
+                return false;
+            }
+            else
+            {
+                result = true;
+            }
+        }
+
+        return result;
+    }
+};
+
+
+// TODO: the complexity could be lesser
+//   the second geometry could be "prepared"/sorted
+// For Linear geometries partition could be used
+// For Areal geometries point_in_geometry() would have to call the winding
+//   strategy differently, currently it linearly calls the strategy for each
+//   segment. So the segments would have to be sorted in a way consistent with
+//   the strategy and then the strategy called only for the segments in range.
+template <bool Within>
+struct multi_point_single_geometry
+{
+    template <typename MultiPoint, typename LinearOrAreal, typename Strategy>
+    static inline bool apply(MultiPoint const& multi_point,
+                             LinearOrAreal const& linear_or_areal,
+                             Strategy const& strategy)
+    {
+        typedef typename boost::range_value<MultiPoint>::type point1_type;
+        typedef typename point_type<LinearOrAreal>::type point2_type;
+        typedef model::box<point2_type> box2_type;
+
+        // Create envelope of geometry
+        box2_type box;
+        geometry::envelope(linear_or_areal, box, strategy.get_envelope_strategy());
+        geometry::detail::expand_by_epsilon(box);
+
+        typedef typename strategy::covered_by::services::default_strategy
+            <
+                point1_type, box2_type
+            >::type point_in_box_type;
+
+        // Test each Point with envelope and then geometry if needed
+        // If in the exterior, break
+        bool result = false;
+
+        typedef typename boost::range_const_iterator<MultiPoint>::type iterator;
+        for ( iterator it = boost::begin(multi_point) ; it != boost::end(multi_point) ; ++it )
+        {
+            int in_val = 0;
+
+            // exterior of box and of geometry
+            if (! point_in_box_type::apply(*it, box)
+                || (in_val = point_in_geometry(*it, linear_or_areal, strategy)) < 0)
+            {
+                result = false;
+                break;
+            }
+
+            // interior : interior/boundary
+            if (Within ? in_val > 0 : in_val >= 0)
+            {
+                result = true;
+            }
+        }
+
+        return result;
+    }
+};
+
+
+// TODO: same here, probably the complexity could be lesser
+template <bool Within>
+struct multi_point_multi_geometry
+{
+    template <typename MultiPoint, typename LinearOrAreal, typename Strategy>
+    static inline bool apply(MultiPoint const& multi_point,
+                             LinearOrAreal const& linear_or_areal,
+                             Strategy const& strategy)
+    {
+        typedef typename point_type<LinearOrAreal>::type point2_type;
+        typedef model::box<point2_type> box2_type;
+        static const bool is_linear = is_same
+            <
+                typename tag_cast
+                    <
+                        typename tag<LinearOrAreal>::type,
+                        linear_tag
+                    >::type,
+                linear_tag
+            >::value;
+
+        typename Strategy::envelope_strategy_type const
+            envelope_strategy = strategy.get_envelope_strategy();
+
+        // TODO: box pairs could be constructed on the fly, inside the rtree
+
+        // Prepare range of envelopes and ids
+        std::size_t count2 = boost::size(linear_or_areal);
+        typedef std::pair<box2_type, std::size_t> box_pair_type;
+        typedef std::vector<box_pair_type> box_pair_vector;
+        box_pair_vector boxes(count2);
+        for (std::size_t i = 0 ; i < count2 ; ++i)
+        {
+            geometry::envelope(linear_or_areal, boxes[i].first, envelope_strategy);
+            geometry::detail::expand_by_epsilon(boxes[i].first);
+            boxes[i].second = i;
+        }
+
+        // Create R-tree
+        index::rtree<box_pair_type, index::rstar<4> > rtree(boxes.begin(), boxes.end());
+
+        // For each point find overlapping envelopes and test corresponding single geometries
+        // If a point is in the exterior break
+        bool result = false;
+
+        typedef typename boost::range_const_iterator<MultiPoint>::type iterator;
+        for ( iterator it = boost::begin(multi_point) ; it != boost::end(multi_point) ; ++it )
+        {
+            // TODO: investigate the possibility of using satisfies
+            // TODO: investigate the possibility of using iterative queries (optimization below)
+            box_pair_vector inters_boxes;
+            rtree.query(index::intersects(*it), std::back_inserter(inters_boxes));
+
+            bool found_interior = false;
+            bool found_boundary = false;
+            int boundaries = 0;
+
+            typedef typename box_pair_vector::const_iterator iterator;
+            for ( iterator box_it = inters_boxes.begin() ; box_it != inters_boxes.end() ; ++box_it )
+            {
+                int in_val = point_in_geometry(*it, range::at(linear_or_areal, box_it->second), strategy);
+
+                if (in_val > 0)
+                    found_interior = true;
+                else if (in_val == 0)
+                    ++boundaries;
+
+                // If the result was set previously (interior or
+                // interior/boundary found) the only thing that needs to be
+                // done for other points is to make sure they're not
+                // overlapping the exterior no need to analyse boundaries.
+                if (result && in_val >= 0)
+                {
+                    break;
+                }
+            }
+
+            if ( boundaries > 0)
+            {
+                if (is_linear && boundaries % 2 == 0)
+                    found_interior = true;
+                else
+                    found_boundary = true;
+            }
+
+            // exterior
+            if (! found_interior && ! found_boundary)
+            {
+                result = false;
+                break;
+            }
+
+            // interior : interior/boundary
+            if (Within ? found_interior : (found_interior || found_boundary))
+            {
+                result = true;
+            }
+        }
+
+        return result;
+    }
+};
+
+}} // namespace detail::within
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_MULTI_POINT_HPP

macx64/include/boost/geometry/algorithms/detail/within/point_in_geometry.hpp

@@ -0,0 +1,414 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017, 2018, 2019.
+// Modifications copyright (c) 2013-2019, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_POINT_IN_GEOMETRY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_POINT_IN_GEOMETRY_HPP
+
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/range.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/strategies/concepts/within_concept.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/relate.hpp>
+
+#include <boost/geometry/util/range.hpp>
+#include <boost/geometry/views/detail/normalized_view.hpp>
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace within {
+
+template <typename Point1, typename Point2, typename Strategy>
+inline bool equals_point_point(Point1 const& p1, Point2 const& p2, Strategy const& strategy)
+{
+    return equals::equals_point_point(p1, p2, strategy.get_equals_point_point_strategy());
+}
+
+// TODO: is this needed?
+inline int check_result_type(int result)
+{
+    return result;
+}
+
+template <typename T>
+inline T check_result_type(T result)
+{
+    BOOST_GEOMETRY_ASSERT(false);
+    return result;
+}
+
+template <typename Point, typename Range, typename Strategy> inline
+int point_in_range(Point const& point, Range const& range, Strategy const& strategy)
+{
+    boost::ignore_unused(strategy);
+
+    typedef typename boost::range_iterator<Range const>::type iterator_type;
+    typename Strategy::state_type state;
+    iterator_type it = boost::begin(range);
+    iterator_type end = boost::end(range);
+
+    for ( iterator_type previous = it++ ; it != end ; ++previous, ++it )
+    {
+        if ( ! strategy.apply(point, *previous, *it, state) )
+        {
+            break;
+        }
+    }
+
+    return check_result_type(strategy.result(state));
+}
+
+template <typename Geometry, typename Point, typename Range>
+inline int point_in_range(Point const& point, Range const& range)
+{
+    typedef typename strategy::point_in_geometry::services::default_strategy
+        <
+            Point, Geometry
+        >::type strategy_type;
+
+    return point_in_range(point, range, strategy_type());
+}
+
+}} // namespace detail::within
+
+namespace detail_dispatch { namespace within {
+
+// checks the relation between a point P and geometry G
+// returns 1 if P is in the interior of G
+// returns 0 if P is on the boundry of G
+// returns -1 if P is in the exterior of G
+
+template <typename Geometry,
+          typename Tag = typename geometry::tag<Geometry>::type>
+struct point_in_geometry
+    : not_implemented<Tag>
+{};
+
+template <typename Point2>
+struct point_in_geometry<Point2, point_tag>
+{
+    template <typename Point1, typename Strategy> static inline
+    int apply(Point1 const& point1, Point2 const& point2, Strategy const& strategy)
+    {
+        boost::ignore_unused(strategy);
+        return strategy.apply(point1, point2) ? 1 : -1;
+    }
+};
+
+template <typename Segment>
+struct point_in_geometry<Segment, segment_tag>
+{
+    template <typename Point, typename Strategy> static inline
+    int apply(Point const& point, Segment const& segment, Strategy const& strategy)
+    {
+        boost::ignore_unused(strategy);
+
+        typedef typename geometry::point_type<Segment>::type point_type;
+        point_type p0, p1;
+// TODO: don't copy points
+        detail::assign_point_from_index<0>(segment, p0);
+        detail::assign_point_from_index<1>(segment, p1);
+
+        typename Strategy::state_type state;
+        strategy.apply(point, p0, p1, state);
+        int r = detail::within::check_result_type(strategy.result(state));
+
+        if ( r != 0 )
+            return -1; // exterior
+
+        // if the point is equal to the one of the terminal points
+        if ( detail::within::equals_point_point(point, p0, strategy)
+          || detail::within::equals_point_point(point, p1, strategy) )
+            return 0; // boundary
+        else
+            return 1; // interior
+    }
+};
+
+
+template <typename Linestring>
+struct point_in_geometry<Linestring, linestring_tag>
+{
+    template <typename Point, typename Strategy> static inline
+    int apply(Point const& point, Linestring const& linestring, Strategy const& strategy)
+    {
+        std::size_t count = boost::size(linestring);
+        if ( count > 1 )
+        {
+            if ( detail::within::point_in_range(point, linestring, strategy) != 0 )
+                return -1; // exterior
+
+            // if the linestring doesn't have a boundary
+            if (detail::within::equals_point_point(range::front(linestring), range::back(linestring), strategy))
+                return 1; // interior
+            // else if the point is equal to the one of the terminal points
+            else if (detail::within::equals_point_point(point, range::front(linestring), strategy)
+                || detail::within::equals_point_point(point, range::back(linestring), strategy))
+                return 0; // boundary
+            else
+                return 1; // interior
+        }
+// TODO: for now degenerated linestrings are ignored
+//       throw an exception here?
+        /*else if ( count == 1 )
+        {
+            if ( detail::equals::equals_point_point(point, range::front(linestring)) )
+                return 1;
+        }*/
+
+        return -1; // exterior
+    }
+};
+
+template <typename Ring>
+struct point_in_geometry<Ring, ring_tag>
+{
+    template <typename Point, typename Strategy> static inline
+    int apply(Point const& point, Ring const& ring, Strategy const& strategy)
+    {
+        if ( boost::size(ring) < core_detail::closure::minimum_ring_size
+                                    <
+                                        geometry::closure<Ring>::value
+                                    >::value )
+        {
+            return -1;
+        }
+
+        detail::normalized_view<Ring const> view(ring);
+        return detail::within::point_in_range(point, view, strategy);
+    }
+};
+
+// Polygon: in exterior ring, and if so, not within interior ring(s)
+template <typename Polygon>
+struct point_in_geometry<Polygon, polygon_tag>
+{
+    template <typename Point, typename Strategy>
+    static inline int apply(Point const& point, Polygon const& polygon,
+                            Strategy const& strategy)
+    {
+        int const code = point_in_geometry
+            <
+                typename ring_type<Polygon>::type
+            >::apply(point, exterior_ring(polygon), strategy);
+
+        if (code == 1)
+        {
+            typename interior_return_type<Polygon const>::type
+                rings = interior_rings(polygon);
+            
+            for (typename detail::interior_iterator<Polygon const>::type
+                 it = boost::begin(rings);
+                 it != boost::end(rings);
+                 ++it)
+            {
+                int const interior_code = point_in_geometry
+                    <
+                        typename ring_type<Polygon>::type
+                    >::apply(point, *it, strategy);
+
+                if (interior_code != -1)
+                {
+                    // If 0, return 0 (touch)
+                    // If 1 (inside hole) return -1 (outside polygon)
+                    // If -1 (outside hole) check other holes if any
+                    return -interior_code;
+                }
+            }
+        }
+        return code;
+    }
+};
+
+template <typename Geometry>
+struct point_in_geometry<Geometry, multi_point_tag>
+{
+    template <typename Point, typename Strategy> static inline
+    int apply(Point const& point, Geometry const& geometry, Strategy const& strategy)
+    {
+        typedef typename boost::range_value<Geometry>::type point_type;
+        typedef typename boost::range_const_iterator<Geometry>::type iterator;
+        for ( iterator it = boost::begin(geometry) ; it != boost::end(geometry) ; ++it )
+        {
+            int pip = point_in_geometry<point_type>::apply(point, *it, strategy);
+
+            //BOOST_GEOMETRY_ASSERT(pip != 0);
+            if ( pip > 0 ) // inside
+                return 1;
+        }
+
+        return -1; // outside
+    }
+};
+
+template <typename Geometry>
+struct point_in_geometry<Geometry, multi_linestring_tag>
+{
+    template <typename Point, typename Strategy> static inline
+    int apply(Point const& point, Geometry const& geometry, Strategy const& strategy)
+    {
+        int pip = -1; // outside
+
+        typedef typename boost::range_value<Geometry>::type linestring_type;
+        typedef typename boost::range_value<linestring_type>::type point_type;
+        typedef typename boost::range_iterator<Geometry const>::type iterator;
+        iterator it = boost::begin(geometry);
+        for ( ; it != boost::end(geometry) ; ++it )
+        {
+            pip = point_in_geometry<linestring_type>::apply(point, *it, strategy);
+
+            // inside or on the boundary
+            if ( pip >= 0 )
+            {
+                ++it;
+                break;
+            }
+        }
+
+        // outside
+        if ( pip < 0 )
+            return -1;
+
+        // TODO: the following isn't needed for covered_by()
+
+        unsigned boundaries = pip == 0 ? 1 : 0;
+
+        for ( ; it != boost::end(geometry) ; ++it )
+        {
+            if ( boost::size(*it) < 2 )
+                continue;
+
+            point_type const& front = range::front(*it);
+            point_type const& back = range::back(*it);
+
+            // is closed_ring - no boundary
+            if ( detail::within::equals_point_point(front, back, strategy) )
+                continue;
+
+            // is point on boundary
+            if ( detail::within::equals_point_point(point, front, strategy)
+              || detail::within::equals_point_point(point, back, strategy) )
+            {
+                ++boundaries;
+            }
+        }
+
+        // if the number of boundaries is odd, the point is on the boundary
+        return boundaries % 2 ? 0 : 1;
+    }
+};
+
+template <typename Geometry>
+struct point_in_geometry<Geometry, multi_polygon_tag>
+{
+    template <typename Point, typename Strategy> static inline
+    int apply(Point const& point, Geometry const& geometry, Strategy const& strategy)
+    {
+        // For invalid multipolygons
+        //int res = -1; // outside
+
+        typedef typename boost::range_value<Geometry>::type polygon_type;
+        typedef typename boost::range_const_iterator<Geometry>::type iterator;
+        for ( iterator it = boost::begin(geometry) ; it != boost::end(geometry) ; ++it )
+        {
+            int pip = point_in_geometry<polygon_type>::apply(point, *it, strategy);
+
+            // inside or on the boundary
+            if ( pip >= 0 )
+                return pip;
+
+            // For invalid multi-polygons
+            //if ( 1 == pip ) // inside polygon
+            //    return 1;
+            //else if ( res < pip ) // point must be inside at least one polygon
+            //    res = pip;
+        }
+
+        return -1; // for valid multipolygons
+        //return res; // for invalid multipolygons
+    }
+};
+
+}} // namespace detail_dispatch::within
+
+namespace detail { namespace within {
+
+// 1 - in the interior
+// 0 - in the boundry
+// -1 - in the exterior
+template <typename Point, typename Geometry, typename Strategy>
+inline int point_in_geometry(Point const& point, Geometry const& geometry, Strategy const& strategy)
+{
+    concepts::within::check<Point, Geometry, Strategy>();
+
+    return detail_dispatch::within::point_in_geometry<Geometry>::apply(point, geometry, strategy);
+}
+
+template <typename Point, typename Geometry>
+inline int point_in_geometry(Point const& point, Geometry const& geometry)
+{
+    typedef typename strategy::point_in_geometry::services::default_strategy
+        <
+            Point, Geometry
+        >::type strategy_type;
+
+    return point_in_geometry(point, geometry, strategy_type());
+}
+
+template <typename Point, typename Geometry, typename Strategy>
+inline bool within_point_geometry(Point const& point, Geometry const& geometry, Strategy const& strategy)
+{
+    return point_in_geometry(point, geometry, strategy) > 0;
+}
+
+template <typename Point, typename Geometry>
+inline bool within_point_geometry(Point const& point, Geometry const& geometry)
+{
+    return point_in_geometry(point, geometry) > 0;
+}
+
+template <typename Point, typename Geometry, typename Strategy>
+inline bool covered_by_point_geometry(Point const& point, Geometry const& geometry, Strategy const& strategy)
+{
+    return point_in_geometry(point, geometry, strategy) >= 0;
+}
+
+template <typename Point, typename Geometry>
+inline bool covered_by_point_geometry(Point const& point, Geometry const& geometry)
+{
+    return point_in_geometry(point, geometry) >= 0;
+}
+
+}} // namespace detail::within
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_POINT_IN_GEOMETRY_HPP

macx64/include/boost/geometry/algorithms/detail/within/within_no_turns.hpp

@@ -0,0 +1,221 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013.
+// Modifications copyright (c) 2013, Oracle and/or its affiliates.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_WITHIN_NO_TURNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_WITHIN_NO_TURNS_HPP
+
+#include <boost/geometry/algorithms/detail/point_on_border.hpp>
+#include <boost/geometry/algorithms/detail/within/point_in_geometry.hpp>
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail_dispatch { namespace within {
+
+// returns true if G1 is within G2
+// this function should be called only if there are no intersection points
+// otherwise it may return invalid result
+// e.g. when non-first point of G1 is outside G2 or when some rings of G1 are the same as rings of G2
+
+template <typename Geometry1,
+          typename Geometry2,
+          typename Tag1 = typename geometry::tag<Geometry1>::type,
+          typename Tag2 = typename geometry::tag<Geometry2>::type>
+struct within_no_turns
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        typedef typename geometry::point_type<Geometry1>::type point1_type;
+        point1_type p;
+        if ( !geometry::point_on_border(p, geometry1) )
+            return false;
+
+        return detail::within::point_in_geometry(p, geometry2, strategy) >= 0;
+    }
+};
+
+template <typename Geometry1, typename Geometry2>
+struct within_no_turns<Geometry1, Geometry2, ring_tag, polygon_tag>
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        typedef typename geometry::point_type<Geometry1>::type point1_type;
+        typedef typename geometry::point_type<Geometry2>::type point2_type;
+        point1_type p;
+        if ( !geometry::point_on_border(p, geometry1) )
+            return false;
+        // check if one of ring points is outside the polygon
+        if ( detail::within::point_in_geometry(p, geometry2, strategy) < 0 )
+            return false;
+        // Now check if holes of G2 aren't inside G1
+        typedef typename boost::range_const_iterator
+            <
+                typename geometry::interior_type<Geometry2>::type
+            >::type iterator;
+        for ( iterator it = boost::begin(geometry::interior_rings(geometry2)) ;
+              it != boost::end(geometry::interior_rings(geometry2)) ;
+              ++it )
+        {
+            point2_type p;
+            if ( !geometry::point_on_border(p, *it) )
+                return false;
+            if ( detail::within::point_in_geometry(p, geometry1, strategy) > 0 )
+                return false;
+        }
+        return true;
+    }
+};
+
+template <typename Geometry1, typename Geometry2>
+struct within_no_turns<Geometry1, Geometry2, polygon_tag, polygon_tag>
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        typedef typename geometry::point_type<Geometry1>::type point1_type;
+        typedef typename geometry::point_type<Geometry2>::type point2_type;
+        point1_type p;
+        if ( !geometry::point_on_border(p, geometry1) )
+            return false;
+        // check if one of ring points is outside the polygon
+        if ( detail::within::point_in_geometry(p, geometry2, strategy) < 0 )
+            return false;
+        // Now check if holes of G2 aren't inside G1
+        typedef typename boost::range_const_iterator
+            <
+                typename geometry::interior_type<Geometry2>::type
+            >::type iterator2;
+        for ( iterator2 it = boost::begin(geometry::interior_rings(geometry2)) ;
+              it != boost::end(geometry::interior_rings(geometry2)) ;
+              ++it )
+        {
+            point2_type p2;
+            if ( !geometry::point_on_border(p2, *it) )
+                return false;
+            // if the hole of G2 is inside G1
+            if ( detail::within::point_in_geometry(p2, geometry1, strategy) > 0 )
+            {
+                // if it's also inside one of the G1 holes, it's ok
+                bool ok = false;
+                typedef typename boost::range_const_iterator
+                    <
+                        typename geometry::interior_type<Geometry1>::type
+                    >::type iterator1;
+                for ( iterator1 it1 = boost::begin(geometry::interior_rings(geometry1)) ;
+                      it1 != boost::end(geometry::interior_rings(geometry1)) ;
+                      ++it1 )
+                {
+                    if ( detail::within::point_in_geometry(p2, *it1, strategy) < 0 )
+                    {
+                        ok = true;
+                        break;
+                    }
+                }
+                if ( !ok )
+                    return false;
+            }
+        }
+        return true;
+    }
+};
+
+template <typename Geometry1,
+          typename Geometry2,
+          typename Tag1 = typename geometry::tag<Geometry1>::type,
+          typename Tag2 = typename geometry::tag<Geometry2>::type,
+          bool IsMulti1 = boost::is_base_of<geometry::multi_tag, Tag1>::value,
+          bool IsMulti2 = boost::is_base_of<geometry::multi_tag, Tag2>::value>
+struct within_no_turns_multi
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        return within_no_turns<Geometry1, Geometry2>::apply(geometry1, geometry2, strategy);
+    }
+};
+
+template <typename Geometry1, typename Geometry2, typename Tag1, typename Tag2>
+struct within_no_turns_multi<Geometry1, Geometry2, Tag1, Tag2, true, false>
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        // All values of G1 must be inside G2
+        typedef typename boost::range_value<Geometry1>::type subgeometry1;
+        typedef typename boost::range_const_iterator<Geometry1>::type iterator;
+        for ( iterator it = boost::begin(geometry1) ; it != boost::end(geometry1) ; ++it )
+        {
+            if ( !within_no_turns<subgeometry1, Geometry2>::apply(*it, geometry2, strategy) )
+                return false;
+        }
+        return true;
+    }
+};
+
+template <typename Geometry1, typename Geometry2, typename Tag1, typename Tag2>
+struct within_no_turns_multi<Geometry1, Geometry2, Tag1, Tag2, false, true>
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        // G1 must be within at least one value of G2
+        typedef typename boost::range_value<Geometry2>::type subgeometry2;
+        typedef typename boost::range_const_iterator<Geometry2>::type iterator;
+        for ( iterator it = boost::begin(geometry2) ; it != boost::end(geometry2) ; ++it )
+        {
+            if ( within_no_turns<Geometry1, subgeometry2>::apply(geometry1, *it, strategy) )
+                return true;
+        }
+        return false;
+    }
+};
+
+template <typename Geometry1, typename Geometry2, typename Tag1, typename Tag2>
+struct within_no_turns_multi<Geometry1, Geometry2, Tag1, Tag2, true, true>
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        // each value of G1 must be inside at least one value of G2
+        typedef typename boost::range_value<Geometry1>::type subgeometry1;
+        typedef typename boost::range_const_iterator<Geometry1>::type iterator;
+        for ( iterator it = boost::begin(geometry1) ; it != boost::end(geometry1) ; ++it )
+        {
+            if ( !within_no_turns_multi<subgeometry1, Geometry2>::apply(*it, geometry2, strategy) )
+                return false;
+        }
+        return true;
+    }
+};
+
+}} // namespace detail_dispatch::within
+
+namespace detail { namespace within {
+
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline bool within_no_turns(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+{
+    return detail_dispatch::within::within_no_turns_multi<Geometry1, Geometry2>::apply(geometry1, geometry2, strategy);
+}
+
+}} // namespace detail::within
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_WITHIN_NO_TURNS_HPP