FM / algorithms

/usr/include/boost/geometry/index/detail/algorithms/

/usr/include/boost/geometry/index/detail/algorithms

Name	Size	Mode	Actions
bounds.hpp	6457	0644	edit dl rm
comparable_distance_centroid.hpp	2795	0644	edit dl rm
comparable_distance_far.hpp	2395	0644	edit dl rm
comparable_distance_near.hpp	2655	0644	edit dl rm
content.hpp	2380	0644	edit dl rm
diff_abs.hpp	1146	0644	edit dl rm
intersection_content.hpp	2912	0644	edit dl rm
is_valid.hpp	2176	0644	edit dl rm
margin.hpp	5261	0644	edit dl rm
minmaxdist.hpp	4103	0644	edit dl rm
nth_element.hpp	1749	0644	edit dl rm
path_intersection.hpp	4609	0644	edit dl rm
segment_intersection.hpp	5304	0644	edit dl rm
smallest_for_indexable.hpp	2442	0644	edit dl rm
sum_for_indexable.hpp	2237	0644	edit dl rm
union_content.hpp	1103	0644	edit dl rm

Edit: /usr/include/boost/geometry/index/detail/algorithms/bounds.hpp (6457B)

#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_BOUNDS_HPP
#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_BOUNDS_HPP

#include <boost/geometry/index/detail/bounded_view.hpp>

namespace boost { namespace geometry { namespace index { namespace detail
{

namespace dispatch
{

template <typename Geometry,
          typename Bounds,
          typename TagGeometry = typename geometry::tag<Geometry>::type,
          typename TagBounds = typename geometry::tag<Bounds>::type>
struct bounds
{
    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>
{
    template <typename Strategy>
    static inline void apply(Geometry const& g, Bounds & b, Strategy const& s)
    {
        index::detail::bounded_view<Geometry, Bounds, Strategy> v(g, s);
        geometry::convert(v, b);
    }
};

} // namespace dispatch

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, s);
}

namespace dispatch
{

template <typename Bounds,
          typename Geometry,
          typename TagBounds = typename geometry::tag<Bounds>::type,
          typename TagGeometry = typename geometry::tag<Geometry>::type>
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)
{
    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>
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);
    }

template <typename Strategy>
    static inline bool apply(Geometry const& g, Bounds & b, Strategy const&)
    {
        return geometry::covered_by(g, b, typename Strategy::covered_by_box_box_strategy_type());
    }
};

template <typename Geometry, typename Bounds>
struct covered_by_bounds<Geometry, Bounds, segment_tag, box_tag>
{
    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);
    }

template <typename Strategy>
    static inline bool apply(Geometry const& g, Bounds & b, Strategy const& strategy)
    {
        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, 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::covered_by_bounds<Geometry, Bounds>::apply(g, b);
}

}}}} // namespace boost::geometry::index::detail

#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_BOUNDS_HPP

// Boost.Geometry Index // // n-dimensional bounds // // 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) #ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_BOUNDS_HPP #define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_BOUNDS_HPP #include namespace boost { namespace geometry { namespace index { namespace detail { namespace dispatch { template ::type, typename TagBounds = typename geometry::tag::type> struct bounds { template static inline void apply(Geometry const& g, Bounds & b, Strategy const& ) { geometry::convert(g, b); } }; template struct bounds { template static inline void apply(Geometry const& g, Bounds & b, Strategy const& s) { index::detail::bounded_view v(g, s); geometry::convert(v, b); } }; } // namespace dispatch template inline void bounds(Geometry const& g, Bounds & b, Strategy const& s) { concepts::check_concepts_and_equal_dimensions(); dispatch::bounds::apply(g, b, s); } namespace dispatch { template ::type, typename TagGeometry = typename geometry::tag::type> struct expand { // STATIC ASSERT }; template struct expand { static inline void apply(Bounds & b, Geometry const& g) { geometry::expand(b, g); } template static inline void apply(Bounds & b, Geometry const& g, Strategy const& ) { geometry::expand(b, g, typename Strategy::expand_point_strategy_type()); } }; template struct expand { static inline void apply(Bounds & b, Geometry const& g) { geometry::expand(b, g); } template static inline void apply(Bounds & b, Geometry const& g, Strategy const& ) { geometry::expand(b, g, typename Strategy::expand_box_strategy_type()); } }; template struct expand { static inline void apply(Bounds & b, Geometry const& g) { geometry::expand(b, g); } template static inline void apply(Bounds & b, Geometry const& g, Strategy const& s) { index::detail::bounded_view v(g, s); geometry::expand(b, v, typename Strategy::expand_box_strategy_type()); } }; } // namespace dispatch template inline void expand(Bounds & b, Geometry const& g, Strategy const& s) { dispatch::expand::apply(b, g, s); } template inline void expand(Bounds & b, Geometry const& g, default_strategy const& ) { dispatch::expand::apply(b, g); } namespace dispatch { template ::type, typename TagBounds = typename geometry::tag::type> struct covered_by_bounds {}; template struct covered_by_bounds { static inline bool apply(Geometry const& g, Bounds & b) { return geometry::covered_by(g, b); } template 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 struct covered_by_bounds { static inline bool apply(Geometry const& g, Bounds & b) { return geometry::covered_by(g, b); } template static inline bool apply(Geometry const& g, Bounds & b, Strategy const&) { return geometry::covered_by(g, b, typename Strategy::covered_by_box_box_strategy_type()); } }; template struct covered_by_bounds { static inline bool apply(Geometry const& g, Bounds & b) { typedef typename point_type::type point_type; typedef geometry::model::box bounds_type; typedef index::detail::bounded_view view_type; return geometry::covered_by(view_type(g, default_strategy()), b); } template static inline bool apply(Geometry const& g, Bounds & b, Strategy const& strategy) { typedef typename point_type::type point_type; typedef geometry::model::box bounds_type; typedef index::detail::bounded_view view_type; return geometry::covered_by(view_type(g, strategy), b, typename Strategy::covered_by_box_box_strategy_type()); } }; } // namespace dispatch template inline bool covered_by_bounds(Geometry const& g, Bounds & b, Strategy const& s) { return dispatch::covered_by_bounds::apply(g, b, s); } template inline bool covered_by_bounds(Geometry const& g, Bounds & b, default_strategy const& ) { return dispatch::covered_by_bounds::apply(g, b); } }}}} // namespace boost::geometry::index::detail #endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_BOUNDS_HPP