boost_mirror/geometry
1
0
Fork 0
mirror of https://github.com/boostorg/geometry.git synced 2025-05-09 15:14:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: change coordinate_type to coordinate_type_t and use 'using' at those places

Browse Source
This commit is contained in:
Barend Gehrels 2024-10-28 22:26:22 +01:00
parent 19f22c2475
commit 08a71cf124
144 changed files with 499 additions and 539 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/boost/geometry/algorithms/area_result.hpp
View File

@ -72,11 +72,11 @@ template <typename Curr, typename Next>
struct more_precise_coordinate_type
: std::is_same
<
typename geometry::coordinate_type<Curr>::type,
geometry::coordinate_type_t<Curr>,
typename geometry::select_most_precise
<
typename geometry::coordinate_type<Curr>::type,
typename geometry::coordinate_type<Next>::type
geometry::coordinate_type_t<Curr>,
geometry::coordinate_type_t<Next>
>::type
>
{};

11
include/boost/geometry/algorithms/azimuth.hpp
View File

@ -58,11 +58,12 @@ struct azimuth<Point1, Point2, point_tag, point_tag>
template <typename Strategy>
static auto apply(Point1 const& p1, Point2 const& p2, Strategy const& strategy)
{
typedef typename decltype(strategy.azimuth())::template result_type
auto azimuth_strategy = strategy.azimuth();
using calc_t = typename decltype(azimuth_strategy)::template result_type
<
typename coordinate_type<Point1>::type,
typename coordinate_type<Point2>::type
>::type calc_t;
coordinate_type_t<Point1>,
coordinate_type_t<Point2>
>::type;
calc_t result = 0;
calc_t const x1 = geometry::get_as_radian<0>(p1);
@ -70,7 +71,7 @@ struct azimuth<Point1, Point2, point_tag, point_tag>
calc_t const x2 = geometry::get_as_radian<0>(p2);
calc_t const y2 = geometry::get_as_radian<1>(p2);
strategy.azimuth().apply(x1, y1, x2, y2, result);
azimuth_strategy.apply(x1, y1, x2, y2, result);
// NOTE: It is not clear which units we should use for the result.
// For now radians are always returned but a user could expect

7
include/boost/geometry/algorithms/detail/assign_indexed_point.hpp
View File

@ -59,10 +59,7 @@ inline void assign_point_to_index(Point const& point, Geometry& geometry)
detail::for_each_dimension<Geometry>([&](auto dimension)
{
geometry::set<Index, dimension>(geometry,
util::numeric_cast
<
typename coordinate_type<Geometry>::type
>(geometry::get<dimension>(point)));
util::numeric_cast<coordinate_type_t<Geometry>>(geometry::get<dimension>(point)));
});
}
@ -93,7 +90,7 @@ inline void assign_point_from_index(Geometry const& geometry, Point& point)
geometry::set<dimension>(point,
util::numeric_cast
<
typename coordinate_type<Point>::type
coordinate_type_t<Point>
>(geometry::get<Index, dimension>(geometry)));
});
}

14
include/boost/geometry/algorithms/detail/assign_values.hpp
View File

@ -54,7 +54,7 @@ struct assign_zero_point
template <typename Point>
static inline void apply(Point& point)
{
typedef typename coordinate_type<Point>::type coordinate_type;
using coordinate_type = coordinate_type_t<Point>;
coordinate_type const zero = 0;
detail::for_each_dimension<Point>([&](auto dimension)
@ -71,7 +71,7 @@ struct assign_inverse_box_or_segment
template <typename BoxOrSegment>
static inline void apply(BoxOrSegment& geometry)
{
typedef typename coordinate_type<BoxOrSegment>::type coordinate_type;
using coordinate_type = coordinate_type_t<BoxOrSegment>;
coordinate_type const highest = util::bounds<coordinate_type>::highest();
coordinate_type const lowest = util::bounds<coordinate_type>::lowest();
@ -90,7 +90,7 @@ struct assign_zero_box_or_segment
template <typename BoxOrSegment>
static inline void apply(BoxOrSegment& geometry)
{
typedef typename coordinate_type<BoxOrSegment>::type coordinate_type;
using coordinate_type = coordinate_type_t<BoxOrSegment>;
coordinate_type const zero = 0;
detail::for_each_dimension<BoxOrSegment>([&](auto dimension)
@ -114,7 +114,7 @@ inline void assign_box_2d_corner(Box const& box, Point& point)
assert_dimension<Point, 2>();
// Copy coordinates
typedef typename coordinate_type<Point>::type coordinate_type;
using coordinate_type = coordinate_type_t<Point>;
geometry::set<0>(point, util::numeric_cast<coordinate_type>(get<Corner1, 0>(box)));
geometry::set<1>(point, util::numeric_cast<coordinate_type>(get<Corner2, 1>(box)));
@ -125,7 +125,7 @@ inline void assign_box_2d_corner(Box const& box, Point& point)
template <typename Geometry>
struct assign_2d_box_or_segment
{
typedef typename coordinate_type<Geometry>::type coordinate_type;
using coordinate_type = coordinate_type_t<Geometry>;
// Here we assign 4 coordinates to a box of segment
// -> Most logical is: x1,y1,x2,y2
@ -161,7 +161,7 @@ struct assign
template <typename Point>
struct assign<point_tag, Point, 2>
{
typedef typename coordinate_type<Point>::type coordinate_type;
using coordinate_type = coordinate_type_t<Point>;
template <typename T>
static inline void apply(Point& point, T const& c1, T const& c2)
@ -174,7 +174,7 @@ struct assign<point_tag, Point, 2>
template <typename Point>
struct assign<point_tag, Point, 3>
{
typedef typename coordinate_type<Point>::type coordinate_type;
using coordinate_type = coordinate_type_t<Point>;
template <typename T>
static inline void apply(Point& point, T const& c1, T const& c2, T const& c3)

2
include/boost/geometry/algorithms/detail/buffer/buffer_box.hpp
View File

@ -26,7 +26,7 @@ namespace detail { namespace buffer
template <typename BoxIn, typename BoxOut, typename T, std::size_t C, std::size_t D, std::size_t N>
struct box_loop
{
typedef typename coordinate_type<BoxOut>::type coordinate_type;
using coordinate_type = coordinate_type_t<BoxOut>;
static inline void apply(BoxIn const& box_in, T const& distance, BoxOut& box_out)
{

4
include/boost/geometry/algorithms/detail/buffer/buffered_piece_collection.hpp
View File

@ -124,8 +124,8 @@ template
>
struct buffered_piece_collection
{
typedef typename geometry::point_type<Ring>::type point_type;
typedef typename geometry::coordinate_type<Ring>::type coordinate_type;
using point_type = geometry::point_type_t<Ring>;
using coordinate_type = geometry::coordinate_type_t<Ring>;
// Ring/polygon type, always clockwise
typedef geometry::model::ring<point_type> clockwise_ring_type;

4
include/boost/geometry/algorithms/detail/buffer/buffered_ring.hpp
View File

@ -129,13 +129,13 @@ struct closure<geometry::detail::buffer::buffered_ring<Ring> >
template <typename Ring>
struct point_type<geometry::detail::buffer::buffered_ring_collection<Ring> >
{
typedef typename geometry::point_type<Ring>::type type;
using type = geometry::point_type_t<Ring>;
};
template <typename Ring>
struct tag<geometry::detail::buffer::buffered_ring_collection<Ring> >
{
typedef geometry::detail::buffer::buffered_ring_collection_tag type;
using type = geometry::detail::buffer::buffered_ring_collection_tag;
};

4
include/boost/geometry/algorithms/detail/buffer/get_piece_turns.hpp
View File

@ -43,8 +43,8 @@ namespace detail { namespace buffer
template <typename Ring>
struct unique_sub_range_from_piece
{
typedef typename boost::range_iterator<Ring const>::type iterator_type;
typedef typename geometry::point_type<Ring const>::type point_type;
using iterator_type = typename boost::range_iterator<Ring const>::type;
using point_type = geometry::point_type_t<Ring const>;
unique_sub_range_from_piece(Ring const& ring,
iterator_type iterator_at_i, iterator_type iterator_at_j)

2
include/boost/geometry/algorithms/detail/buffer/line_line_intersection.hpp
View File

@ -64,7 +64,7 @@ struct line_line_intersection
// in a custom strategy, then the calculation of the point in between
// might be incorrect and the optimization is not used.
using ct = typename coordinate_type<Point>::type;
using ct = coordinate_type_t<Point>;
auto const p = detail::make::make_infinite_line<ct>(pi, pj);
auto const q = detail::make::make_infinite_line<ct>(qi, qj);

6
include/boost/geometry/algorithms/detail/buffer/piece_border.hpp
View File

@ -103,9 +103,9 @@ namespace detail { namespace buffer
template <typename Ring, typename Point>
struct piece_border
{
typedef typename geometry::coordinate_type<Point>::type coordinate_type;
typedef typename default_comparable_distance_result<Point>::type radius_type;
typedef typename geometry::strategy::buffer::turn_in_ring_winding<coordinate_type>::state_type state_type;
using coordinate_type = geometry::coordinate_type_t<Point>;
using radius_type = typename default_comparable_distance_result<Point>::type;
using state_type = typename geometry::strategy::buffer::turn_in_ring_winding<coordinate_type>::state_type;
bool m_reversed;

8
include/boost/geometry/algorithms/detail/centroid/translating_transformer.hpp
View File

@ -53,8 +53,8 @@ template
>
struct translating_transformer
{
typedef typename geometry::point_type<Geometry>::type point_type;
typedef boost::reference_wrapper<point_type const> result_type;
using point_type = geometry::point_type_t<Geometry>;
using result_type = boost::reference_wrapper<point_type const>;
explicit translating_transformer(Geometry const&) {}
explicit translating_transformer(point_type const&) {}
@ -72,8 +72,8 @@ struct translating_transformer
template <typename Geometry>
struct translating_transformer<Geometry, areal_tag, cartesian_tag>
{
typedef typename geometry::point_type<Geometry>::type point_type;
typedef point_type result_type;
using point_type = geometry::point_type_t<Geometry>;
using result_type = point_type;
explicit translating_transformer(Geometry const& geom)
: m_origin(NULL)

4
include/boost/geometry/algorithms/detail/closest_points/linear_or_areal_to_areal.hpp
View File

@ -38,7 +38,7 @@ struct linear_to_areal
using point_type = typename std::conditional
<
std::is_same<typename coordinate_type<Linear>::type, most_precise_type>::value,
std::is_same<coordinate_type_t<Linear>, most_precise_type>::value,
point_type_t<Linear>,
point_type_t<Areal>
>::type;
@ -141,7 +141,7 @@ struct areal_to_areal
using point_type = typename std::conditional
<
std::is_same<typename coordinate_type<Areal1>::type, most_precise_type>::value,
std::is_same<coordinate_type_t<Areal1>, most_precise_type>::value,
point_type_t<Areal1>,
point_type_t<Areal2>
>::type;

2
include/boost/geometry/algorithms/detail/convert_indexed_to_indexed.hpp
View File

@ -42,7 +42,7 @@ struct indexed_to_indexed
{
static inline void apply(Source const& source, Destination& destination)
{
typedef typename coordinate_type<Destination>::type coordinate_type;
using coordinate_type = coordinate_type_t<Destination>;
geometry::set<min_corner, Dimension>(destination,
util::numeric_cast<coordinate_type>(

2
include/boost/geometry/algorithms/detail/convert_point_to_point.hpp
View File

@ -43,7 +43,7 @@ struct point_to_point
{
static inline void apply(Source const& source, Destination& destination)
{
typedef typename coordinate_type<Destination>::type coordinate_type;
using coordinate_type = coordinate_type_t<Destination>;
set<Dimension>(destination, util::numeric_cast<coordinate_type>(get<Dimension>(source)));
point_to_point<Source, Destination, Dimension + 1, DimensionCount>::apply(source, destination);

2
include/boost/geometry/algorithms/detail/convex_hull/interface.hpp
View File

@ -258,7 +258,7 @@ struct convex_hull<GeometryCollection, geometry_collection_tag>
{
// Assuming that single point_type is used by the GeometryCollection
using subgeometry_type = typename detail::first_geometry_type<GeometryCollection>::type;
using point_type = typename geometry::point_type<subgeometry_type>::type;
using point_type = geometry::point_type_t<subgeometry_type>;
using ring_type = model::ring<point_type, true, false>;
// Calculate box rings once

10
include/boost/geometry/algorithms/detail/direction_code.hpp
View File

@ -105,9 +105,9 @@ struct direction_code_impl<spherical_equatorial_tag>
units_sa_t, units_p_t);
}
using coor_sa_t = typename coordinate_type<PointSegmentA>::type;
using coor_sb_t = typename coordinate_type<PointSegmentB>::type;
using coor_p_t = typename coordinate_type<Point2>::type;
using coor_sa_t = coordinate_type_t<PointSegmentA>;
using coor_sb_t = coordinate_type_t<PointSegmentB>;
using coor_p_t = coordinate_type_t<Point2>;
// Declare unit type (equal for all types) and calc type (coerced to most precise)
using units_t = typename cs_angular_units<Point2>::type;
@ -211,12 +211,12 @@ struct direction_code_impl<spherical_polar_tag>
{
using constants_sa_t = math::detail::constants_on_spheroid
<
typename coordinate_type<PointSegmentA>::type,
coordinate_type_t<PointSegmentA>,
typename cs_angular_units<PointSegmentA>::type
>;
using constants_p_t = math::detail::constants_on_spheroid
<
typename coordinate_type<Point2>::type,
coordinate_type_t<Point2>,
typename cs_angular_units<Point2>::type
>;

2
include/boost/geometry/algorithms/detail/disjoint/areal_areal.hpp
View File

@ -48,7 +48,7 @@ inline bool point_on_border_covered_by(Geometry1 const& geometry1,
Geometry2 const& geometry2,
Strategy const& strategy)
{
using point_type = typename geometry::point_type<Geometry1>::type;
using point_type = geometry::point_type_t<Geometry1>;
typename helper_geometry<point_type>::type pt;
return geometry::point_on_border(pt, geometry1)
&& geometry::covered_by(pt, geometry2, strategy);

7
include/boost/geometry/algorithms/detail/disjoint/linear_linear.hpp
View File

@ -90,12 +90,9 @@ struct disjoint_linear
Geometry2 const& geometry2,
Strategy const& strategy)
{
using point_type = typename geometry::point_type<Geometry1>::type;
using point_type = geometry::point_type_t<Geometry1>;
using mutable_point_type = typename helper_geometry<point_type>::type;
using ratio_type = geometry::segment_ratio
<
typename coordinate_type<point_type>::type
> ;
using ratio_type = geometry::segment_ratio<coordinate_type_t<point_type>>;
using turn_info_type = overlay::turn_info
<
mutable_point_type,

26
include/boost/geometry/algorithms/detail/disjoint/segment_box.hpp
View File

@ -131,17 +131,17 @@ struct disjoint_segment_box_sphere_or_spheroid
// Case 2: disjoint if bounding boxes are disjoint
typedef typename coordinate_type<segment_point_type>::type CT;
using coor_t = coordinate_type_t<segment_point_type>;
segment_point_type p0_normalized;
NormalizeStrategy::apply(p0, p0_normalized);
segment_point_type p1_normalized;
NormalizeStrategy::apply(p1, p1_normalized);
CT lon1 = geometry::get_as_radian<0>(p0_normalized);
CT lat1 = geometry::get_as_radian<1>(p0_normalized);
CT lon2 = geometry::get_as_radian<0>(p1_normalized);
CT lat2 = geometry::get_as_radian<1>(p1_normalized);
coor_t lon1 = geometry::get_as_radian<0>(p0_normalized);
coor_t lat1 = geometry::get_as_radian<1>(p0_normalized);
coor_t lon2 = geometry::get_as_radian<0>(p1_normalized);
coor_t lat2 = geometry::get_as_radian<1>(p1_normalized);
if (lon1 > lon2)
{
@ -166,12 +166,12 @@ struct disjoint_segment_box_sphere_or_spheroid
// Case 3: test intersection by comparing angles
CT alp1, a_b0, a_b1, a_b2, a_b3;
coor_t alp1, a_b0, a_b1, a_b2, a_b3;
CT b_lon_min = geometry::get_as_radian<geometry::min_corner, 0>(box);
CT b_lat_min = geometry::get_as_radian<geometry::min_corner, 1>(box);
CT b_lon_max = geometry::get_as_radian<geometry::max_corner, 0>(box);
CT b_lat_max = geometry::get_as_radian<geometry::max_corner, 1>(box);
coor_t b_lon_min = geometry::get_as_radian<geometry::min_corner, 0>(box);
coor_t b_lat_min = geometry::get_as_radian<geometry::min_corner, 1>(box);
coor_t b_lon_max = geometry::get_as_radian<geometry::max_corner, 0>(box);
coor_t b_lat_max = geometry::get_as_radian<geometry::max_corner, 1>(box);
azimuth_strategy.apply(lon1, lat1, lon2, lat2, alp1);
azimuth_strategy.apply(lon1, lat1, b_lon_min, b_lat_min, a_b0);
@ -212,12 +212,12 @@ struct disjoint_segment_box_sphere_or_spheroid
// points of the box are above (below) the segment in northern (southern)
// hemisphere. Then we have to compute the vertex of the segment
CT vertex_lat;
coor_t vertex_lat;
if ((lat1 < b_lat_min && vertex_north)
|| (lat1 > b_lat_max && !vertex_north))
{
CT b_lat_below; //latitude of box closest to equator
coor_t b_lat_below; //latitude of box closest to equator
if (vertex_north)
{
@ -230,7 +230,7 @@ struct disjoint_segment_box_sphere_or_spheroid
//optimization TODO: computing the spherical longitude should suffice for
// the majority of cases
CT vertex_lon = geometry::formula::vertex_longitude<CT, CS_Tag>
coor_t vertex_lon = geometry::formula::vertex_longitude<coor_t, CS_Tag>
::apply(lon1, lat1,
lon2, lat2,
vertex_lat,

4
include/boost/geometry/algorithms/detail/distance/geometry_collection.hpp
View File

@ -68,9 +68,9 @@ inline auto collection_to_collection(GeometryCollection1 const& collection1,
{
using result_t = typename geometry::distance_result<GeometryCollection1, GeometryCollection2, Strategies>::type;
using point1_t = typename geometry::point_type<GeometryCollection1>::type;
using point1_t = geometry::point_type_t<GeometryCollection1>;
using box1_t = model::box<point1_t>;
using point2_t = typename geometry::point_type<GeometryCollection2>::type;
using point2_t = geometry::point_type_t<GeometryCollection2>;
using box2_t = model::box<point2_t>;
using rtree_value_t = std::pair<box1_t, typename boost::range_iterator<GeometryCollection1 const>::type>;

2
include/boost/geometry/algorithms/detail/envelope/initialize.hpp
View File

@ -62,7 +62,7 @@ template
>
struct initialize
{
typedef typename coordinate_type<Box>::type coordinate_type;
using coordinate_type = coordinate_type_t<Box>;
static inline void apply(Box& box,
coordinate_type min_value

14
include/boost/geometry/algorithms/detail/envelope/range_of_boxes.hpp
View File

@ -229,9 +229,9 @@ struct envelope_range_of_boxes
{
// boxes in the range are assumed to be normalized already
typedef typename boost::range_value<RangeOfBoxes>::type box_type;
typedef typename coordinate_type<box_type>::type coordinate_type;
typedef typename detail::cs_angular_units<box_type>::type units_type;
using box_type = typename boost::range_value<RangeOfBoxes>::type;
using coordinate_type = coordinate_type_t<box_type>;
using units_type = typename detail::cs_angular_units<box_type>::type;
static const bool is_equatorial = ! std::is_same
<
@ -239,13 +239,13 @@ struct envelope_range_of_boxes
spherical_polar_tag
>::value;
typedef math::detail::constants_on_spheroid
using constants = math::detail::constants_on_spheroid
<
coordinate_type, units_type, is_equatorial
> constants;
>;
typedef longitude_interval<coordinate_type> interval_type;
typedef std::vector<interval_type> interval_range_type;
using interval_type = longitude_interval<coordinate_type>;
using interval_range_type = std::vector<interval_type>;
BOOST_GEOMETRY_ASSERT(! boost::empty(range_of_boxes));

2
include/boost/geometry/algorithms/detail/equals/collect_vectors.hpp
View File

@ -250,7 +250,7 @@ struct collected_vector_polar
private:
static base_point_type to_equatorial(Point const& p)
{
using coord_type = typename coordinate_type<Point>::type;
using coord_type = coordinate_type_t<Point>;
using constants = math::detail::constants_on_spheroid
<
coord_type,

2
include/boost/geometry/algorithms/detail/equals/implementation.hpp
View File

@ -215,7 +215,7 @@ struct equals_by_collection
>::template type
<
calculation_type,
typename geometry::point_type<Geometry1>::type
geometry::point_type_t<Geometry1>
>;
std::vector<collected_vector_type> c1, c2;

17
include/boost/geometry/algorithms/detail/expand_by_epsilon.hpp
View File

@ -41,7 +41,7 @@ struct corner_by_epsilon
{
static inline void apply(Point & point)
{
typedef typename coordinate_type<Point>::type coord_type;
using coord_type = coordinate_type_t<Point>;
coord_type const coord = get<I>(point);
coord_type const seps = math::scaled_epsilon(coord);
@ -51,9 +51,9 @@ struct corner_by_epsilon
}
static inline void apply(Point & point,
typename coordinate_type<Point>::type const& eps)
coordinate_type_t<Point> const& eps)
{
typedef typename coordinate_type<Point>::type coord_type;
using coord_type = coordinate_type_t<Point>;
coord_type const coord = get<I>(point);
coord_type const seps = math::scaled_epsilon(coord, eps);
@ -72,13 +72,13 @@ template
struct corner_by_epsilon<Point, PlusOrMinus, D, D>
{
static inline void apply(Point const&) {}
static inline void apply(Point const&, typename coordinate_type<Point>::type const&) {}
static inline void apply(Point const&, coordinate_type_t<Point> const&) {}
};
template
<
typename Box,
bool Enable = ! std::is_integral<typename coordinate_type<Box>::type>::value
bool Enable = ! std::is_integral<coordinate_type_t<Box>>::value
>
struct expand_by_epsilon
{
@ -94,7 +94,7 @@ struct expand_by_epsilon
}
static inline void apply(Box & box,
typename coordinate_type<Box>::type const& eps)
coordinate_type_t<Box> const& eps)
{
typedef detail::indexed_point_view<Box, min_corner> min_type;
min_type min_point(box);
@ -110,7 +110,7 @@ template <typename Box>
struct expand_by_epsilon<Box, false>
{
static inline void apply(Box &) {}
static inline void apply(Box &, typename coordinate_type<Box>::type const&) {}
static inline void apply(Box &, coordinate_type_t<Box> const&) {}
};
} // namespace expand
@ -122,8 +122,7 @@ inline void expand_by_epsilon(Box & box)
}
template <typename Box>
inline void expand_by_epsilon(Box & box,
typename coordinate_type<Box>::type const& eps)
inline void expand_by_epsilon(Box & box, coordinate_type_t<Box> const& eps)
{
expand::expand_by_epsilon<Box>::apply(box, eps);
}

4
include/boost/geometry/algorithms/detail/extreme_points.hpp
View File

@ -122,8 +122,8 @@ template<typename Ring, std::size_t Dimension>
struct extreme_points_on_ring
{
typedef typename geometry::coordinate_type<Ring>::type coordinate_type;
typedef typename geometry::point_type<Ring>::type point_type;
using coordinate_type = geometry::coordinate_type_t<Ring>;
using point_type = geometry::point_type_t<Ring>;
template <typename CirclingIterator, typename Points>
static inline bool extend(CirclingIterator& it,

2
include/boost/geometry/algorithms/detail/gc_make_rtree.hpp
View File

@ -37,7 +37,7 @@ using gc_make_rtree_box_t = geometry::model::box
<
geometry::model::point
<
typename geometry::coordinate_type<GC>::type,
geometry::coordinate_type_t<GC>,
geometry::dimension<GC>::value,
typename geometry::coordinate_system<GC>::type
>

8
include/boost/geometry/algorithms/detail/get_max_size.hpp
View File

@ -33,9 +33,9 @@ namespace detail
template <typename Box, std::size_t Dimension>
struct get_max_size_box
{
static inline typename coordinate_type<Box>::type apply(Box const& box)
static inline coordinate_type_t<Box> apply(Box const& box)
{
typename coordinate_type<Box>::type s
coordinate_type_t<Box> s
= geometry::math::abs(geometry::get<1, Dimension>(box) - geometry::get<0, Dimension>(box));
return (std::max)(s, get_max_size_box<Box, Dimension - 1>::apply(box));
@ -45,7 +45,7 @@ struct get_max_size_box
template <typename Box>
struct get_max_size_box<Box, 0>
{
static inline typename coordinate_type<Box>::type apply(Box const& box)
static inline coordinate_type_t<Box> apply(Box const& box)
{
return geometry::math::abs(geometry::get<1, 0>(box) - geometry::get<0, 0>(box));
}
@ -54,7 +54,7 @@ struct get_max_size_box<Box, 0>
// This might be implemented later on for other geometries too.
// Not dispatched yet.
template <typename Box>
inline typename coordinate_type<Box>::type get_max_size(Box const& box)
inline coordinate_type_t<Box> get_max_size(Box const& box)
{
return get_max_size_box<Box, dimension<Box>::value - 1>::apply(box);
}

12
include/boost/geometry/algorithms/detail/intersects/implementation.hpp
View File

@ -46,20 +46,20 @@ struct self_intersects
{
concepts::check<Geometry const>();
typedef typename geometry::point_type<Geometry>::type point_type;
typedef typename strategies::relate::services::default_strategy
using point_type = geometry::point_type_t<Geometry>;
using strategy_type = typename strategies::relate::services::default_strategy
<
Geometry, Geometry
>::type strategy_type;
>::type;
typedef detail::overlay::turn_info<point_type> turn_info;
using turn_info = detail::overlay::turn_info<point_type>;
std::deque<turn_info> turns;
typedef detail::overlay::get_turn_info
using turn_policy = detail::overlay::get_turn_info
<
detail::overlay::assign_null_policy
> turn_policy;
>;
strategy_type strategy;

2
include/boost/geometry/algorithms/detail/is_valid/has_invalid_coordinate.hpp
View File

@ -109,7 +109,7 @@ template
typename Tag = typename tag<Geometry>::type,
bool HasFloatingPointCoordinates = std::is_floating_point
<
typename coordinate_type<Geometry>::type
coordinate_type_t<Geometry>
>::value
>
struct has_invalid_coordinate

4
include/boost/geometry/algorithms/detail/overlaps/implementation.hpp
View File

@ -59,8 +59,8 @@ struct box_box_loop
{
assert_dimension_equal<Box1, Box2>();
typedef typename coordinate_type<Box1>::type coordinate_type1;
typedef typename coordinate_type<Box2>::type coordinate_type2;
using coordinate_type1 = coordinate_type_t<Box1>;
using coordinate_type2 = coordinate_type_t<Box2>;
coordinate_type1 const& min1 = get<min_corner, Dimension>(b1);
coordinate_type1 const& max1 = get<max_corner, Dimension>(b1);

4
include/boost/geometry/algorithms/detail/overlay/clip_linestring.hpp
View File

@ -99,8 +99,8 @@ public:
inline bool clip_segment(Box const& b, segment_type& s, bool& sp1_clipped, bool& sp2_clipped) const
{
typedef typename select_coordinate_type<Box, Point>::type coordinate_type;
typedef typename select_most_precise<coordinate_type, double>::type calc_type;
using coordinate_type = typename select_coordinate_type<Box, Point>::type;
using calc_type = typename select_most_precise<coordinate_type, double>::type;
calc_type t1 = 0;
calc_type t2 = 1;

2
include/boost/geometry/algorithms/detail/overlay/colocate_clusters.hpp
View File

@ -25,7 +25,7 @@ namespace detail { namespace overlay
template
<
typename Point,
typename CoordinateType = typename geometry::coordinate_type<Point>::type,
typename CoordinateType = geometry::coordinate_type_t<Point>,
typename CsTag = typename geometry::cs_tag<Point>::type,
bool IsIntegral = std::is_integral<CoordinateType>::value
>

5
include/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp
View File

@ -318,12 +318,11 @@ inline void create_map(Turns const& turns, MappedVector& mapped_vector,
}
template <typename Point1, typename Point2>
inline typename geometry::coordinate_type<Point1>::type
distance_measure(Point1 const& a, Point2 const& b)
inline geometry::coordinate_type_t<Point1> distance_measure(Point1 const& a, Point2 const& b)
{
// TODO: use comparable distance for point-point instead - but that
// causes currently cycling include problems
using ctype = typename geometry::coordinate_type<Point1>::type;
using ctype = geometry::coordinate_type_t<Point1>;
ctype const dx = get<0>(a) - get<0>(b);
ctype const dy = get<1>(a) - get<1>(b);
return dx * dx + dy * dy;

4
include/boost/geometry/algorithms/detail/overlay/get_clusters.hpp
View File

@ -40,7 +40,7 @@ public:
template <typename P>
static inline bool equals(P const& p1, P const& p2)
{
using coor_t = typename coordinate_type<P>::type;
using coor_t = coordinate_type_t<P>;
static auto const tolerance
= common_approximately_equals_epsilon_multiplier<coor_t>::value();
return approximately_equals(p1, p2, tolerance);
@ -101,7 +101,7 @@ inline void get_clusters(Turns& turns, Clusters& clusters)
sweep_equal_policy
<
std::is_integral<typename coordinate_type<point_type>::type>::value
std::is_integral<coordinate_type_t<point_type>>::value
> equal_policy;
std::vector<turn_with_point<point_type>> points;

2
include/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp
View File

@ -216,7 +216,7 @@ struct turn_info_verification_functions
BOOST_GEOMETRY_ASSERT(index_p > 0 && index_p <= 2);
BOOST_GEOMETRY_ASSERT(index_q > 0 && index_q <= 2);
using distance_measure_result_type = typename geometry::coordinate_type<decltype(ti.point)>::type;
using distance_measure_result_type = geometry::coordinate_type_t<decltype(ti.point)>;
bool const p_in_range = index_p < range_p.size();
bool const q_in_range = index_q < range_q.size();

10
include/boost/geometry/algorithms/detail/overlay/get_turns.hpp
View File

@ -390,8 +390,8 @@ public :
private :
typedef typename geometry::point_type<Geometry1>::type point1_type;
typedef typename geometry::point_type<Geometry2>::type point2_type;
using point1_type = geometry::point_type_t<Geometry1>;
using point2_type = geometry::point_type_t<Geometry2>;
// It is NOT possible to have section-iterators here
// because of the logistics of "index" (the section-iterator automatically
@ -540,9 +540,9 @@ template
>
struct get_turns_cs
{
typedef typename geometry::point_type<Range>::type range_point_type;
typedef typename geometry::point_type<Box>::type box_point_type;
typedef std::array<box_point_type, 4> box_array;
using range_point_type = geometry::point_type_t<Range>;
using box_point_type = geometry::point_type_t<Box>;
using box_array = std::array<box_point_type, 4>;
using view_type = detail::closed_clockwise_view
<

12
include/boost/geometry/algorithms/detail/overlay/intersection_insert.hpp
View File

@ -288,7 +288,7 @@ struct intersection_of_linestring_with_areal
typedef geometry::segment_ratio
<
typename coordinate_type<point_type>::type
coordinate_type_t<point_type>
> ratio_type;
typedef detail::overlay::turn_info
@ -419,9 +419,9 @@ struct intersection_linear_areal_point
OutputIterator out,
Strategy const& strategy)
{
typedef geometry::segment_ratio<typename geometry::coordinate_type<PointOut>::type> ratio_type;
using ratio_type = geometry::segment_ratio<geometry::coordinate_type_t<PointOut>>;
typedef detail::overlay::turn_info
using turn_info = detail::overlay::turn_info
<
PointOut,
ratio_type,
@ -430,12 +430,12 @@ struct intersection_linear_areal_point
PointOut,
ratio_type
>
> turn_info;
>;
typedef detail::overlay::get_turn_info_linear_areal
using turn_policy = detail::overlay::get_turn_info_linear_areal
<
detail::overlay::assign_null_policy
> turn_policy;
>;
std::vector<turn_info> turns;

2
include/boost/geometry/algorithms/detail/overlay/less_by_segment_ratio.hpp
View File

@ -88,7 +88,7 @@ private :
Geometry2 const& m_geometry2;
Strategy const& m_strategy;
typedef typename geometry::point_type<Geometry1>::type point_type;
using point_type = geometry::point_type_t<Geometry1>;
inline bool default_order(Indexed const& left, Indexed const& right) const
{

18
include/boost/geometry/algorithms/detail/overlay/overlay.hpp
View File

@ -182,7 +182,7 @@ inline OutputIterator return_if_one_input_is_empty(Geometry1 const& geometry1,
typedef ring_properties
<
typename geometry::point_type<ring_type>::type,
geometry::point_type_t<ring_type>,
typename geometry::area_result<ring_type, Strategy>::type
> properties;
@ -248,23 +248,23 @@ struct overlay
>(geometry1, geometry2, out, strategy);
}
typedef typename geometry::point_type<GeometryOut>::type point_type;
typedef detail::overlay::traversal_turn_info
using point_type = geometry::point_type_t<GeometryOut>;
using turn_info = detail::overlay::traversal_turn_info
<
point_type,
typename segment_ratio_type<point_type>::type
> turn_info;
typedef std::deque<turn_info> turn_container_type;
>;
using turn_container_type = std::deque<turn_info>;
typedef typename geometry::ring_type<GeometryOut>::type ring_type;
typedef std::deque<ring_type> ring_container_type;
using ring_type = typename geometry::ring_type<GeometryOut>::type;
using ring_container_type = std::deque<ring_type>;
// Define the clusters, mapping cluster_id -> turns
typedef std::map
using cluster_type = std::map
<
signed_size_type,
cluster_info
> cluster_type;
>;
turn_container_type turns;

10
include/boost/geometry/algorithms/detail/overlay/pointlike_areal.hpp
View File

@ -183,14 +183,14 @@ private:
{
item_visitor_type<OutputIterator, Strategy> item_visitor(multipolygon, oit, strategy);
typedef geometry::model::point
using point_type = geometry::model::point
<
typename geometry::coordinate_type<MultiPoint>::type,
geometry::coordinate_type_t<MultiPoint>,
geometry::dimension<MultiPoint>::value,
typename geometry::coordinate_system<MultiPoint>::type
> point_type;
typedef geometry::model::box<point_type> box_type;
typedef std::pair<box_type, std::size_t> box_pair;
>;
using box_type = geometry::model::box<point_type>;
using box_pair = std::pair<box_type, std::size_t>;
std::vector<box_pair> box_pairs;
box_pairs.reserve(boost::size(multipolygon));

4
include/boost/geometry/algorithms/detail/overlay/range_in_geometry.hpp
View File

@ -55,8 +55,8 @@ struct points_range
template <typename Box>
struct points_range<Box, box_tag>
{
typedef typename geometry::point_type<Box>::type point_type;
typedef const point_type * iterator_type;
using point_type = geometry::point_type_t<Box>;
using iterator_type = const point_type *;
explicit points_range(Box const& box)
{

2
include/boost/geometry/algorithms/detail/overlay/segment_as_subrange.hpp
View File

@ -34,7 +34,7 @@ struct segment_as_subrange
geometry::set<1>(m_p2, geometry::get<1, 1>(m_segment));
}
typedef typename geometry::point_type<Segment>::type point_type;
using point_type = geometry::point_type_t<Segment>;
point_type const& at(std::size_t index) const
{

6
include/boost/geometry/algorithms/detail/overlay/self_turn_points.hpp
View File

@ -131,13 +131,13 @@ struct get_turns
InterruptPolicy& interrupt_policy,
int source_index, bool skip_adjacent)
{
typedef model::box<typename geometry::point_type<Geometry>::type> box_type;
using box_type = model::box<geometry::point_type_t<Geometry>>;
// sectionalize in two dimensions to detect
// all potential spikes correctly
typedef geometry::sections<box_type, 2> sections_type;
using sections_type = geometry::sections<box_type, 2>;
typedef std::integer_sequence<std::size_t, 0, 1> dimensions;
using dimensions = std::integer_sequence<std::size_t, 0, 1>;
sections_type sec;
geometry::sectionalize<Reverse, dimensions>(geometry,

2
include/boost/geometry/algorithms/detail/overlay/sort_by_side.hpp
View File

@ -322,7 +322,7 @@ public :
// Use the coordinate type, but if it is too small (e.g. std::int16), use a double
using ct_type = typename geometry::select_most_precise
<
typename geometry::coordinate_type<Point>::type,
geometry::coordinate_type_t<Point>,
double
>::type;

12
include/boost/geometry/algorithms/detail/overlay/traversal.hpp
View File

@ -92,16 +92,16 @@ private :
static const operation_type target_operation = operation_from_overlay<OverlayType>::value;
typedef typename sort_by_side::side_compare<target_operation>::type side_compare_type;
typedef typename boost::range_value<Turns>::type turn_type;
typedef typename turn_type::turn_operation_type turn_operation_type;
using side_compare_type = typename sort_by_side::side_compare<target_operation>::type;
using turn_type = typename boost::range_value<Turns>::type;
using turn_operation_type = typename turn_type::turn_operation_type;
typedef typename geometry::point_type<Geometry1>::type point_type;
typedef sort_by_side::side_sorter
using point_type = geometry::point_type_t<Geometry1>;
using sbs_type = sort_by_side::side_sorter
<
Reverse1, Reverse2, OverlayType,
point_type, Strategy, side_compare_type
> sbs_type;
>;
public :
inline traversal(Geometry1 const& geometry1, Geometry2 const& geometry2,

4
include/boost/geometry/algorithms/detail/overlay/turn_info.hpp
View File

@ -57,7 +57,7 @@ struct turn_operation
segment_identifier seg_id;
SegmentRatio fraction;
typedef typename coordinate_type<Point>::type comparable_distance_type;
using comparable_distance_type = coordinate_type_t<Point>;
comparable_distance_type remaining_distance;
inline turn_operation()
@ -79,7 +79,7 @@ struct turn_operation
template
<
typename Point,
typename SegmentRatio = geometry::segment_ratio<typename coordinate_type<Point>::type>,
typename SegmentRatio = geometry::segment_ratio<coordinate_type_t<Point>>,
typename Operation = turn_operation<Point, SegmentRatio>,
typename Container = std::array<Operation, 2>
>

2
include/boost/geometry/algorithms/detail/partition.hpp
View File

@ -77,7 +77,7 @@ struct include_all_policy
template <std::size_t Dimension, typename Box>
inline void divide_box(Box const& box, Box& lower_box, Box& upper_box)
{
using coor_t = typename coordinate_type<Box>::type;
using coor_t = coordinate_type_t<Box>;
// Divide input box into two halves
// either left/right (Dimension 0)

2
include/boost/geometry/algorithms/detail/relate/areal_areal.hpp
View File

@ -89,7 +89,7 @@ public:
return false;
}
using point_type = typename geometry::point_type<Areal>::type;
using point_type = geometry::point_type_t<Areal>;
typename helper_geometry<point_type>::type pt;
bool const ok = geometry::point_on_border(pt, areal);

4
include/boost/geometry/algorithms/detail/relate/implementation_gc.hpp
View File

@ -122,7 +122,7 @@ struct gc_gc
typename traits::geometry_types<Geometry1>::type,
util::is_multi_polygon
>::type;
using pt1_t = typename geometry::point_type<Geometry1>::type;
using pt1_t = geometry::point_type_t<Geometry1>;
using mpt1_t = std::conditional_t
<
std::is_void<mpt1_found_t>::value,
@ -158,7 +158,7 @@ struct gc_gc
typename traits::geometry_types<Geometry2>::type,
util::is_multi_polygon
>::type;
using pt2_t = typename geometry::point_type<Geometry2>::type;
using pt2_t = geometry::point_type_t<Geometry2>;
using mpt2_t = std::conditional_t
<
std::is_void<mpt2_found_t>::value,

2
include/boost/geometry/algorithms/detail/relate/linear_areal.hpp
View File

@ -172,7 +172,7 @@ public:
// TODO:
// handle empty/invalid geometries in a different way than below?
using point_type = typename geometry::point_type<Areal>::type;
using point_type = geometry::point_type_t<Areal>;
typename helper_geometry<point_type>::type pt;
bool const ok = geometry::point_on_border(pt, areal);

4
include/boost/geometry/algorithms/detail/relate/point_point.hpp
View File

@ -224,8 +224,8 @@ struct multipoint_multipoint
Result & result)
{
// sort points from the 1 MPt
typedef typename geometry::point_type<SortedMultiPoint>::type point_type;
typedef geometry::less<void, -1, Strategy> less_type;
using point_type = geometry::point_type_t<SortedMultiPoint>;
using less_type = geometry::less<void, -1, Strategy>;
std::vector<point_type> points(boost::begin(sorted_mpt), boost::end(sorted_mpt));

2
include/boost/geometry/algorithms/detail/relate/topology_check.hpp
View File

@ -306,7 +306,7 @@ private:
mutable bool m_has_interior;
mutable bool m_has_boundary;
typedef typename geometry::point_type<MultiLinestring>::type point_type;
using point_type = geometry::point_type_t<MultiLinestring>;
mutable std::vector<point_type> m_endpoints;
};

2
include/boost/geometry/algorithms/detail/relate/turns.hpp
View File

@ -54,7 +54,7 @@ struct get_turns
{
using turn_point_type = typename helper_geometry
<
typename geometry::point_type<Geometry1>::type
geometry::point_type_t<Geometry1>
>::type;
template

6
include/boost/geometry/algorithms/detail/sections/sectionalize.hpp
View File

@ -189,7 +189,7 @@ struct get_direction_loop<Point, DimensionVector, 0, Count, spherical_tag>
static inline void apply(Segment const& seg,
int directions[Count])
{
using coordinate_type = typename coordinate_type<Segment>::type;
using coordinate_type = coordinate_type_t<Segment>;
using units_t = typename coordinate_system<Point>::type::units;
coordinate_type const diff = math::longitude_distance_signed
@ -391,7 +391,7 @@ struct sectionalize_part
{
using section_type = typename boost::range_value<Sections>::type;
using box_type = typename section_type::box_type;
using point_type = typename geometry::point_type<box_type>::type;
using point_type = geometry::point_type_t<box_type>;
BOOST_STATIC_ASSERT
(
@ -713,7 +713,7 @@ inline void enlarge_sections(Sections& sections, Strategy const&)
// but that somehow is not accepted by the NVCC (CUDA 12.4) compiler.
using section_t = typename boost::range_value<Sections>::type;
using box_t = typename section_t::box_type;
using coor_t = typename geometry::coordinate_type<box_t>::type;
using coor_t = geometry::coordinate_type_t<box_t>;
static auto const eps = math::scaled_epsilon<coor_t>(1000);

20
include/boost/geometry/algorithms/detail/touches/implementation.hpp
View File

@ -65,8 +65,8 @@ struct box_box_loop
template <typename Box1, typename Box2>
static inline bool apply(Box1 const& b1, Box2 const& b2, bool & touch)
{
typedef typename coordinate_type<Box1>::type coordinate_type1;
typedef typename coordinate_type<Box2>::type coordinate_type2;
using coordinate_type1 = coordinate_type_t<Box1>;
using coordinate_type2 = coordinate_type_t<Box2>;
coordinate_type1 const& min1 = get<min_corner, Dimension>(b1);
coordinate_type1 const& max1 = get<max_corner, Dimension>(b1);
@ -217,7 +217,7 @@ inline bool point_on_border_within(Geometry1 const& geometry1,
Geometry2 const& geometry2,
Strategy const& strategy)
{
using point_type = typename geometry::point_type<Geometry1>::type;
using point_type = geometry::point_type_t<Geometry1>;
typename helper_geometry<point_type>::type pt;
return geometry::point_on_border(pt, geometry1)
&& geometry::within(pt, geometry2, strategy);
@ -242,7 +242,7 @@ struct areal_areal
Geometry2 const& geometry2,
Strategy const& strategy)
{
using point_type = typename geometry::point_type<Geometry1>::type;
using point_type = geometry::point_type_t<Geometry1>;
using mutable_point_type = typename helper_geometry<point_type>::type;
using turn_info = detail::overlay::turn_info<mutable_point_type>;
@ -505,17 +505,17 @@ struct self_touches
{
concepts::check<Geometry const>();
typedef typename strategies::relate::services::default_strategy
using strategy_type = typename strategies::relate::services::default_strategy
<
Geometry, Geometry
>::type strategy_type;
typedef typename geometry::point_type<Geometry>::type point_type;
typedef detail::overlay::turn_info<point_type> turn_info;
>::type;
using point_type = geometry::point_type_t<Geometry>;
using turn_info = detail::overlay::turn_info<point_type>;
typedef detail::overlay::get_turn_info
using policy_type = detail::overlay::get_turn_info
<
detail::overlay::assign_null_policy
> policy_type;
>;
std::deque<turn_info> turns;
detail::touches::areal_interrupt_policy policy;

2
include/boost/geometry/algorithms/detail/within/point_in_geometry.hpp
View File

@ -94,7 +94,7 @@ 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)
{
typedef typename geometry::point_type<Segment>::type point_type;
using point_type = geometry::point_type_t<Segment>;
point_type p0, p1;
// TODO: don't copy points
detail::assign_point_from_index<0>(segment, p0);

12
include/boost/geometry/algorithms/merge_elements.hpp
View File

@ -66,7 +66,7 @@ template
>
inline void distribute_element(Geometry const& geometry, It it, PointLike& , Linear&, Areal& areal)
{
typename geometry::point_type<Geometry>::type point;
geometry::point_type_t<Geometry> point;
if (geometry::point_on_border(point, geometry))
{
using point_t = typename Areal::value_type::first_type;
@ -81,7 +81,7 @@ template
>
inline void distribute_element(Geometry const& geometry, It it, PointLike& , Linear& linear, Areal& )
{
typename geometry::point_type<Geometry>::type point;
geometry::point_type_t<Geometry> point;
if (geometry::point_on_border(point, geometry))
{
using point_t = typename Linear::value_type::first_type;
@ -96,7 +96,7 @@ template
>
inline void distribute_element(Geometry const& geometry, It it, PointLike& pointlike, Linear& , Areal& )
{
typename geometry::point_type<Geometry>::type point;
geometry::point_type_t<Geometry> point;
if (geometry::point_on_border(point, geometry))
{
using point_t = typename Linear::value_type::first_type;
@ -268,11 +268,11 @@ struct merge_gc
GeometryCollection & out,
Strategy const& strategy)
{
using original_point_t = typename geometry::point_type<GeometryCollection>::type;
using original_point_t = geometry::point_type_t<GeometryCollection>;
using iterator_t = typename boost::range_iterator<GeometryCollection const>::type;
using coordinate_t = typename geometry::coordinate_type<original_point_t>::type;
using coor_t = geometry::coordinate_type_t<original_point_t>;
using cs_t = typename geometry::coordinate_system<original_point_t>::type;
using point_t = model::point<coordinate_t, 2, cs_t>;
using point_t = model::point<coor_t, 2, cs_t>;
using multi_point_t = typename util::sequence_find_if
<

14
include/boost/geometry/algorithms/point_on_surface.hpp
View File

@ -146,7 +146,7 @@ struct min_of_intruder
template <typename Point, typename P>
inline void calculate_average(Point& point, std::vector<P> const& points)
{
typedef typename geometry::coordinate_type<Point>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<Point>;
coordinate_type x = 0;
coordinate_type y = 0;
@ -237,8 +237,8 @@ template <int Dimension, typename Geometry, typename Point, typename SideStrateg
inline bool calculate_point_on_surface(Geometry const& geometry, Point& point,
SideStrategy const& strategy)
{
typedef typename geometry::point_type<Geometry>::type point_type;
typedef typename geometry::coordinate_type<Geometry>::type coordinate_type;
using point_type = geometry::point_type_t<Geometry>;
using coordinate_type = geometry::coordinate_type_t<Geometry>;
std::vector<point_type> extremes;
typedef std::vector<std::vector<point_type> > intruders_type;
@ -327,10 +327,10 @@ inline void point_on_surface(Geometry const& geometry, Point & point)
\return The Point guaranteed to lie on the surface of the Geometry
*/
template<typename Geometry, typename SideStrategy>
inline typename geometry::point_type<Geometry>::type
inline geometry::point_type_t<Geometry>
return_point_on_surface(Geometry const& geometry, SideStrategy const& strategy)
{
typename geometry::point_type<Geometry>::type result;
geometry::point_type_t<Geometry> result;
geometry::point_on_surface(geometry, result, strategy);
return result;
}
@ -342,10 +342,10 @@ return_point_on_surface(Geometry const& geometry, SideStrategy const& strategy)
\return The Point guaranteed to lie on the surface of the Geometry
*/
template<typename Geometry>
inline typename geometry::point_type<Geometry>::type
inline geometry::point_type_t<Geometry>
return_point_on_surface(Geometry const& geometry)
{
typename geometry::point_type<Geometry>::type result;
geometry::point_type_t<Geometry> result;
geometry::point_on_surface(geometry, result);
return result;
}

4
include/boost/geometry/algorithms/simplify.hpp
View File

@ -393,7 +393,7 @@ private :
auto const cdistance_strategy = strategies::distance::detail::make_comparable(strategies)
.distance(detail::dummy_point(), detail::dummy_point());
using point_type = typename geometry::point_type<Ring>::type;
using point_type = geometry::point_type_t<Ring>;
using cdistance_type = decltype(cdistance_strategy.apply(
std::declval<point_type>(), std::declval<point_type>()));
@ -444,7 +444,7 @@ public :
// Rotate it into a copied vector
// (vector, because source type might not support rotation)
// (duplicate end point will be simplified away)
typedef typename geometry::point_type<RingIn>::type point_type;
using point_type = geometry::point_type_t<RingIn>;
std::vector<point_type> rotated;
rotated.reserve(size + 1); // 1 because open rings are closed

8
include/boost/geometry/algorithms/transform.hpp
View File

@ -84,10 +84,10 @@ struct transform_box
{
// Create a valid box and therefore swap if necessary
using coordinate_type = coordinate_type_t<point_type2>;
coordinate_type x1 = geometry::get<0>(p1)
, y1 = geometry::get<1>(p1)
, x2 = geometry::get<0>(p2)
, y2 = geometry::get<1>(p2);
coordinate_type x1 = geometry::get<0>(p1);
coordinate_type y1 = geometry::get<1>(p1);
coordinate_type x2 = geometry::get<0>(p2);
coordinate_type y2 = geometry::get<1>(p2);
if (x1 > x2) { std::swap(x1, x2); }
if (y1 > y2) { std::swap(y1, y2); }

6
include/boost/geometry/algorithms/unique.hpp
View File

@ -167,10 +167,10 @@ inline void unique(Geometry& geometry)
concepts::check<Geometry>();
// Default strategy is the default point-comparison policy
typedef geometry::equal_to
using policy = geometry::equal_to
<
typename geometry::point_type<Geometry>::type
> policy;
geometry::point_type_t<Geometry>
>;
dispatch::unique<Geometry>::apply(geometry, policy());

10
include/boost/geometry/arithmetic/arithmetic.hpp
View File

@ -41,7 +41,7 @@ namespace boost { namespace geometry
\param value value to add
*/
template <typename Point>
inline void add_value(Point& p, typename coordinate_type<Point>::type const& value)
inline void add_value(Point& p, coordinate_type_t<Point> const& value)
{
BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
@ -83,7 +83,7 @@ inline void add_point(Point1& p1, Point2 const& p2)
\param value value to subtract
*/
template <typename Point>
inline void subtract_value(Point& p, typename coordinate_type<Point>::type const& value)
inline void subtract_value(Point& p, coordinate_type_t<Point> const& value)
{
BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
@ -125,7 +125,7 @@ inline void subtract_point(Point1& p1, Point2 const& p2)
\param value value to multiply by
*/
template <typename Point>
inline void multiply_value(Point& p, typename coordinate_type<Point>::type const& value)
inline void multiply_value(Point& p, coordinate_type_t<Point> const& value)
{
BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
@ -168,7 +168,7 @@ inline void multiply_point(Point1& p1, Point2 const& p2)
\param value value to divide by
*/
template <typename Point>
inline void divide_value(Point& p, typename coordinate_type<Point>::type const& value)
inline void divide_value(Point& p, coordinate_type_t<Point> const& value)
{
BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
@ -210,7 +210,7 @@ inline void divide_point(Point1& p1, Point2 const& p2)
\param value value to assign
*/
template <typename Point>
inline void assign_value(Point& p, typename coordinate_type<Point>::type const& value)
inline void assign_value(Point& p, coordinate_type_t<Point> const& value)
{
BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );

4
include/boost/geometry/arithmetic/determinant.hpp
View File

@ -65,8 +65,8 @@ inline ReturnType determinant(U const& u, V const& v)
return calculate_determinant
<
ReturnType,
typename geometry::coordinate_type<U>::type,
typename geometry::coordinate_type<V>::type
geometry::coordinate_type_t<U>,
geometry::coordinate_type_t<V>
>::apply(get<0>(u), get<1>(u), get<0>(v), get<1>(v));
}

2
include/boost/geometry/arithmetic/infinite_line_functions.hpp
View File

@ -89,7 +89,7 @@ inline
typename select_most_precise
<
Type,
typename geometry::coordinate_type<Point>::type
geometry::coordinate_type_t<Point>
>::type
side_value(model::infinite_line<Type> const& line, Point const& p)
{

10
include/boost/geometry/arithmetic/normalize.hpp
View File

@ -26,22 +26,22 @@ namespace detail
{
template <typename Point>
inline typename coordinate_type<Point>::type vec_length_sqr(Point const& pt)
inline coordinate_type_t<Point> vec_length_sqr(Point const& pt)
{
return dot_product(pt, pt);
}
template <typename Point>
inline typename coordinate_type<Point>::type vec_length(Point const& pt)
inline coordinate_type_t<Point> vec_length(Point const& pt)
{
// NOTE: hypot() could be used instead of sqrt()
return math::sqrt(dot_product(pt, pt));
}
template <typename Point>
inline bool vec_normalize(Point & pt, typename coordinate_type<Point>::type & len)
inline bool vec_normalize(Point & pt, coordinate_type_t<Point>& len)
{
typedef typename coordinate_type<Point>::type coord_t;
using coord_t = coordinate_type_t<Point>;
coord_t const c0 = 0;
len = vec_length(pt);
@ -58,7 +58,7 @@ inline bool vec_normalize(Point & pt, typename coordinate_type<Point>::type & le
template <typename Point>
inline bool vec_normalize(Point & pt)
{
typedef typename coordinate_type<Point>::type coord_t;
using coord_t = coordinate_type_t<Point>;
coord_t len;
return vec_normalize(pt, len);
}

6
include/boost/geometry/core/coordinate_promotion.hpp
View File

@ -49,10 +49,10 @@ struct promote_floating_point
template <typename Geometry>
struct fp_coordinate_type
{
typedef typename promote_floating_point
using type = typename promote_floating_point
<
typename coordinate_type<Geometry>::type
>::type type;
coordinate_type_t<Geometry>
>::type;
};
namespace detail

24
include/boost/geometry/formulas/geographic.hpp
View File

@ -35,7 +35,7 @@ namespace formula {
template <typename Point3d, typename PointGeo, typename Spheroid>
inline Point3d geo_to_cart3d(PointGeo const& point_geo, Spheroid const& spheroid)
{
typedef typename coordinate_type<Point3d>::type calc_t;
using calc_t = coordinate_type_t<Point3d>;
calc_t const c1 = 1;
calc_t const e_sqr = eccentricity_sqr<calc_t>(spheroid);
@ -61,7 +61,7 @@ inline Point3d geo_to_cart3d(PointGeo const& point_geo, Spheroid const& spheroid
template <typename PointGeo, typename Spheroid, typename Point3d>
inline void geo_to_cart3d(PointGeo const& point_geo, Point3d & result, Point3d & north, Point3d & east, Spheroid const& spheroid)
{
typedef typename coordinate_type<Point3d>::type calc_t;
using calc_t = coordinate_type_t<Point3d>;
calc_t const c1 = 1;
calc_t const e_sqr = eccentricity_sqr<calc_t>(spheroid);
@ -94,8 +94,8 @@ inline void geo_to_cart3d(PointGeo const& point_geo, Point3d & result, Point3d &
template <typename PointGeo, typename Point3d, typename Spheroid>
inline PointGeo cart3d_to_geo(Point3d const& point_3d, Spheroid const& spheroid)
{
typedef typename coordinate_type<PointGeo>::type coord_t;
typedef typename coordinate_type<Point3d>::type calc_t;
using coord_t = coordinate_type_t<PointGeo>;
using calc_t = coordinate_type_t<Point3d>;
calc_t const c1 = 1;
//calc_t const c2 = 2;
@ -141,7 +141,7 @@ inline PointGeo cart3d_to_geo(Point3d const& point_3d, Spheroid const& spheroid)
template <typename Point3d, typename Spheroid>
inline Point3d projected_to_xy(Point3d const& point_3d, Spheroid const& spheroid)
{
typedef typename coordinate_type<Point3d>::type coord_t;
using coord_t = coordinate_type_t<Point3d>;
// len_xy = sqrt(x^2 + y^2)
// r = len_xy - |z / tan(lat)|
@ -167,7 +167,7 @@ inline Point3d projected_to_xy(Point3d const& point_3d, Spheroid const& spheroid
template <typename Point3d, typename Spheroid>
inline Point3d projected_to_surface(Point3d const& direction, Spheroid const& spheroid)
{
typedef typename coordinate_type<Point3d>::type coord_t;
using coord_t = coordinate_type_t<Point3d>;
//coord_t const c0 = 0;
coord_t const c2 = 2;
@ -206,7 +206,7 @@ inline bool projected_to_surface(Point3d const& origin, Point3d const& direction
Point3d & result1, Point3d & result2,
Spheroid const& spheroid)
{
typedef typename coordinate_type<Point3d>::type coord_t;
using coord_t = coordinate_type_t<Point3d>;
coord_t const c0 = 0;
coord_t const c1 = 1;
@ -265,7 +265,7 @@ inline bool great_elliptic_intersection(Point3d const& a1, Point3d const& a2,
Point3d & result,
Spheroid const& spheroid)
{
typedef typename coordinate_type<Point3d>::type coord_t;
using coord_t = coordinate_type_t<Point3d>;
coord_t c0 = 0;
coord_t c1 = 1;
@ -308,7 +308,7 @@ inline bool great_elliptic_intersection(Point3d const& a1, Point3d const& a2,
template <typename Point3d1, typename Point3d2>
static inline int elliptic_side_value(Point3d1 const& origin, Point3d1 const& norm, Point3d2 const& pt)
{
typedef typename coordinate_type<Point3d1>::type calc_t;
using calc_t = coordinate_type_t<Point3d1>;
calc_t c0 = 0;
// vector oposite to pt - origin
@ -330,7 +330,7 @@ inline bool planes_spheroid_intersection(Point3d const& o1, Point3d const& n1,
Point3d & ip1, Point3d & ip2,
Spheroid const& spheroid)
{
typedef typename coordinate_type<Point3d>::type coord_t;
using coord_t = coordinate_type_t<Point3d>;
coord_t c0 = 0;
coord_t c1 = 1;
@ -381,7 +381,7 @@ inline void experimental_elliptic_plane(Point3d const& p1, Point3d const& p2,
Point3d & origin, Point3d & normal,
Spheroid const& spheroid)
{
typedef typename coordinate_type<Point3d>::type coord_t;
using coord_t = coordinate_type_t<Point3d>;
Point3d xy1 = projected_to_xy(p1, spheroid);
Point3d xy2 = projected_to_xy(p2, spheroid);
@ -416,7 +416,7 @@ inline bool experimental_elliptic_intersection(Point3d const& a1, Point3d const&
Point3d & result,
Spheroid const& spheroid)
{
typedef typename coordinate_type<Point3d>::type coord_t;
using coord_t = coordinate_type_t<Point3d>;
coord_t c0 = 0;
coord_t c1 = 1;

6
include/boost/geometry/formulas/spherical.hpp
View File

@ -56,7 +56,7 @@ static inline void sph_to_cart3d(T const& lon, T const& lat, T & x, T & y, T & z
template <typename Point3d, typename PointSph>
static inline Point3d sph_to_cart3d(PointSph const& point_sph)
{
typedef typename coordinate_type<Point3d>::type calc_t;
using calc_t = coordinate_type_t<Point3d>;
calc_t const lon = get_as_radian<0>(point_sph);
calc_t const lat = get_as_radian<1>(point_sph);
@ -81,8 +81,8 @@ static inline void cart3d_to_sph(T const& x, T const& y, T const& z, T & lon, T
template <typename PointSph, typename Point3d>
static inline PointSph cart3d_to_sph(Point3d const& point_3d)
{
typedef typename coordinate_type<PointSph>::type coord_t;
typedef typename coordinate_type<Point3d>::type calc_t;
using coord_t = coordinate_type_t<PointSph>;
using calc_t = coordinate_type_t<Point3d>;
calc_t const x = get<0>(point_3d);
calc_t const y = get<1>(point_3d);

2
include/boost/geometry/geometries/adapted/boost_fusion.hpp
View File

@ -140,7 +140,7 @@ struct access
>
>
{
typedef typename coordinate_type<Sequence>::type ctype;
using ctype = coordinate_type_t<Sequence>;
static inline ctype get(Sequence const& point)
{

4
include/boost/geometry/geometries/adapted/std_pair_as_segment.hpp
View File

@ -57,7 +57,7 @@ struct point_type<std::pair<Point, Point> >
template <typename Point, std::size_t Dimension>
struct indexed_access<std::pair<Point, Point>, 0, Dimension>
{
typedef typename geometry::coordinate_type<Point>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<Point>;
static inline coordinate_type get(std::pair<Point, Point> const& s)
{
@ -74,7 +74,7 @@ struct indexed_access<std::pair<Point, Point>, 0, Dimension>
template <typename Point, std::size_t Dimension>
struct indexed_access<std::pair<Point, Point>, 1, Dimension>
{
typedef typename geometry::coordinate_type<Point>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<Point>;
static inline coordinate_type get(std::pair<Point, Point> const& s)
{

4
include/boost/geometry/geometries/box.hpp
View File

@ -204,7 +204,7 @@ struct point_type<model::box<Point> >
template <typename Point, std::size_t Dimension>
struct indexed_access<model::box<Point>, min_corner, Dimension>
{
typedef typename geometry::coordinate_type<Point>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<Point>;
static constexpr coordinate_type get(model::box<Point> const& b)
{
@ -220,7 +220,7 @@ struct indexed_access<model::box<Point>, min_corner, Dimension>
template <typename Point, std::size_t Dimension>
struct indexed_access<model::box<Point>, max_corner, Dimension>
{
typedef typename geometry::coordinate_type<Point>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<Point>;
static constexpr coordinate_type get(model::box<Point> const& b)
{

6
include/boost/geometry/geometries/concepts/point_concept.hpp
View File

@ -40,8 +40,8 @@ class Point
{
#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
typedef typename coordinate_type<Geometry>::type ctype;
typedef typename coordinate_system<Geometry>::type csystem;
using ctype = coordinate_type_t<Geometry>;
using csystem = typename coordinate_system<Geometry>::type;
// The following enum is used to fully instantiate the coordinate
// system class; this is needed in order to check the units passed
@ -93,7 +93,7 @@ class ConstPoint
{
#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
typedef typename coordinate_type<Geometry>::type ctype;
typedef coordinate_type_t<Geometry> ctype;
typedef typename coordinate_system<Geometry>::type csystem;
// The following enum is used to fully instantiate the coordinate

2
include/boost/geometry/geometries/helper_geometry.hpp
View File

@ -129,7 +129,7 @@ struct helper_geometry<Ring, NewCoordinateType, NewUnits, ring_tag>
template
<
typename Geometry,
typename NewCoordinateType = typename coordinate_type<Geometry>::type,
typename NewCoordinateType = coordinate_type_t<Geometry>,
typename NewUnits = typename detail::cs_angular_units<Geometry>::type
>
struct helper_geometry

16
include/boost/geometry/geometries/pointing_segment.hpp
View File

@ -84,17 +84,14 @@ struct tag<model::pointing_segment<Point> >
template <typename Point>
struct point_type<model::pointing_segment<Point> >
{
typedef Point type;
using type = Point;
};
template <typename Point, std::size_t Dimension>
struct indexed_access<model::pointing_segment<Point>, 0, Dimension>
{
typedef model::pointing_segment<Point> segment_type;
typedef typename geometry::coordinate_type
<
segment_type
>::type coordinate_type;
using segment_type = model::pointing_segment<Point>;
using coordinate_type = geometry::coordinate_type_t<segment_type>;
static inline coordinate_type get(segment_type const& s)
{
@ -113,11 +110,8 @@ struct indexed_access<model::pointing_segment<Point>, 0, Dimension>
template <typename Point, std::size_t Dimension>
struct indexed_access<model::pointing_segment<Point>, 1, Dimension>
{
typedef model::pointing_segment<Point> segment_type;
typedef typename geometry::coordinate_type
<
segment_type
>::type coordinate_type;
using segment_type = model::pointing_segment<Point>;
using coordinate_type = geometry::coordinate_type_t<segment_type>;
static inline coordinate_type get(segment_type const& s)
{

16
include/boost/geometry/geometries/register/box.hpp
View File

@ -23,7 +23,7 @@
template <size_t D> \
struct indexed_access<Box, min_corner, D> \
{ \
typedef typename coordinate_type<Point>::type ct; \
using ct = coordinate_type_t<Point>; \
static inline ct get(Box const& b) \
{ return geometry::get<D>(b. MinCorner); } \
static inline void set(Box& b, ct const& value) \
@ -32,7 +32,7 @@ struct indexed_access<Box, min_corner, D> \
template <size_t D> \
struct indexed_access<Box, max_corner, D> \
{ \
typedef typename coordinate_type<Point>::type ct; \
using ct = coordinate_type_t<Point>; \
static inline ct get(Box const& b) \
{ return geometry::get<D>(b. MaxCorner); } \
static inline void set(Box& b, ct const& value) \
@ -44,7 +44,7 @@ struct indexed_access<Box, max_corner, D> \
template <typename P, size_t D> \
struct indexed_access<Box<P>, min_corner, D> \
{ \
typedef typename coordinate_type<P>::type ct; \
using ct = coordinate_type_t<P>; \
static inline ct get(Box<P> const& b) \
{ return geometry::get<D>(b. MinCorner); } \
static inline void set(Box<P>& b, ct const& value) \
@ -53,7 +53,7 @@ struct indexed_access<Box<P>, min_corner, D> \
template <typename P, size_t D> \
struct indexed_access<Box<P>, max_corner, D> \
{ \
typedef typename coordinate_type<P>::type ct; \
using ct = coordinate_type_t<P>; \
static inline ct get(Box<P> const& b) \
{ return geometry::get<D>(b. MaxCorner); } \
static inline void set(Box<P>& b, ct const& value) \
@ -64,25 +64,25 @@ struct indexed_access<Box<P>, max_corner, D> \
#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_BOX_ACCESS_4VALUES(Box, Point, Left, Bottom, Right, Top) \
template <> struct indexed_access<Box, min_corner, 0> \
{ \
typedef coordinate_type<Point>::type ct; \
using ct = coordinate_type_t<Point>; \
static inline ct get(Box const& b) { return b. Left; } \
static inline void set(Box& b, ct const& value) { b. Left = value; } \
}; \
template <> struct indexed_access<Box, min_corner, 1> \
{ \
typedef coordinate_type<Point>::type ct; \
using ct = coordinate_type_t<Point>; \
static inline ct get(Box const& b) { return b. Bottom; } \
static inline void set(Box& b, ct const& value) { b. Bottom = value; } \
}; \
template <> struct indexed_access<Box, max_corner, 0> \
{ \
typedef coordinate_type<Point>::type ct; \
using ct = coordinate_type_t<Point>; \
static inline ct get(Box const& b) { return b. Right; } \
static inline void set(Box& b, ct const& value) { b. Right = value; } \
}; \
template <> struct indexed_access<Box, max_corner, 1> \
{ \
typedef coordinate_type<Point>::type ct; \
using ct = coordinate_type_t<Point>; \
static inline ct get(Box const& b) { return b. Top; } \
static inline void set(Box& b, ct const& value) { b. Top = value; } \
};

6
include/boost/geometry/geometries/register/point.hpp
View File

@ -31,10 +31,10 @@
// Starting point, specialize basic traits necessary to register a point
#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_TRAITS(Point, Dim, CoordinateType, CoordinateSystem) \
template<> struct tag<Point> { typedef point_tag type; }; \
template<> struct tag<Point> { using type = point_tag; }; \
template<> struct dimension<Point> : std::integral_constant<std::size_t, Dim> {}; \
template<> struct coordinate_type<Point> { typedef CoordinateType type; }; \
template<> struct coordinate_system<Point> { typedef CoordinateSystem type; };
template<> struct coordinate_type<Point> { using type = CoordinateType; }; \
template<> struct coordinate_system<Point> { using type = CoordinateSystem; };
// Specialize access class per dimension
#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS(Point, Dim, CoordinateType, Get, Set) \

16
include/boost/geometry/geometries/register/segment.hpp
View File

@ -23,7 +23,7 @@
template <size_t D> \
struct indexed_access<Segment, min_corner, D> \
{ \
typedef typename coordinate_type<Point>::type ct; \
using ct = coordinate_type_t<Point>; \
static inline ct get(Segment const& b) \
{ return geometry::get<D>(b. Index0); } \
static inline void set(Segment& b, ct const& value) \
@ -32,7 +32,7 @@ struct indexed_access<Segment, min_corner, D> \
template <size_t D> \
struct indexed_access<Segment, max_corner, D> \
{ \
typedef typename coordinate_type<Point>::type ct; \
using ct = coordinate_type_t<Point>; \
static inline ct get(Segment const& b) \
{ return geometry::get<D>(b. Index1); } \
static inline void set(Segment& b, ct const& value) \
@ -44,7 +44,7 @@ struct indexed_access<Segment, max_corner, D> \
template <typename P, size_t D> \
struct indexed_access<Segment<P>, min_corner, D> \
{ \
typedef typename coordinate_type<P>::type ct; \
using ct = coordinate_type_t<P>; \
static inline ct get(Segment<P> const& b) \
{ return geometry::get<D>(b. Index0); } \
static inline void set(Segment<P>& b, ct const& value) \
@ -53,7 +53,7 @@ struct indexed_access<Segment<P>, min_corner, D> \
template <typename P, size_t D> \
struct indexed_access<Segment<P>, max_corner, D> \
{ \
typedef typename coordinate_type<P>::type ct; \
using ct = coordinate_type_t<P>; \
static inline ct get(Segment<P> const& b) \
{ return geometry::get<D>(b. Index1); } \
static inline void set(Segment<P>& b, ct const& value) \
@ -64,25 +64,25 @@ struct indexed_access<Segment<P>, max_corner, D> \
#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_SEGMENT_ACCESS_4VALUES(Segment, Point, Left, Bottom, Right, Top) \
template <> struct indexed_access<Segment, min_corner, 0> \
{ \
typedef coordinate_type<Point>::type ct; \
using ct = coordinate_type_t<Point>; \
static inline ct get(Segment const& b) { return b. Left; } \
static inline void set(Segment& b, ct const& value) { b. Left = value; } \
}; \
template <> struct indexed_access<Segment, min_corner, 1> \
{ \
typedef coordinate_type<Point>::type ct; \
using ct = coordinate_type_t<Point>; \
static inline ct get(Segment const& b) { return b. Bottom; } \
static inline void set(Segment& b, ct const& value) { b. Bottom = value; } \
}; \
template <> struct indexed_access<Segment, max_corner, 0> \
{ \
typedef coordinate_type<Point>::type ct; \
using ct = coordinate_type_t<Point>; \
static inline ct get(Segment const& b) { return b. Right; } \
static inline void set(Segment& b, ct const& value) { b. Right = value; } \
}; \
template <> struct indexed_access<Segment, max_corner, 1> \
{ \
typedef coordinate_type<Point>::type ct; \
using ct = coordinate_type_t<Point>; \
static inline ct get(Segment const& b) { return b. Top; } \
static inline void set(Segment& b, ct const& value) { b. Top = value; } \
};

8
include/boost/geometry/geometries/segment.hpp
View File

@ -137,7 +137,7 @@ template <typename Point, std::size_t Dimension>
struct indexed_access<model::segment<Point>, 0, Dimension>
{
typedef model::segment<Point> segment_type;
typedef typename geometry::coordinate_type<segment_type>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<segment_type>;
static constexpr coordinate_type get(segment_type const& s)
{
@ -155,7 +155,7 @@ template <typename Point, std::size_t Dimension>
struct indexed_access<model::segment<Point>, 1, Dimension>
{
typedef model::segment<Point> segment_type;
typedef typename geometry::coordinate_type<segment_type>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<segment_type>;
static constexpr coordinate_type get(segment_type const& s)
{
@ -200,7 +200,7 @@ template <typename ConstOrNonConstPoint, std::size_t Dimension>
struct indexed_access<model::referring_segment<ConstOrNonConstPoint>, 0, Dimension>
{
typedef model::referring_segment<ConstOrNonConstPoint> segment_type;
typedef typename geometry::coordinate_type<segment_type>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<segment_type>;
static inline coordinate_type get(segment_type const& s)
{
@ -218,7 +218,7 @@ template <typename ConstOrNonConstPoint, std::size_t Dimension>
struct indexed_access<model::referring_segment<ConstOrNonConstPoint>, 1, Dimension>
{
typedef model::referring_segment<ConstOrNonConstPoint> segment_type;
typedef typename geometry::coordinate_type<segment_type>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<segment_type>;
static inline coordinate_type get(segment_type const& s)
{

4
include/boost/geometry/index/detail/algorithms/comparable_distance_centroid.hpp
View File

@ -49,8 +49,8 @@ struct sum_for_indexable_dimension<Point, BoxIndexable, box_tag, comparable_dist
inline static result_type apply(Point const& pt, BoxIndexable const& i)
{
typedef typename coordinate_type<Point>::type point_coord_t;
typedef typename coordinate_type<BoxIndexable>::type indexable_coord_t;
using point_coord_t = coordinate_type_t<Point>;
using indexable_coord_t = coordinate_type_t<BoxIndexable>;
point_coord_t pt_c = geometry::get<DimensionIndex>(pt);
indexable_coord_t ind_c_min = geometry::get<geometry::min_corner, DimensionIndex>(i);

4
include/boost/geometry/index/detail/algorithms/comparable_distance_far.hpp
View File

@ -37,8 +37,8 @@ struct sum_for_indexable_dimension<Point, BoxIndexable, box_tag, comparable_dist
inline static result_type apply(Point const& pt, BoxIndexable const& i)
{
typedef typename coordinate_type<Point>::type point_coord_t;
typedef typename coordinate_type<BoxIndexable>::type indexable_coord_t;
using point_coord_t = coordinate_type_t<Point>;
using indexable_coord_t = coordinate_type<BoxIndexable>;
point_coord_t pt_c = geometry::get<DimensionIndex>(pt);
indexable_coord_t ind_c_min = geometry::get<geometry::min_corner, DimensionIndex>(i);

6
include/boost/geometry/index/detail/algorithms/comparable_distance_near.hpp
View File

@ -44,12 +44,12 @@ template <
size_t DimensionIndex>
struct sum_for_indexable_dimension<Point, BoxIndexable, box_tag, comparable_distance_near_tag, DimensionIndex>
{
typedef typename geometry::default_comparable_distance_result<Point, BoxIndexable>::type result_type;
using result_type = typename geometry::default_comparable_distance_result<Point, BoxIndexable>::type;
inline static result_type apply(Point const& pt, BoxIndexable const& i)
{
typedef typename coordinate_type<Point>::type point_coord_t;
typedef typename coordinate_type<BoxIndexable>::type indexable_coord_t;
using point_coord_t = coordinate_type_t<Point>;
using indexable_coord_t = coordinate_type_t<BoxIndexable>;
point_coord_t pt_c = geometry::get<DimensionIndex>(pt);
indexable_coord_t ind_c_min = geometry::get<geometry::min_corner, DimensionIndex>(i);

2
include/boost/geometry/index/detail/algorithms/margin.hpp
View File

@ -34,7 +34,7 @@ struct default_margin_result
{
using type = typename select_most_precise
<
typename coordinate_type<Box>::type,
coordinate_type_t<Box>,
double
>::type;
};

6
include/boost/geometry/index/detail/algorithms/minmaxdist.hpp
View File

@ -34,12 +34,12 @@ template <
size_t DimensionIndex>
struct smallest_for_indexable_dimension<Point, BoxIndexable, box_tag, minmaxdist_tag, DimensionIndex>
{
typedef typename geometry::default_comparable_distance_result<Point, BoxIndexable>::type result_type;
using result_type = typename geometry::default_comparable_distance_result<Point, BoxIndexable>::type;
inline static result_type apply(Point const& pt, BoxIndexable const& i, result_type const& maxd)
{
typedef typename coordinate_type<Point>::type point_coord_t;
typedef typename coordinate_type<BoxIndexable>::type indexable_coord_t;
using point_coord_t = coordinate_type_t<Point>;
using indexable_coord_t = coordinate_type_t<BoxIndexable>;
point_coord_t pt_c = geometry::get<DimensionIndex>(pt);
indexable_coord_t ind_c_min = geometry::get<geometry::min_corner, DimensionIndex>(i);

2
include/boost/geometry/index/detail/algorithms/segment_intersection.hpp
View File

@ -32,7 +32,7 @@ namespace boost { namespace geometry { namespace index { namespace detail {
// typedef typename select_most_precise<
// typename select_most_precise<
// typename coordinate_type<Indexable>::type,
// typename coordinate_type<Point>::type
// coordinate_type_t<Point>
// >::type,
// float // TODO - use bigger type, calculated from the size of coordinate types
// >::type type;

12
include/boost/geometry/index/detail/bounded_view.hpp
View File

@ -66,7 +66,7 @@ template <typename Segment, typename Box, typename Strategy>
struct bounded_view_base<Segment, Box, Strategy, segment_tag, box_tag, cartesian_tag>
{
public:
typedef typename geometry::coordinate_type<Box>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<Box>;
bounded_view_base(Segment const& segment, Strategy const& )
: m_segment(segment)
@ -95,7 +95,7 @@ private:
template <typename Segment, typename Box, typename Strategy, typename CSTag>
struct bounded_view_base<Segment, Box, Strategy, segment_tag, box_tag, CSTag>
{
typedef typename geometry::coordinate_type<Box>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<Box>;
bounded_view_base(Segment const& segment, Strategy const& strategy)
{
@ -124,7 +124,7 @@ template <typename BoxIn, typename Box, typename Strategy, typename CSTag>
struct bounded_view_base<BoxIn, Box, Strategy, box_tag, box_tag, CSTag>
{
public:
typedef typename geometry::coordinate_type<Box>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<Box>;
bounded_view_base(BoxIn const& box, Strategy const& )
: m_box(box)
@ -154,7 +154,7 @@ template <typename Point, typename Box, typename Strategy, typename CSTag>
struct bounded_view_base<Point, Box, Strategy, point_tag, box_tag, CSTag>
{
public:
typedef typename geometry::coordinate_type<Box>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<Box>;
bounded_view_base(Point const& point, Strategy const& )
: m_point(point)
@ -249,7 +249,7 @@ struct indexed_access<index::detail::bounded_view<Geometry, Box, Strategy, Tag,
min_corner, Dimension>
{
typedef index::detail::bounded_view<Geometry, Box, Strategy, Tag, box_tag> box_type;
typedef typename geometry::coordinate_type<Box>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<Box>;
static inline coordinate_type get(box_type const& b)
{
@ -267,7 +267,7 @@ struct indexed_access<index::detail::bounded_view<Geometry, Box, Strategy, Tag,
max_corner, Dimension>
{
typedef index::detail::bounded_view<Geometry, Box, Strategy, Tag, box_tag> box_type;
typedef typename geometry::coordinate_type<Box>::type coordinate_type;
using coordinate_type = geometry::coordinate_type_t<Box>;
static inline coordinate_type get(box_type const& b)
{

6
include/boost/geometry/index/detail/rtree/pack_create.hpp
View File

@ -42,10 +42,10 @@ struct biggest_edge
{
BOOST_STATIC_ASSERT(0 < Dimension);
template <typename Box>
static inline void apply(Box const& box, typename coordinate_type<Box>::type & length, std::size_t & dim_index)
static inline void apply(Box const& box, coordinate_type_t<Box> & length, std::size_t & dim_index)
{
biggest_edge<Dimension-1>::apply(box, length, dim_index);
typename coordinate_type<Box>::type curr
coordinate_type_t<Box> curr
= geometry::get<max_corner, Dimension-1>(box) - geometry::get<min_corner, Dimension-1>(box);
if ( length < curr )
{
@ -59,7 +59,7 @@ template <>
struct biggest_edge<1>
{
template <typename Box>
static inline void apply(Box const& box, typename coordinate_type<Box>::type & length, std::size_t & dim_index)
static inline void apply(Box const& box, coordinate_type_t<Box> & length, std::size_t & dim_index)
{
dim_index = 0;
length = geometry::get<max_corner, 0>(box) - geometry::get<min_corner, 0>(box);

20
include/boost/geometry/index/detail/rtree/utilities/gl_draw.hpp
View File

@ -39,10 +39,10 @@ struct gl_draw_point
template <typename Point>
struct gl_draw_point<Point, 2>
{
static inline void apply(Point const& p, typename coordinate_type<Point>::type z)
static inline void apply(Point const& p, coordinate_type_t<Point> z)
{
typename coordinate_type<Point>::type const& x = geometry::get<0>(p);
typename coordinate_type<Point>::type const& y = geometry::get<1>(p);
coordinate_type_t<Point> const& x = geometry::get<0>(p);
coordinate_type_t<Point> const& y = geometry::get<1>(p);
/*glBegin(GL_POINT);
glVertex3f(x, y, z);
glEnd();*/
@ -62,7 +62,7 @@ struct gl_draw_box
template <typename Box>
struct gl_draw_box<Box, 2>
{
static inline void apply(Box const& b, typename coordinate_type<Box>::type z)
static inline void apply(Box const& b, coordinate_type_t<Box> z)
{
glBegin(GL_LINE_LOOP);
glVertex3f(geometry::get<min_corner, 0>(b), geometry::get<min_corner, 1>(b), z);
@ -80,7 +80,7 @@ struct gl_draw_segment
template <typename Segment>
struct gl_draw_segment<Segment, 2>
{
static inline void apply(Segment const& s, typename coordinate_type<Segment>::type z)
static inline void apply(Segment const& s, coordinate_type_t<Segment> z)
{
glBegin(GL_LINES);
glVertex3f(geometry::get<0, 0>(s), geometry::get<0, 1>(s), z);
@ -115,7 +115,7 @@ struct gl_draw_indexable<Segment, segment_tag>
} // namespace dispatch
template <typename Indexable> inline
void gl_draw_indexable(Indexable const& i, typename coordinate_type<Indexable>::type z)
void gl_draw_indexable(Indexable const& i, coordinate_type_t<Indexable> z)
{
dispatch::gl_draw_indexable<
Indexable,
@ -142,7 +142,7 @@ struct gl_draw
inline gl_draw(translator_type const& t,
size_t level_first = 0,
size_t level_last = (std::numeric_limits<size_t>::max)(),
typename coordinate_type<box_type>::type z_coord_level_multiplier = 1
coordinate_type_t<box_type> z_coord_level_multiplier = 1
)
: tr(t)
, level_f(level_first)
@ -219,7 +219,7 @@ struct gl_draw
translator_type const& tr;
size_t level_f;
size_t level_l;
typename coordinate_type<box_type>::type z_mul;
coordinate_type_t<box_type> z_mul;
size_t level;
};
@ -230,9 +230,7 @@ template <typename Rtree> inline
void gl_draw(Rtree const& tree,
size_t level_first = 0,
size_t level_last = (std::numeric_limits<size_t>::max)(),
typename coordinate_type<
typename Rtree::bounds_type
>::type z_coord_level_multiplier = 1
coordinate_type_t<typename Rtree::bounds_type> z_coord_level_multiplier = 1
)
{
typedef utilities::view<Rtree> RTV;

4
include/boost/geometry/index/detail/serialization.hpp
View File

@ -252,7 +252,7 @@ struct serialize_point
template <typename Archive>
static inline void save(Archive & ar, P const& p, unsigned int version)
{
typename coordinate_type<P>::type c = get<I>(p);
coordinate_type_t<P> c = get<I>(p);
ar << boost::serialization::make_nvp("c", c);
serialize_point<P, I+1, D>::save(ar, p, version);
}
@ -260,7 +260,7 @@ struct serialize_point
template <typename Archive>
static inline void load(Archive & ar, P & p, unsigned int version)
{
typename geometry::coordinate_type<P>::type c;
geometry::coordinate_type_t<P> c;
ar >> boost::serialization::make_nvp("c", c);
set<I>(p, c);
serialize_point<P, I+1, D>::load(ar, p, version);

2
include/boost/geometry/index/rtree.hpp
View File

@ -193,7 +193,7 @@ public:
/*! \brief The Box type used by the R-tree. */
typedef geometry::model::box<
geometry::model::point<
typename coordinate_type<indexable_type>::type,
coordinate_type_t<indexable_type>,
dimension<indexable_type>::value,
typename coordinate_system<indexable_type>::type
>

2
include/boost/geometry/io/svg/svg_mapper.hpp
View File

@ -270,7 +270,7 @@ class svg_mapper : boost::noncopyable
typedef typename geometry::select_most_precise
<
typename coordinate_type<Point>::type,
coordinate_type_t<Point>,
double
>::type calculation_type;

12
include/boost/geometry/io/svg/write.hpp
View File

@ -71,7 +71,7 @@ struct svg_box
// Prevent invisible boxes, making them >=1, using "max"
BOOST_USING_STD_MAX();
typedef typename coordinate_type<Box>::type ct;
using ct = coordinate_type_t<Box>;
ct x = geometry::get<geometry::min_corner, 0>(box);
ct y = geometry::get<geometry::min_corner, 1>(box);
ct width = max BOOST_PREVENT_MACRO_SUBSTITUTION (ct(1),
@ -92,11 +92,11 @@ struct svg_segment
static inline void apply(std::basic_ostream<Char, Traits>& os,
Segment const& segment, std::string const& style, double)
{
typedef typename coordinate_type<Segment>::type ct;
ct x1 = geometry::get<0, 0>(segment);
ct y1 = geometry::get<0, 1>(segment);
ct x2 = geometry::get<1, 0>(segment);
ct y2 = geometry::get<1, 1>(segment);
using ct = coordinate_type_t<Segment>;
ct const x1 = geometry::get<0, 0>(segment);
ct const y1 = geometry::get<0, 1>(segment);
ct const x2 = geometry::get<1, 0>(segment);
ct const y2 = geometry::get<1, 1>(segment);
os << "<line x1=\"" << x1 << "\" y1=\"" << y1
<< "\" x2=\"" << x2 << "\" y2=\"" << y2

8
include/boost/geometry/io/wkt/read.hpp
View File

@ -132,7 +132,7 @@ struct parsing_assigner
Point& point,
std::string const& wkt)
{
using coordinate_type = typename coordinate_type<Point>::type;
using coordinate_type = coordinate_type_t<Point>;
// Stop at end of tokens, or at "," ot ")"
bool finished = (it == end || *it == "," || *it == ")");
@ -263,7 +263,7 @@ template <typename Geometry,
struct stateful_range_appender
{
// NOTE: Geometry is a reference
inline void append(Geometry geom, typename geometry::point_type<Geometry>::type const& point, bool)
inline void append(Geometry geom, geometry::point_type_t<Geometry> const& point, bool)
{
geometry::append(geom, point);
}
@ -272,7 +272,7 @@ struct stateful_range_appender
template <typename Geometry>
struct stateful_range_appender<Geometry, open>
{
using point_type = typename geometry::point_type<Geometry>::type;
using point_type = geometry::point_type_t<Geometry>;
using size_type = typename boost::range_size
<
typename util::remove_cptrref<Geometry>::type
@ -329,7 +329,7 @@ private:
template <typename Geometry>
struct container_appender
{
using point_type = typename geometry::point_type<Geometry>::type;
using point_type = geometry::point_type_t<Geometry>;
template <typename TokenizerIterator>
static inline void apply(TokenizerIterator& it,

4
include/boost/geometry/iterators/detail/point_iterator/value_type.hpp
View File

@ -32,8 +32,8 @@ struct value_type
typedef std::conditional_t
<
! std::is_const<Geometry>::value,
typename geometry::point_type<Geometry>::type,
typename geometry::point_type<Geometry>::type const
geometry::point_type_t<Geometry>,
geometry::point_type_t<Geometry> const
> type;
};

2
include/boost/geometry/policies/robustness/segment_ratio.hpp
View File

@ -351,7 +351,7 @@ private :
template <typename Point>
struct segment_ratio_type
{
using type = segment_ratio<typename geometry::coordinate_type<Point>::type>;
using type = segment_ratio<geometry::coordinate_type_t<Point>>;
};
}} // namespace boost::geometry

60
include/boost/geometry/srs/projections/impl/pj_transform.hpp
View File

@ -75,7 +75,7 @@ template
>
struct z_access
{
typedef typename coordinate_type<Point>::type type;
using type = coordinate_type_t<Point>;
static inline type get(Point const& point)
{
return geometry::get<2>(point);
@ -89,7 +89,7 @@ struct z_access
template <typename Point>
struct z_access<Point, false>
{
typedef typename coordinate_type<Point>::type type;
using type = coordinate_type_t<Point>;
static inline type get(Point const& )
{
return type(0);
@ -119,9 +119,9 @@ template
>
struct range_wrapper
{
typedef Range range_type;
typedef typename boost::range_value<Range>::type point_type;
typedef typename coordinate_type<point_type>::type coord_t;
using range_type = Range;
using point_type = typename boost::range_value<Range>::type;
using coord_t = coordinate_type_t<point_type>;
range_wrapper(Range & range)
: m_range(range)
@ -139,9 +139,9 @@ private:
template <typename Range>
struct range_wrapper<Range, true>
{
typedef Range range_type;
typedef typename boost::range_value<Range>::type point_type;
typedef typename coordinate_type<point_type>::type coord_t;
using range_type = Range;
using point_type = typename boost::range_value<Range>::type;
using coord_t = coordinate_type_t<point_type>;
range_wrapper(Range & range)
: m_range(range)
@ -237,8 +237,8 @@ inline bool pj_transform(SrcPrj const& srcprj, Par const& srcdefn,
Grids const& dstgrids)
{
typedef typename boost::range_value<Range>::type point_type;
typedef typename coordinate_type<point_type>::type coord_t;
using point_type = typename boost::range_value<Range>::type;
using coord_t = coordinate_type_t<point_type>;
static const std::size_t dimension = geometry::dimension<point_type>::value;
std::size_t point_count = boost::size(range);
bool result = true;
@ -616,9 +616,7 @@ inline int pj_geodetic_to_geocentric( T const& a, T const& es,
range_wrapper<Range, AddZ> & range_wrapper )
{
//typedef typename boost::range_iterator<Range>::type iterator;
typedef typename boost::range_value<Range>::type point_type;
//typedef typename coordinate_type<point_type>::type coord_t;
using point_type = typename boost::range_value<Range>::type;
Range & rng = range_wrapper.get_range();
std::size_t point_count = boost::size(rng);
@ -671,9 +669,7 @@ inline int pj_geocentric_to_geodetic( T const& a, T const& es,
range_wrapper<Range, AddZ> & range_wrapper )
{
//typedef typename boost::range_iterator<Range>::type iterator;
typedef typename boost::range_value<Range>::type point_type;
//typedef typename coordinate_type<point_type>::type coord_t;
using point_type = typename boost::range_value<Range>::type;
Range & rng = range_wrapper.get_range();
std::size_t point_count = boost::size(rng);
@ -762,20 +758,22 @@ inline int pj_geocentric_to_wgs84( Par const& defn,
range_wrapper<Range, AddZ> & range_wrapper )
{
typedef typename boost::range_value<Range>::type point_type;
typedef typename coordinate_type<point_type>::type coord_t;
using point_type = typename boost::range_value<Range>::type;
using coord_t = coordinate_type_t<point_type>;
Range & rng = range_wrapper.get_range();
Range& rng = range_wrapper.get_range();
std::size_t point_count = boost::size(rng);
if( defn.datum_type == datum_3param )
if (defn.datum_type == datum_3param)
{
for(std::size_t i = 0; i < point_count; i++ )
for (std::size_t i = 0; i < point_count; i++ )
{
point_type & point = range::at(rng, i);
point_type& point = range::at(rng, i);
if( is_invalid_point(point) )
if (is_invalid_point(point))
{
continue;
}
set<0>(point, get<0>(point) + Dx_BF(defn));
set<1>(point, get<1>(point) + Dy_BF(defn));
@ -819,20 +817,22 @@ inline int pj_geocentric_from_wgs84( Par const& defn,
range_wrapper<Range, AddZ> & range_wrapper )
{
typedef typename boost::range_value<Range>::type point_type;
typedef typename coordinate_type<point_type>::type coord_t;
using point_type = typename boost::range_value<Range>::type;
using coord_t = coordinate_type_t<point_type>;
Range & rng = range_wrapper.get_range();
Range& rng = range_wrapper.get_range();
std::size_t point_count = boost::size(rng);
if( defn.datum_type == datum_3param )
if (defn.datum_type == datum_3param)
{
for(std::size_t i = 0; i < point_count; i++ )
for (std::size_t i = 0; i < point_count; i++ )
{
point_type & point = range::at(rng, i);
point_type& point = range::at(rng, i);
if( is_invalid_point(point) )
if (is_invalid_point(point))
{
continue;
}
set<0>(point, get<0>(point) - Dx_BF(defn));
set<1>(point, get<1>(point) - Dy_BF(defn));

12
include/boost/geometry/srs/transformation.hpp
View File

@ -93,18 +93,18 @@ struct transform_geometry_point_coordinates<PtIn, PtOut, false>
template <typename Geometry, typename CT>
struct transform_geometry_point
{
typedef typename geometry::point_type<Geometry>::type point_type;
using point_type = geometry::point_type_t<Geometry>;
typedef geometry::model::point
using type = geometry::model::point
<
typename select_most_precise
<
typename geometry::coordinate_type<point_type>::type,
geometry::coordinate_type_t<point_type>,
CT
>::type,
geometry::dimension<point_type>::type::value,
typename geometry::coordinate_system<point_type>::type
> type;
>;
template <typename PtIn, typename PtOut>
static inline void apply(PtIn const& in, PtOut & out, bool enable_angles)
@ -229,10 +229,10 @@ template
<
typename select_most_precise
<
typename geometry::coordinate_type<OutGeometry>::type,
geometry::coordinate_type_t<OutGeometry>,
CT
>::type,
typename geometry::coordinate_type<OutGeometry>::type
geometry::coordinate_type_t<OutGeometry>
>::value
>
struct transform_geometry_wrapper

7
include/boost/geometry/strategies/cartesian/buffer_end_round.hpp
View File

@ -118,13 +118,12 @@ public :
RangeOut& range_out) const
{
boost::ignore_unused(perp_left_point);
typedef typename coordinate_type<Point>::type coordinate_type;
typedef typename geometry::select_most_precise
using promoted_type = typename geometry::select_most_precise
<
coordinate_type,
coordinate_type_t<Point>,
double
>::type promoted_type;
>::type;
promoted_type const dist_left = distance.apply(penultimate_point, ultimate_point, buffer_side_left);
promoted_type const dist_right = distance.apply(penultimate_point, ultimate_point, buffer_side_right);

7
include/boost/geometry/strategies/cartesian/buffer_join_miter.hpp
View File

@ -77,12 +77,11 @@ public:
return false;
}
typedef typename coordinate_type<Point>::type coordinate_type;
typedef typename geometry::select_most_precise
using promoted_type = typename geometry::select_most_precise
<
coordinate_type,
coordinate_type_t<Point>,
double
>::type promoted_type;
>::type;
Point p = ip;

14
include/boost/geometry/strategies/cartesian/buffer_join_round.hpp
View File

@ -128,18 +128,12 @@ public :
DistanceType const& buffer_distance,
RangeOut& range_out) const
{
typedef typename coordinate_type<Point>::type coordinate_type;
typedef typename boost::range_value<RangeOut>::type output_point_type;
typedef typename geometry::select_most_precise
using promoted_type = typename geometry::select_most_precise
<
typename geometry::select_most_precise
<
coordinate_type,
typename geometry::coordinate_type<output_point_type>::type
>::type,
coordinate_type_t<Point>,
geometry::coordinate_type_t<typename boost::range_value<RangeOut>::type>,
double
>::type promoted_type;
>::type;
geometry::equal_to<Point> equals;
if (equals(perp1, perp2))

Some files were not shown because too many files have changed in this diff Show More