FM / detail

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

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

Name	Size	Mode	Actions
buffer/	-	0755	rm
centroid/	-	0755	rm
closest_feature/	-	0755	rm
comparable_distance/	-	0755	rm
covered_by/	-	0755	rm
disjoint/	-	0755	rm
distance/	-	0755	rm
envelope/	-	0755	rm
equals/	-	0755	rm
expand/	-	0755	rm
intersection/	-	0755	rm
intersects/	-	0755	rm
is_simple/	-	0755	rm
is_valid/	-	0755	rm
make/	-	0755	rm
overlaps/	-	0755	rm
overlay/	-	0755	rm
relate/	-	0755	rm
relation/	-	0755	rm
sections/	-	0755	rm
touches/	-	0755	rm
turns/	-	0755	rm
within/	-	0755	rm
assign_box_corners.hpp	3338	0644	edit dl rm
assign_indexed_point.hpp	2656	0644	edit dl rm
assign_values.hpp	8957	0644	edit dl rm
as_range.hpp	2688	0644	edit dl rm
azimuth.hpp	4802	0644	edit dl rm
calculate_null.hpp	1144	0644	edit dl rm
calculate_point_order.hpp	11145	0644	edit dl rm
calculate_sum.hpp	2047	0644	edit dl rm
check_iterator_range.hpp	2012	0644	edit dl rm
convert_indexed_to_indexed.hpp	2296	0644	edit dl rm
convert_point_to_point.hpp	2259	0644	edit dl rm
counting.hpp	2746	0644	edit dl rm
course.hpp	1180	0644	edit dl rm
direction_code.hpp	9205	0644	edit dl rm
expand_by_epsilon.hpp	3880	0644	edit dl rm
extreme_points.hpp	19767	0644	edit dl rm
for_each_range.hpp	4962	0644	edit dl rm
get_max_size.hpp	2054	0644	edit dl rm
has_self_intersections.hpp	5389	0644	edit dl rm
interior_iterator.hpp	1768	0644	edit dl rm
max_interval_gap.hpp	8430	0644	edit dl rm
multi_modify.hpp	1883	0644	edit dl rm
multi_modify_with_predicate.hpp	1442	0644	edit dl rm
multi_sum.hpp	1490	0644	edit dl rm
normalize.hpp	1296	0644	edit dl rm
not.hpp	2032	0644	edit dl rm
num_distinct_consecutive_points.hpp	2449	0644	edit dl rm
partition.hpp	29824	0644	edit dl rm
point_is_spike_or_equal.hpp	5455	0644	edit dl rm
point_on_border.hpp	5254	0644	edit dl rm
recalculate.hpp	6905	0644	edit dl rm
ring_identifier.hpp	2285	0644	edit dl rm
signed_size_type.hpp	770	0644	edit dl rm
single_geometry.hpp	2840	0644	edit dl rm
sub_range.hpp	4097	0644	edit dl rm
sweep.hpp	2086	0644	edit dl rm
throw_on_empty_input.hpp	2073	0644	edit dl rm
tupled_output.hpp	19235	0644	edit dl rm

Edit: /usr/include/boost/geometry/algorithms/detail/assign_values.hpp (8957B)

// Boost.Geometry (aka GGL, Generic Geometry Library)

// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.

// This file was modified by Oracle on 2018.
// Modifications copyright (c) 2018, Oracle and/or its affiliates.

// Contributed and/or modified by Vissarion Fysikopoulos, 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_ASSIGN_VALUES_HPP
#define BOOST_GEOMETRY_ALGORITHMS_ASSIGN_VALUES_HPP

#include <cstddef>

#include <boost/concept/requires.hpp>
#include <boost/concept_check.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/if.hpp>
#include <boost/numeric/conversion/bounds.hpp>
#include <boost/numeric/conversion/cast.hpp>

#include <boost/geometry/arithmetic/arithmetic.hpp>
#include <boost/geometry/algorithms/append.hpp>
#include <boost/geometry/algorithms/clear.hpp>
#include <boost/geometry/core/access.hpp>
#include <boost/geometry/core/exterior_ring.hpp>
#include <boost/geometry/core/tags.hpp>

#include <boost/geometry/geometries/concepts/check.hpp>

#include <boost/geometry/util/is_inverse_spheroidal_coordinates.hpp>
#include <boost/geometry/util/for_each_coordinate.hpp>

namespace boost { namespace geometry
{

#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace assign
{

template <std::size_t Index, std::size_t Dimension, std::size_t DimensionCount>
struct initialize
{
    template <typename Box>
    static inline void apply(Box& box, typename coordinate_type<Box>::type const& value)
    {
        geometry::set<Index, Dimension>(box, value);
        initialize<Index, Dimension + 1, DimensionCount>::apply(box, value);
    }
};

template <std::size_t Index, std::size_t DimensionCount>
struct initialize<Index, DimensionCount, DimensionCount>
{
    template <typename Box>
    static inline void apply(Box&, typename coordinate_type<Box>::type const&)
    {}
};

struct assign_zero_point
{
    template <typename Point>
    static inline void apply(Point& point)
    {
        geometry::assign_value(point, 0);
    }
};

struct assign_inverse_box_or_segment
{

template <typename BoxOrSegment>
    static inline void apply(BoxOrSegment& geometry)
    {
        typedef typename point_type<BoxOrSegment>::type point_type;
        typedef typename coordinate_type<point_type>::type bound_type;

initialize<0, 0, dimension<BoxOrSegment>::type::value>::apply(
            geometry, geometry::bounds<bound_type>::highest()
        );
        initialize<1, 0, dimension<BoxOrSegment>::type::value>::apply(
            geometry, geometry::bounds<bound_type>::lowest()
        );
    }

};

struct assign_zero_box_or_segment
{
    template <typename BoxOrSegment>
    static inline void apply(BoxOrSegment& geometry)
    {
        typedef typename coordinate_type<BoxOrSegment>::type coordinate_type;

initialize<0, 0, dimension<BoxOrSegment>::type::value>::apply(
            geometry, coordinate_type()
        );
        initialize<1, 0, dimension<BoxOrSegment>::type::value>::apply(
            geometry, coordinate_type()
        );
    }
};

template
<
    std::size_t Corner1, std::size_t Corner2,
    typename Box, typename Point
>
inline void assign_box_2d_corner(Box const& box, Point& point)
{
    // Be sure both are 2-Dimensional
    assert_dimension<Box, 2>();
    assert_dimension<Point, 2>();

// Copy coordinates
    typedef typename coordinate_type<Point>::type coordinate_type;

geometry::set<0>(point, boost::numeric_cast<coordinate_type>(get<Corner1, 0>(box)));
    geometry::set<1>(point, boost::numeric_cast<coordinate_type>(get<Corner2, 1>(box)));
}

template
<
    typename Geometry, typename Point,
    std::size_t Index,
    std::size_t Dimension, std::size_t DimensionCount
>
struct assign_point_to_index
{

static inline void apply(Point const& point, Geometry& geometry)
    {
        geometry::set<Index, Dimension>(geometry, boost::numeric_cast
            <
                typename coordinate_type<Geometry>::type
            >(geometry::get<Dimension>(point)));

assign_point_to_index
            <
                Geometry, Point, Index, Dimension + 1, DimensionCount
            >::apply(point, geometry);
    }
};

template
<
    typename Geometry, typename Point,
    std::size_t Index,
    std::size_t DimensionCount
>
struct assign_point_to_index
    <
        Geometry, Point,
        Index,
        DimensionCount, DimensionCount
    >
{
    static inline void apply(Point const& , Geometry& )
    {
    }
};

template
<
    typename Geometry, typename Point,
    std::size_t Index,
    std::size_t Dimension, std::size_t DimensionCount
>
struct assign_point_from_index
{

static inline void apply(Geometry const& geometry, Point& point)
    {
        geometry::set<Dimension>( point, boost::numeric_cast
            <
                typename coordinate_type<Point>::type
            >(geometry::get<Index, Dimension>(geometry)));

assign_point_from_index
            <
                Geometry, Point, Index, Dimension + 1, DimensionCount
            >::apply(geometry, point);
    }
};

template
<
    typename Geometry, typename Point,
    std::size_t Index,
    std::size_t DimensionCount
>
struct assign_point_from_index
    <
        Geometry, Point,
        Index,
        DimensionCount, DimensionCount
    >
{
    static inline void apply(Geometry const&, Point&)
    {
    }
};

template <typename Geometry>
struct assign_2d_box_or_segment
{
    typedef typename coordinate_type<Geometry>::type coordinate_type;

// Here we assign 4 coordinates to a box of segment
    // -> Most logical is: x1,y1,x2,y2
    // In case the user reverses x1/x2 or y1/y2, for a box, we could reverse them (THAT IS NOT IMPLEMENTED)

template <typename Type>
    static inline void apply(Geometry& geometry,
                Type const& x1, Type const& y1, Type const& x2, Type const& y2)
    {
        geometry::set<0, 0>(geometry, boost::numeric_cast<coordinate_type>(x1));
        geometry::set<0, 1>(geometry, boost::numeric_cast<coordinate_type>(y1));
        geometry::set<1, 0>(geometry, boost::numeric_cast<coordinate_type>(x2));
        geometry::set<1, 1>(geometry, boost::numeric_cast<coordinate_type>(y2));
    }
};

}} // namespace detail::assign
#endif // DOXYGEN_NO_DETAIL

#ifndef DOXYGEN_NO_DISPATCH
namespace dispatch
{

template <typename GeometryTag, typename Geometry, std::size_t DimensionCount>
struct assign
{
    BOOST_MPL_ASSERT_MSG
        (
            false, NOT_OR_NOT_YET_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
            , (types<Geometry>)
        );
};

template <typename Point>
struct assign<point_tag, Point, 2>
{
    typedef typename coordinate_type<Point>::type coordinate_type;

template <typename T>
    static inline void apply(Point& point, T const& c1, T const& c2)
    {
        set<0>(point, boost::numeric_cast<coordinate_type>(c1));
        set<1>(point, boost::numeric_cast<coordinate_type>(c2));
    }
};

template <typename Point>
struct assign<point_tag, Point, 3>
{
    typedef typename coordinate_type<Point>::type coordinate_type;

template <typename T>
    static inline void apply(Point& point, T const& c1, T const& c2, T const& c3)
    {
        set<0>(point, boost::numeric_cast<coordinate_type>(c1));
        set<1>(point, boost::numeric_cast<coordinate_type>(c2));
        set<2>(point, boost::numeric_cast<coordinate_type>(c3));
    }
};

template <typename Box>
struct assign<box_tag, Box, 2>
    : detail::assign::assign_2d_box_or_segment<Box>
{};

template <typename Segment>
struct assign<segment_tag, Segment, 2>
    : detail::assign::assign_2d_box_or_segment<Segment>
{};

template <typename GeometryTag, typename Geometry>
struct assign_zero {};

template <typename Point>
struct assign_zero<point_tag, Point>
    : detail::assign::assign_zero_point
{};

template <typename Box>
struct assign_zero<box_tag, Box>
    : detail::assign::assign_zero_box_or_segment
{};

template <typename Segment>
struct assign_zero<segment_tag, Segment>
    : detail::assign::assign_zero_box_or_segment
{};

template <typename GeometryTag, typename Geometry>
struct assign_inverse {};

template <typename Box>
struct assign_inverse<box_tag, Box>
    : detail::assign::assign_inverse_box_or_segment
{};

template <typename Segment>
struct assign_inverse<segment_tag, Segment>
    : detail::assign::assign_inverse_box_or_segment
{};

} // namespace dispatch
#endif // DOXYGEN_NO_DISPATCH

}} // namespace boost::geometry

#endif // BOOST_GEOMETRY_ALGORITHMS_ASSIGN_VALUES_HPP

// 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. // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // This file was modified by Oracle on 2018. // Modifications copyright (c) 2018, Oracle and/or its affiliates. // Contributed and/or modified by Vissarion Fysikopoulos, 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_ASSIGN_VALUES_HPP #define BOOST_GEOMETRY_ALGORITHMS_ASSIGN_VALUES_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace geometry { #ifndef DOXYGEN_NO_DETAIL namespace detail { namespace assign { template struct initialize { template static inline void apply(Box& box, typename coordinate_type::type const& value) { geometry::set(box, value); initialize::apply(box, value); } }; template struct initialize { template static inline void apply(Box&, typename coordinate_type::type const&) {} }; struct assign_zero_point { template static inline void apply(Point& point) { geometry::assign_value(point, 0); } }; struct assign_inverse_box_or_segment { template static inline void apply(BoxOrSegment& geometry) { typedef typename point_type::type point_type; typedef typename coordinate_type::type bound_type; initialize<0, 0, dimension::type::value>::apply( geometry, geometry::bounds::highest() ); initialize<1, 0, dimension::type::value>::apply( geometry, geometry::bounds::lowest() ); } }; struct assign_zero_box_or_segment { template static inline void apply(BoxOrSegment& geometry) { typedef typename coordinate_type::type coordinate_type; initialize<0, 0, dimension::type::value>::apply( geometry, coordinate_type() ); initialize<1, 0, dimension::type::value>::apply( geometry, coordinate_type() ); } }; template < std::size_t Corner1, std::size_t Corner2, typename Box, typename Point > inline void assign_box_2d_corner(Box const& box, Point& point) { // Be sure both are 2-Dimensional assert_dimension(); assert_dimension(); // Copy coordinates typedef typename coordinate_type::type coordinate_type; geometry::set<0>(point, boost::numeric_cast(get(box))); geometry::set<1>(point, boost::numeric_cast(get(box))); } template < typename Geometry, typename Point, std::size_t Index, std::size_t Dimension, std::size_t DimensionCount > struct assign_point_to_index { static inline void apply(Point const& point, Geometry& geometry) { geometry::set(geometry, boost::numeric_cast < typename coordinate_type::type >(geometry::get(point))); assign_point_to_index < Geometry, Point, Index, Dimension + 1, DimensionCount >::apply(point, geometry); } }; template < typename Geometry, typename Point, std::size_t Index, std::size_t DimensionCount > struct assign_point_to_index < Geometry, Point, Index, DimensionCount, DimensionCount > { static inline void apply(Point const& , Geometry& ) { } }; template < typename Geometry, typename Point, std::size_t Index, std::size_t Dimension, std::size_t DimensionCount > struct assign_point_from_index { static inline void apply(Geometry const& geometry, Point& point) { geometry::set( point, boost::numeric_cast < typename coordinate_type::type >(geometry::get(geometry))); assign_point_from_index < Geometry, Point, Index, Dimension + 1, DimensionCount >::apply(geometry, point); } }; template < typename Geometry, typename Point, std::size_t Index, std::size_t DimensionCount > struct assign_point_from_index < Geometry, Point, Index, DimensionCount, DimensionCount > { static inline void apply(Geometry const&, Point&) { } }; template struct assign_2d_box_or_segment { typedef typename coordinate_type::type coordinate_type; // Here we assign 4 coordinates to a box of segment // -> Most logical is: x1,y1,x2,y2 // In case the user reverses x1/x2 or y1/y2, for a box, we could reverse them (THAT IS NOT IMPLEMENTED) template static inline void apply(Geometry& geometry, Type const& x1, Type const& y1, Type const& x2, Type const& y2) { geometry::set<0, 0>(geometry, boost::numeric_cast(x1)); geometry::set<0, 1>(geometry, boost::numeric_cast(y1)); geometry::set<1, 0>(geometry, boost::numeric_cast(x2)); geometry::set<1, 1>(geometry, boost::numeric_cast(y2)); } }; }} // namespace detail::assign #endif // DOXYGEN_NO_DETAIL #ifndef DOXYGEN_NO_DISPATCH namespace dispatch { template struct assign { BOOST_MPL_ASSERT_MSG ( false, NOT_OR_NOT_YET_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE , (types) ); }; template struct assign { typedef typename coordinate_type::type coordinate_type; template static inline void apply(Point& point, T const& c1, T const& c2) { set<0>(point, boost::numeric_cast(c1)); set<1>(point, boost::numeric_cast(c2)); } }; template struct assign { typedef typename coordinate_type::type coordinate_type; template static inline void apply(Point& point, T const& c1, T const& c2, T const& c3) { set<0>(point, boost::numeric_cast(c1)); set<1>(point, boost::numeric_cast(c2)); set<2>(point, boost::numeric_cast(c3)); } }; template struct assign : detail::assign::assign_2d_box_or_segment {}; template struct assign : detail::assign::assign_2d_box_or_segment {}; template struct assign_zero {}; template struct assign_zero : detail::assign::assign_zero_point {}; template struct assign_zero : detail::assign::assign_zero_box_or_segment {}; template struct assign_zero : detail::assign::assign_zero_box_or_segment {}; template struct assign_inverse {}; template struct assign_inverse : detail::assign::assign_inverse_box_or_segment {}; template struct assign_inverse : detail::assign::assign_inverse_box_or_segment {}; } // namespace dispatch #endif // DOXYGEN_NO_DISPATCH }} // namespace boost::geometry #endif // BOOST_GEOMETRY_ALGORITHMS_ASSIGN_VALUES_HPP