//
// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
//
+// This file was modified by Oracle on 2019.
+// Modifications copyright (c) 2019 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)
#include <boost/geometry/index/detail/bounded_view.hpp>
-namespace boost { namespace geometry { namespace index { namespace detail {
+namespace boost { namespace geometry { namespace index { namespace detail
+{
-namespace dispatch {
+namespace dispatch
+{
template <typename Geometry,
typename Bounds,
typename TagBounds = typename geometry::tag<Bounds>::type>
struct bounds
{
- static inline void apply(Geometry const& g, Bounds & b)
+ template <typename Strategy>
+ static inline void apply(Geometry const& g, Bounds & b, Strategy const& )
{
geometry::convert(g, b);
}
template <typename Geometry, typename Bounds>
struct bounds<Geometry, Bounds, segment_tag, box_tag>
{
- static inline void apply(Geometry const& g, Bounds & b)
+ template <typename Strategy>
+ static inline void apply(Geometry const& g, Bounds & b, Strategy const& s)
{
- index::detail::bounded_view<Geometry, Bounds> v(g);
+ index::detail::bounded_view<Geometry, Bounds, Strategy> v(g, s);
geometry::convert(v, b);
}
};
+
} // namespace dispatch
-template <typename Geometry, typename Bounds>
-inline void bounds(Geometry const& g, Bounds & b)
+
+template <typename Geometry, typename Bounds, typename Strategy>
+inline void bounds(Geometry const& g, Bounds & b, Strategy const& s)
{
concepts::check_concepts_and_equal_dimensions<Geometry const, Bounds>();
- dispatch::bounds<Geometry, Bounds>::apply(g, b);
+ dispatch::bounds<Geometry, Bounds>::apply(g, b, s);
}
-namespace dispatch {
-template <typename Geometry,
+namespace dispatch
+{
+
+template <typename Bounds,
+ typename Geometry,
+ typename TagBounds = typename geometry::tag<Bounds>::type,
typename TagGeometry = typename geometry::tag<Geometry>::type>
-struct return_ref_or_bounds
+struct expand
+{
+ // STATIC ASSERT
+};
+
+template <typename Bounds, typename Geometry>
+struct expand<Bounds, Geometry, box_tag, point_tag>
+{
+ static inline void apply(Bounds & b, Geometry const& g)
+ {
+ geometry::expand(b, g);
+ }
+
+ template <typename Strategy>
+ static inline void apply(Bounds & b, Geometry const& g, Strategy const& )
+ {
+ geometry::expand(b, g, typename Strategy::expand_point_strategy_type());
+ }
+};
+
+template <typename Bounds, typename Geometry>
+struct expand<Bounds, Geometry, box_tag, box_tag>
+{
+ static inline void apply(Bounds & b, Geometry const& g)
+ {
+ geometry::expand(b, g);
+ }
+
+ template <typename Strategy>
+ static inline void apply(Bounds & b, Geometry const& g, Strategy const& )
+ {
+ geometry::expand(b, g, typename Strategy::expand_box_strategy_type());
+ }
+};
+
+template <typename Bounds, typename Geometry>
+struct expand<Bounds, Geometry, box_tag, segment_tag>
+{
+ static inline void apply(Bounds & b, Geometry const& g)
+ {
+ geometry::expand(b, g);
+ }
+
+ template <typename Strategy>
+ static inline void apply(Bounds & b, Geometry const& g, Strategy const& s)
+ {
+ index::detail::bounded_view<Geometry, Bounds, Strategy> v(g, s);
+ geometry::expand(b, v, typename Strategy::expand_box_strategy_type());
+ }
+};
+
+
+} // namespace dispatch
+
+
+template <typename Bounds, typename Geometry, typename Strategy>
+inline void expand(Bounds & b, Geometry const& g, Strategy const& s)
{
- typedef Geometry const& result_type;
+ dispatch::expand<Bounds, Geometry>::apply(b, g, s);
+}
+
+template <typename Bounds, typename Geometry>
+inline void expand(Bounds & b, Geometry const& g, default_strategy const& )
+{
+ dispatch::expand<Bounds, Geometry>::apply(b, g);
+}
+
+
+namespace dispatch
+{
+
+
+template <typename Geometry,
+ typename Bounds,
+ typename TagGeometry = typename geometry::tag<Geometry>::type,
+ typename TagBounds = typename geometry::tag<Bounds>::type>
+struct covered_by_bounds
+{};
+
+template <typename Geometry, typename Bounds>
+struct covered_by_bounds<Geometry, Bounds, point_tag, box_tag>
+{
+ static inline bool apply(Geometry const& g, Bounds & b)
+ {
+ return geometry::covered_by(g, b);
+ }
+
+ template <typename Strategy>
+ static inline bool apply(Geometry const& g, Bounds & b, Strategy const&)
+ {
+ return geometry::covered_by(g, b, typename Strategy::covered_by_point_box_strategy_type());
+ }
+};
+
+template <typename Geometry, typename Bounds>
+struct covered_by_bounds<Geometry, Bounds, box_tag, box_tag>
+{
+ static inline bool apply(Geometry const& g, Bounds & b)
+ {
+ return geometry::covered_by(g, b);
+ }
- static inline result_type apply(Geometry const& g)
+ template <typename Strategy>
+ static inline bool apply(Geometry const& g, Bounds & b, Strategy const&)
{
- return g;
+ return geometry::covered_by(g, b, typename Strategy::covered_by_box_box_strategy_type());
}
};
-template <typename Geometry>
-struct return_ref_or_bounds<Geometry, segment_tag>
+template <typename Geometry, typename Bounds>
+struct covered_by_bounds<Geometry, Bounds, segment_tag, box_tag>
{
- typedef typename point_type<Geometry>::type point_type;
- typedef geometry::model::box<point_type> bounds_type;
- typedef index::detail::bounded_view<Geometry, bounds_type> result_type;
+ static inline bool apply(Geometry const& g, Bounds & b)
+ {
+ typedef typename point_type<Geometry>::type point_type;
+ typedef geometry::model::box<point_type> bounds_type;
+ typedef index::detail::bounded_view<Geometry, bounds_type, default_strategy> view_type;
+
+ return geometry::covered_by(view_type(g, default_strategy()), b);
+ }
- static inline result_type apply(Geometry const& g)
+ template <typename Strategy>
+ static inline bool apply(Geometry const& g, Bounds & b, Strategy const& strategy)
{
- return result_type(g);
+ typedef typename point_type<Geometry>::type point_type;
+ typedef geometry::model::box<point_type> bounds_type;
+ typedef index::detail::bounded_view<Geometry, bounds_type, Strategy> view_type;
+
+ return geometry::covered_by(view_type(g, strategy), b,
+ typename Strategy::covered_by_box_box_strategy_type());
}
};
+
} // namespace dispatch
-template <typename Geometry>
-inline
-typename dispatch::return_ref_or_bounds<Geometry>::result_type
-return_ref_or_bounds(Geometry const& g)
+
+template <typename Geometry, typename Bounds, typename Strategy>
+inline bool covered_by_bounds(Geometry const& g, Bounds & b, Strategy const& s)
+{
+ return dispatch::covered_by_bounds<Geometry, Bounds>::apply(g, b, s);
+}
+
+template <typename Geometry, typename Bounds>
+inline bool covered_by_bounds(Geometry const& g, Bounds & b, default_strategy const& )
{
- return dispatch::return_ref_or_bounds<Geometry>::apply(g);
+ return dispatch::covered_by_bounds<Geometry, Bounds>::apply(g, b);
}
+
}}}} // namespace boost::geometry::index::detail
+
#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_BOUNDS_HPP
projects / ceph.git / blobdiff