From 0f23d2317aa3018d327a81d869a22022a77871df Mon Sep 17 00:00:00 2001 From: Adam Wulkiewicz Date: Mon, 22 Sep 2014 00:30:08 +0200 Subject: [PATCH 01/34] [index] Fix signed/unsigned comparison in is_valid (MPL_ASSERT). --- include/boost/geometry/index/detail/algorithms/is_valid.hpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/include/boost/geometry/index/detail/algorithms/is_valid.hpp b/include/boost/geometry/index/detail/algorithms/is_valid.hpp index ee42e3936..0450f3b65 100644 --- a/include/boost/geometry/index/detail/algorithms/is_valid.hpp +++ b/include/boost/geometry/index/detail/algorithms/is_valid.hpp @@ -19,7 +19,9 @@ template struct is_valid_box { BOOST_MPL_ASSERT_MSG( - (0 < Dimension && Dimension <= dimension::value), + (0 < dimension::value && + 0 < Dimension && + Dimension <= static_cast(dimension::value)), INVALID_DIMENSION_PARAMETER, (is_valid_box)); From ff24c271a748c68814bd09301b2a7fac60cf353a Mon Sep 17 00:00:00 2001 From: "Patrick J. LoPresti" Date: Mon, 22 Sep 2014 14:13:14 -0700 Subject: [PATCH 02/34] [core] Fix signed/unsigned comparison warnings --- include/boost/geometry/core/coordinate_dimension.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/include/boost/geometry/core/coordinate_dimension.hpp b/include/boost/geometry/core/coordinate_dimension.hpp index 15df129de..e11ff33af 100644 --- a/include/boost/geometry/core/coordinate_dimension.hpp +++ b/include/boost/geometry/core/coordinate_dimension.hpp @@ -89,7 +89,7 @@ inline void assert_dimension() BOOST_STATIC_ASSERT(( boost::mpl::equal_to < - geometry::dimension, + boost::mpl::int_::value>, boost::mpl::int_ >::type::value )); @@ -102,13 +102,13 @@ inline void assert_dimension() template inline void assert_dimension_less_equal() { - BOOST_STATIC_ASSERT(( dimension::type::value <= Dimensions )); + BOOST_STATIC_ASSERT(( static_cast(dimension::type::value) <= Dimensions )); } template inline void assert_dimension_greater_equal() { - BOOST_STATIC_ASSERT(( dimension::type::value >= Dimensions )); + BOOST_STATIC_ASSERT(( static_cast(dimension::type::value) >= Dimensions )); } /*! @@ -118,7 +118,7 @@ inline void assert_dimension_greater_equal() template inline void assert_dimension_equal() { - BOOST_STATIC_ASSERT(( dimension::type::value == dimension::type::value )); + BOOST_STATIC_ASSERT(( static_cast(dimension::type::value) == static_cast(dimension::type::value) )); } }} // namespace boost::geometry From 2756392b512650db62a0eb8fd9e18243cdee1b29 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Wed, 24 Sep 2014 08:38:43 +0300 Subject: [PATCH 03/34] [test][point_iterator] fix/update includes --- test/iterators/point_iterator.cpp | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/test/iterators/point_iterator.cpp b/test/iterators/point_iterator.cpp index 5751cb39f..62bd1b2cd 100644 --- a/test/iterators/point_iterator.cpp +++ b/test/iterators/point_iterator.cpp @@ -23,6 +23,8 @@ #include +#include + #include #include @@ -37,12 +39,8 @@ #include -#include -#include +#include #include -#include -#include -#include #include #include From 6c6c31d1b24aeed596921e8425b97612775dba84 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Wed, 24 Sep 2014 08:39:45 +0300 Subject: [PATCH 04/34] [iterators][point_iterator] add missing include for interior_type --- include/boost/geometry/iterators/point_iterator_type.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/include/boost/geometry/iterators/point_iterator_type.hpp b/include/boost/geometry/iterators/point_iterator_type.hpp index 4991b2718..28a7d4e81 100644 --- a/include/boost/geometry/iterators/point_iterator_type.hpp +++ b/include/boost/geometry/iterators/point_iterator_type.hpp @@ -17,6 +17,7 @@ #include #include +#include #include #include #include From 49af3c4c8778fb99d408780911f904af24bab2d2 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Wed, 24 Sep 2014 08:41:42 +0300 Subject: [PATCH 05/34] [iterators][flatten_iterator] add one more template parameter for the reference type (previously it was defaulted to Value&) --- .../geometry/iterators/flatten_iterator.hpp | 33 ++++++++++++------- 1 file changed, 22 insertions(+), 11 deletions(-) diff --git a/include/boost/geometry/iterators/flatten_iterator.hpp b/include/boost/geometry/iterators/flatten_iterator.hpp index 42f755552..078079dc2 100644 --- a/include/boost/geometry/iterators/flatten_iterator.hpp +++ b/include/boost/geometry/iterators/flatten_iterator.hpp @@ -29,7 +29,8 @@ template typename InnerIterator, typename Value, typename AccessInnerBegin, - typename AccessInnerEnd + typename AccessInnerEnd, + typename Reference = Value& > class flatten_iterator : public boost::iterator_facade @@ -40,9 +41,12 @@ class flatten_iterator InnerIterator, Value, AccessInnerBegin, - AccessInnerEnd>, + AccessInnerEnd, + Reference + >, Value, - boost::bidirectional_traversal_tag + boost::bidirectional_traversal_tag, + Reference > { private: @@ -72,7 +76,8 @@ public: < typename OtherOuterIterator, typename OtherInnerIterator, typename OtherValue, - typename OtherAccessInnerBegin, typename OtherAccessInnerEnd + typename OtherAccessInnerBegin, typename OtherAccessInnerEnd, + typename OtherReference > flatten_iterator(flatten_iterator < @@ -80,7 +85,8 @@ public: OtherInnerIterator, OtherValue, OtherAccessInnerBegin, - OtherAccessInnerEnd + OtherAccessInnerEnd, + OtherReference > const& other) : m_outer_it(other.m_outer_it), m_outer_end(other.m_outer_end), @@ -107,7 +113,8 @@ public: typename OtherInnerIterator, typename OtherValue, typename OtherAccessInnerBegin, - typename OtherAccessInnerEnd + typename OtherAccessInnerEnd, + typename OtherReference > flatten_iterator operator=(flatten_iterator < @@ -115,7 +122,8 @@ public: OtherInnerIterator, OtherValue, OtherAccessInnerBegin, - OtherAccessInnerEnd + OtherAccessInnerEnd, + OtherReference > const& other) { static const bool are_conv @@ -147,7 +155,8 @@ private: typename Inner, typename V, typename InnerBegin, - typename InnerEnd + typename InnerEnd, + typename R > friend class flatten_iterator; @@ -170,7 +179,7 @@ private: } } - inline Value& dereference() const + inline Reference dereference() const { BOOST_ASSERT( m_outer_it != m_outer_end ); BOOST_ASSERT( m_inner_it != AccessInnerEnd::apply(*m_outer_it) ); @@ -184,7 +193,8 @@ private: typename OtherInnerIterator, typename OtherValue, typename OtherAccessInnerBegin, - typename OtherAccessInnerEnd + typename OtherAccessInnerEnd, + typename OtherReference > inline bool equal(flatten_iterator < @@ -192,7 +202,8 @@ private: OtherInnerIterator, OtherValue, OtherAccessInnerBegin, - OtherAccessInnerEnd + OtherAccessInnerEnd, + OtherReference > const& other) const { if ( m_outer_it != other.m_outer_it ) From 73ec339f7b38edec2a1f767aaf036fc53ef395a3 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Wed, 24 Sep 2014 08:42:37 +0300 Subject: [PATCH 06/34] [iterators][concatenate_iterator] add one more template parameter for the reference type (previously it was defaulted to Value&) --- .../iterators/concatenate_iterator.hpp | 62 +++++++++++++++---- 1 file changed, 49 insertions(+), 13 deletions(-) diff --git a/include/boost/geometry/iterators/concatenate_iterator.hpp b/include/boost/geometry/iterators/concatenate_iterator.hpp index e97061e1a..20112b4c4 100644 --- a/include/boost/geometry/iterators/concatenate_iterator.hpp +++ b/include/boost/geometry/iterators/concatenate_iterator.hpp @@ -23,13 +23,20 @@ namespace boost { namespace geometry -template +template +< + typename Iterator1, + typename Iterator2, + typename Value, + typename Reference = Value& +> class concatenate_iterator : public boost::iterator_facade < - concatenate_iterator, + concatenate_iterator, Value, - boost::bidirectional_traversal_tag + boost::bidirectional_traversal_tag, + Reference > { private: @@ -54,9 +61,20 @@ public: : m_it1(end1), m_end1(end1), m_begin2(begin2), m_it2(end2) {} - template - concatenate_iterator - (concatenate_iterator const& other) + template + < + typename OtherIt1, + typename OtherIt2, + typename OtherValue, + typename OtherReference + > + concatenate_iterator(concatenate_iterator + < + OtherIt1, + OtherIt2, + OtherValue, + OtherReference + > const& other) : m_it1(other.m_it1) , m_end1(other.m_end1) , m_begin2(other.m_begin2) @@ -71,9 +89,20 @@ public: (types)); } - template - concatenate_iterator - operator=(concatenate_iterator const& other) + template + < + typename OtherIt1, + typename OtherIt2, + typename OtherValue, + typename OtherReference + > + concatenate_iterator operator=(concatenate_iterator + < + OtherIt1, + OtherIt2, + OtherValue, + OtherReference + > const& other) { static const bool are_conv = boost::is_convertible::value @@ -93,10 +122,10 @@ public: private: friend class boost::iterator_core_access; - template + template friend class concatenate_iterator; - inline Value& dereference() const + inline Reference dereference() const { if ( m_it1 == m_end1 ) { @@ -105,12 +134,19 @@ private: return *m_it1; } - template + template + < + typename OtherIt1, + typename OtherIt2, + typename OtherValue, + typename OtherReference + > inline bool equal(concatenate_iterator < OtherIt1, OtherIt2, - OtherValue + OtherValue, + OtherReference > const& other) const { return m_it1 == other.m_it1 && m_it2 == other.m_it2; From e9aee617341a5b698269608b8f69eae46f18e9ec Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Wed, 24 Sep 2014 08:45:02 +0300 Subject: [PATCH 07/34] [iterators][segment_iterator] add basic dispatch definitions for the segment_iterator and segment_iterator_type classes --- .../iterators/dispatch/segment_iterator.hpp | 47 +++++++++++++++++++ .../dispatch/segment_iterator_type.hpp | 37 +++++++++++++++ 2 files changed, 84 insertions(+) create mode 100644 include/boost/geometry/iterators/dispatch/segment_iterator.hpp create mode 100644 include/boost/geometry/iterators/dispatch/segment_iterator_type.hpp diff --git a/include/boost/geometry/iterators/dispatch/segment_iterator.hpp b/include/boost/geometry/iterators/dispatch/segment_iterator.hpp new file mode 100644 index 000000000..3c50c7a20 --- /dev/null +++ b/include/boost/geometry/iterators/dispatch/segment_iterator.hpp @@ -0,0 +1,47 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2014, Oracle and/or its affiliates. + +// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle + +// Licensed under the Boost Software License version 1.0. +// http://www.boost.org/users/license.html + +#ifndef BOOST_GEOMETRY_ITERATORS_DISPATCH_SEGMENT_ITERATOR_HPP +#define BOOST_GEOMETRY_ITERATORS_DISPATCH_SEGMENT_ITERATOR_HPP + +#include +#include + +namespace boost { namespace geometry +{ + + +#ifndef DOXYGEN_NO_DISPATCH +namespace dispatch +{ + + +// dispatch for points_begin +template ::type> +struct segments_begin + : not_implemented +{}; + + + +// dispatch for points_end +template ::type> +struct segments_end + : not_implemented +{}; + + + +} // namespace dispatch +#endif // DOXYGEN_NO_DISPATCH + + +}} // namespace boost::geometry + +#endif // BOOST_GEOMETRY_ITERATORS_DISPATCH_SEGMENT_ITERATOR_HPP diff --git a/include/boost/geometry/iterators/dispatch/segment_iterator_type.hpp b/include/boost/geometry/iterators/dispatch/segment_iterator_type.hpp new file mode 100644 index 000000000..f4817ee42 --- /dev/null +++ b/include/boost/geometry/iterators/dispatch/segment_iterator_type.hpp @@ -0,0 +1,37 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2014, Oracle and/or its affiliates. + +// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle + +// Licensed under the Boost Software License version 1.0. +// http://www.boost.org/users/license.html + +#ifndef BOOST_GEOMETRY_ITERATORS_DISPATCH_SEGMENT_ITERATOR_TYPE_HPP +#define BOOST_GEOMETRY_ITERATORS_DISPATCH_SEGMENT_ITERATOR_TYPE_HPP + +#include +#include + +namespace boost { namespace geometry +{ + + +#ifndef DOXYGEN_NO_DISPATCH +namespace dispatch +{ + +template ::type> +struct segment_iterator_type + : not_implemented +{}; + + + +} // namespace dispatch +#endif // DOXYGEN_NO_DISPATCH + + +}} // namespace boost::geometry + +#endif // BOOST_GEOMETRY_ITERATORS_DISPATCH_SEGMENT_ITERATOR_TYPE_HPP From 3739d7914092e0c27ebd727c0d58412a7c2f6697 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Wed, 24 Sep 2014 08:48:09 +0300 Subject: [PATCH 08/34] [iterators][segment_iterator] add implementation for an iterator over the segments of a range --- .../iterators/range_segment_iterator.hpp | 201 ++++++++++++++++++ 1 file changed, 201 insertions(+) create mode 100644 include/boost/geometry/iterators/range_segment_iterator.hpp diff --git a/include/boost/geometry/iterators/range_segment_iterator.hpp b/include/boost/geometry/iterators/range_segment_iterator.hpp new file mode 100644 index 000000000..2d6320c03 --- /dev/null +++ b/include/boost/geometry/iterators/range_segment_iterator.hpp @@ -0,0 +1,201 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2014, Oracle and/or its affiliates. + +// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle + +// Licensed under the Boost Software License version 1.0. +// http://www.boost.org/users/license.html + +#ifndef BOOST_GEOMETRY_ITERATORS_RANGE_SEGMENT_ITERATOR_HPP +#define BOOST_GEOMETRY_ITERATORS_RANGE_SEGMENT_ITERATOR_HPP + +#include +#include +#include +#include +#include +#include + +#include +#include + + +namespace boost { namespace geometry +{ + + +template ::value> +struct range_iterator_type +{ + typedef typename boost::range_iterator::type type; +}; + +template +struct range_iterator_type +{ + typedef closing_iterator type; +}; + + + +template ::value> +struct range_iterator_begin +{ + static inline typename range_iterator_type::type + apply(Range& range) + { + return boost::begin(range); + } +}; + +template +struct range_iterator_begin +{ + static inline typename range_iterator_type::type + apply(Range& range) + { + return closing_iterator(range); + } +}; + + + +template ::value> +struct range_iterator_end +{ + static inline typename range_iterator_type::type + apply(Range& range) + { + return boost::end(range); + } +}; + +template +struct range_iterator_end +{ + static inline typename range_iterator_type::type + apply(Range& range) + { + return closing_iterator(range, true); + } +}; + + + + + + +template +class range_segment_iterator + : public boost::iterator_facade + < + range_segment_iterator, + Value, + boost::bidirectional_traversal_tag, + Reference + > +{ +public: + typedef typename range_iterator_type::type iterator_type; + + // default constructor + range_segment_iterator() + : m_it() + {} + + // for begin + range_segment_iterator(Range& r) + : m_it(range_iterator_begin::apply(r)) + {} + + // for end + range_segment_iterator(Range& r, bool) + : m_it(--range_iterator_end::apply(r)) + {} + + template + range_segment_iterator(range_segment_iterator + < + OtherRange, + OtherValue, + OtherReference + > const& other) + : m_it(other.m_it) + { + typedef typename range_segment_iterator + < + OtherRange, OtherValue, OtherReference + >::iterator_type other_iterator_type; + + static const bool are_conv + = boost::is_convertible::value; + + BOOST_MPL_ASSERT_MSG((are_conv), NOT_CONVERTIBLE, (types)); + } + + template + range_segment_iterator operator=(range_segment_iterator + < + OtherRange, + OtherValue, + OtherReference + > const& other) + { + typedef typename range_segment_iterator + < + OtherRange, OtherValue, OtherReference + >::iterator_type other_iterator_type; + + static const bool are_conv + = boost::is_convertible::value; + + BOOST_MPL_ASSERT_MSG((are_conv), NOT_CONVERTIBLE, (types)); + + m_it = other.m_it; + return *this; + } + +private: + friend class boost::iterator_core_access; + + template + friend class range_segment_iterator; + + inline Reference dereference() const + { + iterator_type next(m_it); + ++next; + return Reference(*m_it, *next); + } + + template + inline bool equal(range_segment_iterator + < + OtherRange, + OtherValue, + OtherReference + > const& other) const + { + return m_it == other.m_it; + } + + inline void increment() + { + ++m_it; + } + + inline void decrement() + { + --m_it; + } + +private: + iterator_type m_it; +}; + + +}} // namespace boost::geometry + + +#endif // BOOST_GEOMETRY_ITERATORS_RANGE_SEGMENT_ITERATOR_HPP From 6dea5fca8410cee84399d485a50253b37cc25d04 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Wed, 24 Sep 2014 08:48:43 +0300 Subject: [PATCH 09/34] [iterators][segment_iterator] add implementation for the underlying segment_iterator type --- .../iterators/segment_iterator_type.hpp | 165 ++++++++++++++++++ 1 file changed, 165 insertions(+) create mode 100644 include/boost/geometry/iterators/segment_iterator_type.hpp diff --git a/include/boost/geometry/iterators/segment_iterator_type.hpp b/include/boost/geometry/iterators/segment_iterator_type.hpp new file mode 100644 index 000000000..7ff62e1e2 --- /dev/null +++ b/include/boost/geometry/iterators/segment_iterator_type.hpp @@ -0,0 +1,165 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2014, Oracle and/or its affiliates. + +// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle + +// Licensed under the Boost Software License version 1.0. +// http://www.boost.org/users/license.html + +#ifndef BOOST_GEOMETRY_ITERATORS_SEGMENT_ITERATOR_TYPE_HPP +#define BOOST_GEOMETRY_ITERATORS_SEGMENT_ITERATOR_TYPE_HPP + +#include + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +#include +#include + + +namespace boost { namespace geometry +{ + + +template +struct segment_iterator_value_type +{ + typedef typename detail_dispatch::point_iterator_value_type + < + Geometry + >::type point_iterator_value_type; + + typedef geometry::model::referring_segment + < + point_iterator_value_type + > type; +}; + + + +#ifndef DOXYGEN_NO_DISPATCH +namespace dispatch +{ + + +template +struct segment_iterator_type +{ + typedef range_segment_iterator + < + Linestring, + typename segment_iterator_value_type::type + > type; +}; + + +template +struct segment_iterator_type +{ + typedef range_segment_iterator + < + Ring, + typename segment_iterator_value_type::type + > type; +}; + + +template +class segment_iterator_type +{ +private: + typedef typename detail_dispatch::point_iterator_inner_range_type + < + Polygon + >::type inner_range; + +public: + typedef concatenate_iterator + < + range_segment_iterator + < + inner_range, + typename segment_iterator_value_type::type + >, + flatten_iterator + < + typename boost::range_iterator + < + typename geometry::interior_type::type + >::type, + typename dispatch::segment_iterator_type::type, + typename segment_iterator_value_type::type, + dispatch::segments_begin, + dispatch::segments_end, + typename segment_iterator_value_type::type + >, + typename segment_iterator_value_type::type, + typename segment_iterator_value_type::type + > type; +}; + + +template +class segment_iterator_type +{ +private: + typedef typename detail_dispatch::point_iterator_inner_range_type + < + MultiLinestring + >::type inner_range; + +public: + typedef flatten_iterator + < + typename boost::range_iterator::type, + typename dispatch::segment_iterator_type::type, + typename segment_iterator_value_type::type, + dispatch::segments_begin, + dispatch::segments_end, + typename segment_iterator_value_type::type + > type; +}; + + +template +class segment_iterator_type +{ +private: + typedef typename detail_dispatch::point_iterator_inner_range_type + < + MultiPolygon + >::type inner_range; + +public: + typedef flatten_iterator + < + typename boost::range_iterator::type, + typename dispatch::segment_iterator_type::type, + typename segment_iterator_value_type::type, + dispatch::segments_begin, + dispatch::segments_end, + typename segment_iterator_value_type::type + > type; +}; + + + +} // namespace dispatch +#endif // DOXYGEN_NO_DISPATCH + + +}} // namespace boost::geometry + + +#endif // BOOST_GEOMETRY_ITERATORS_SEGMENT_ITERATOR_TYPE_HPP From d2be8d47a39eda29ffcfca5d5ff171ecd35ab470 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Wed, 24 Sep 2014 08:49:19 +0300 Subject: [PATCH 10/34] [iterators][segment_iterator] add implementation for the segment_iterator class, as well as for the free functions segments_begin and segments_end --- .../geometry/iterators/segment_iterator.hpp | 277 ++++++++++++++++++ 1 file changed, 277 insertions(+) create mode 100644 include/boost/geometry/iterators/segment_iterator.hpp diff --git a/include/boost/geometry/iterators/segment_iterator.hpp b/include/boost/geometry/iterators/segment_iterator.hpp new file mode 100644 index 000000000..e9747d55b --- /dev/null +++ b/include/boost/geometry/iterators/segment_iterator.hpp @@ -0,0 +1,277 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2014, Oracle and/or its affiliates. + +// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle + +// Licensed under the Boost Software License version 1.0. +// http://www.boost.org/users/license.html + +#ifndef BOOST_GEOMETRY_ITERATORS_SEGMENT_ITERATOR_HPP +#define BOOST_GEOMETRY_ITERATORS_SEGMENT_ITERATOR_HPP + +#include +#include +#include + +#include +#include +#include + +#include +#include + +#include + + +namespace boost { namespace geometry +{ + + +#ifndef DOXYGEN_NO_DISPATCH +namespace dispatch +{ + + +// specializations for points_begin + + +template +struct segments_begin +{ + typedef typename segment_iterator_type::type result_type; + + static inline result_type apply(Linestring& linestring) + { + return result_type(linestring); + } +}; + + +template +struct segments_begin +{ + typedef typename segment_iterator_type::type result_type; + + static inline result_type apply(Ring& ring) + { + return result_type(ring); + } +}; + + +template +struct segments_begin +{ + typedef typename detail_dispatch::point_iterator_inner_range_type + < + Polygon + >::type inner_range; + + typedef typename segment_iterator_type::type return_type; + + static inline return_type apply(Polygon& polygon) + { + typedef typename return_type::second_iterator_type flatten_iterator; + + return return_type + (segments_begin + < + inner_range + >::apply(geometry::exterior_ring(polygon)), + segments_end::apply(geometry::exterior_ring(polygon)), + flatten_iterator(boost::begin(geometry::interior_rings(polygon)), + boost::end(geometry::interior_rings(polygon)) + ), + flatten_iterator(boost::begin(geometry::interior_rings(polygon)), + boost::end(geometry::interior_rings(polygon)) + ) + ); + } +}; + + +template +struct segments_begin +{ + typedef typename segment_iterator_type::type result_type; + + static inline result_type apply(MultiLinestring& multilinestring) + { + return result_type(boost::begin(multilinestring), + boost::end(multilinestring)); + } +}; + + +template +struct segments_begin +{ + typedef typename segment_iterator_type::type result_type; + + static inline result_type apply(MultiPolygon& multipolygon) + { + return result_type(boost::begin(multipolygon), + boost::end(multipolygon)); + } +}; + + +} // namespace dispatch +#endif // DOXYGEN_NO_DISPATCH + + + + + +#ifndef DOXYGEN_NO_DISPATCH +namespace dispatch +{ + + +// specializations for points_end + + +template +struct segments_end +{ + typedef typename segment_iterator_type::type result_type; + + static inline result_type apply(Linestring& linestring) + { + return result_type(linestring, true); + } +}; + + +template +struct segments_end +{ + typedef typename segment_iterator_type::type result_type; + + static inline result_type apply(Ring& ring) + { + return result_type(ring, true); + } +}; + + +template +struct segments_end +{ + typedef typename detail_dispatch::point_iterator_inner_range_type + < + Polygon + >::type inner_range; + + typedef typename segment_iterator_type::type return_type; + + static inline return_type apply(Polygon& polygon) + { + typedef typename return_type::second_iterator_type flatten_iterator; + + return return_type + (segments_end::apply(geometry::exterior_ring(polygon)), + flatten_iterator(boost::begin(geometry::interior_rings(polygon)), + boost::end(geometry::interior_rings(polygon)) + ), + flatten_iterator( boost::end(geometry::interior_rings(polygon)) ) + ); + } +}; + + +template +struct segments_end +{ + typedef typename segment_iterator_type::type result_type; + + static inline result_type apply(MultiLinestring& multilinestring) + { + return result_type(boost::end(multilinestring)); + } +}; + + +template +struct segments_end +{ + typedef typename segment_iterator_type::type result_type; + static inline result_type apply(MultiPolygon& multipolygon) + { + return result_type(boost::end(multipolygon)); + } +}; + + +} // namespace dispatch +#endif // DOXYGEN_NO_DISPATCH + + +// MK:: need to add doc here +template +class segment_iterator + : public dispatch::segment_iterator_type::type +{ +private: + typedef typename dispatch::segment_iterator_type::type base; + + base const* base_ptr() const + { + return this; + } + + template friend class segment_iterator; + + template + friend inline segment_iterator segments_begin(G const&); + + template + friend inline segment_iterator segments_end(G const&); + + segment_iterator(base const& base_it) : base(base_it) {} + +public: + segment_iterator() {} + + template + segment_iterator(segment_iterator const& other) + : base(*other.base_ptr()) + { + static const bool is_conv + = boost::is_convertible< + typename dispatch::segment_iterator_type + < + OtherGeometry const + >::type, + typename dispatch::segment_iterator_type::type + >::value; + + BOOST_MPL_ASSERT_MSG((is_conv), + NOT_CONVERTIBLE, + (segment_iterator)); + } +}; + + +// MK:: need to add doc here +template +inline segment_iterator +segments_begin(Geometry const& geometry) +{ + return dispatch::segments_begin::apply(geometry); +} + + +// MK:: need to add doc here +template +inline segment_iterator +segments_end(Geometry const& geometry) +{ + return dispatch::segments_end::apply(geometry); +} + + +}} // namespace boost::geometry + +#endif // BOOST_GEOMETRY_ITERATORS_SEGMENT_ITERATOR_HPP From 80b5e6700f8b806ed16569c845ee3342e1e1b1f9 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Wed, 24 Sep 2014 08:50:48 +0300 Subject: [PATCH 11/34] [test][iterators][segment_iterator] add unit test for the segment_iterator --- test/iterators/segment_iterator.cpp | 404 ++++++++++++++++++++++++++++ 1 file changed, 404 insertions(+) create mode 100644 test/iterators/segment_iterator.cpp diff --git a/test/iterators/segment_iterator.cpp b/test/iterators/segment_iterator.cpp new file mode 100644 index 000000000..a651db4f5 --- /dev/null +++ b/test/iterators/segment_iterator.cpp @@ -0,0 +1,404 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) +// Unit Test + +// Copyright (c) 2014, Oracle and/or its affiliates. + +// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle + +// Licensed under the Boost Software License version 1.0. +// http://www.boost.org/users/license.html + + +#ifndef BOOST_TEST_MODULE +#define BOOST_TEST_MODULE test_segment_iterator +#endif + +#include +#include +#include +#include + +#include + +#include + +#include + +#include +#include +#include +#include + +#include +#include + +#include + +#include +#include +#include + +#include + +#include + + +namespace ba = ::boost::assign; +namespace bg = ::boost::geometry; +namespace bgm = bg::model; + +typedef bgm::point point_type; +typedef bgm::linestring linestring_type; +typedef bgm::ring ring_cw_closed_type; +typedef bgm::ring ring_cw_open_type; +typedef bgm::polygon polygon_cw_closed_type; +typedef bgm::polygon polygon_cw_open_type; + +// multi-geometries +typedef bgm::multi_linestring multi_linestring_type; +typedef bgm::multi_polygon multi_polygon_cw_closed_type; +typedef bgm::multi_polygon multi_polygon_cw_open_type; + +// tuple-based geometries +typedef boost::tuple tuple_point_type; +typedef std::vector tuple_linestring_type; +typedef std::vector tuple_multi_linestring_type; + +BOOST_GEOMETRY_REGISTER_BOOST_TUPLE_CS(cs::cartesian) +BOOST_GEOMETRY_REGISTER_LINESTRING(tuple_linestring_type) +BOOST_GEOMETRY_REGISTER_MULTI_LINESTRING(tuple_multi_linestring_type) + +template +inline Geometry from_wkt(std::string const& wkt) +{ + Geometry geometry; + boost::geometry::read_wkt(wkt, geometry); + return geometry; +} + +template +inline std::ostream& print_geometry_range(std::ostream& os, + Iterator first, + Iterator beyond, + std::string const& header) +{ + os << header << "("; + for (Iterator it = first; it != beyond; ++it) + { + os << " " << bg::dsv(*it); + } + os << " )"; + return os; +} + +struct equals +{ + template + static inline std::size_t number_of_elements(Iterator begin, + Iterator end) + { + std::size_t size = std::distance(begin, end); + + std::size_t num_elems(0); + for (Iterator it = begin; it != end; ++it) + { + ++num_elems; + } + BOOST_CHECK( size == num_elems ); + + num_elems = 0; + for (Iterator it = end; it != begin; --it) + { + ++num_elems; + } + BOOST_CHECK( size == num_elems ); + + return num_elems; + } + + template + static inline bool apply(Iterator1 begin1, Iterator1 end1, + Iterator2 begin2, Iterator2 end2) + { + std::size_t num_points1 = number_of_elements(begin1, end1); + std::size_t num_points2 = number_of_elements(begin2, end2); + + if ( num_points1 != num_points2 ) + { + return false; + } + + Iterator1 it1 = begin1; + Iterator2 it2 = begin2; + for (; it1 != end1; ++it1, ++it2) + { + if ( !bg::equals(*it1, *it2) ) + { + return false; + } + } + return true; + } +}; + + +template +struct test_segment_iterator_of_geometry +{ + template + static inline void base_test(G const& geometry, + SegmentRange const& segment_range, + std::string const& header) + { + typedef bg::segment_iterator segment_iterator; + + segment_iterator begin = bg::segments_begin(geometry); + segment_iterator end = bg::segments_end(geometry); + + BOOST_CHECK( std::distance(begin, end) == bg::num_segments(geometry) ); + + BOOST_CHECK( equals::apply(begin, end, + bg::segments_begin(segment_range), + bg::segments_end(segment_range)) + ); + +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::string closure + = ( + (bg::closure::value == bg::closed) + ? "closed" + : "open" + ); + + std::cout << header << " geometry (WKT): " + << bg::wkt(geometry) << std::endl; + std::cout << header << " geometry (DSV): " + << bg::dsv(geometry) << std::endl; + std::cout << "geometry's closure: " << closure << std::endl; + print_geometry_range(std::cout, begin, end, "segment range: "); + std::cout << std::endl; + + typedef bg::segment_iterator segment_range_iterator; + + print_geometry_range(std::cout, + bg::segments_begin(segment_range), + bg::segments_end(segment_range), + "expected segment range: "); + std::cout << std::endl; +#endif + } + + static inline void apply(Geometry geometry, + SegmentRange const& segment_range) + { + base_test(geometry, segment_range, "const"); + + // testing dereferencing + typedef typename std::iterator_traits + < + bg::segment_iterator + >::value_type value_type; + + value_type first_segment = *bg::segments_begin(geometry); + +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::cout << "first segment in geometry: " + << bg::wkt(first_segment) + << std::endl; + + std::cout << std::endl << std::endl; +#endif + } +}; + +//====================================================================== +//====================================================================== + +template +struct dual_tester +{ + template + static inline void apply(OpenGeometry const& open_g, + ExpectedResult expected) + { + typedef test_segment_iterator_of_geometry + < + OpenGeometry, ExpectedResult + > otester; + + typedef test_segment_iterator_of_geometry + < + ClosedGeometry, ExpectedResult + > ctester; + + otester::apply(open_g, expected); + +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::cout << std::endl << std::endl; +#endif + + ClosedGeometry closed_g; + + bg::convert(open_g, closed_g); + + ctester::apply(closed_g, expected); + } +}; + +//====================================================================== +//====================================================================== + +BOOST_AUTO_TEST_CASE( test_linestring_segment_iterator ) +{ +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::cout << "*** LINESTRING ***" << std::endl; +#endif + + typedef tuple_multi_linestring_type TML; + typedef linestring_type G; + + typedef test_segment_iterator_of_geometry tester; + + tester::apply(from_wkt("LINESTRING(0 0,1 1,2 2,3 3,4 4)"), + ba::list_of + ( ba::tuple_list_of(0,0)(1,1) ) + ( ba::tuple_list_of(1,1)(2,2) ) + ( ba::tuple_list_of(2,2)(3,3) ) + ( ba::tuple_list_of(3,3)(4,4) ) + ); + +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::cout << std::endl << std::endl << std::endl; +#endif +} + +//====================================================================== +//====================================================================== + +BOOST_AUTO_TEST_CASE( test_ring_segment_iterator ) +{ +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::cout << "*** RING ***" << std::endl; +#endif + + typedef tuple_multi_linestring_type TML; + typedef ring_cw_open_type OG; + typedef ring_cw_closed_type CG; + + typedef dual_tester tester; + + tester::apply(from_wkt("POLYGON((0 0,0 10,10 10,10 0))"), + ba::list_of + ( ba::tuple_list_of(0,0)(0,10) ) + ( ba::tuple_list_of(0,10)(10,10) ) + ( ba::tuple_list_of(10,10)(10,0) ) + ( ba::tuple_list_of(10,0)(0,0) ) + ); + +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::cout << std::endl << std::endl << std::endl; +#endif +} + +//====================================================================== +//====================================================================== + +BOOST_AUTO_TEST_CASE( test_polygon_segment_iterator ) +{ +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::cout << "*** POLYGON ***" << std::endl; +#endif + + typedef tuple_multi_linestring_type TML; + typedef polygon_cw_open_type OG; + typedef polygon_cw_closed_type CG; + + typedef dual_tester tester; + + tester::apply(from_wkt("POLYGON((0 0,0 10,10 10,10 0),(1 1,9 1,9 9,1 9))"), + ba::list_of + ( ba::tuple_list_of(0,0)(0,10) ) + ( ba::tuple_list_of(0,10)(10,10) ) + ( ba::tuple_list_of(10,10)(10,0) ) + ( ba::tuple_list_of(10,0)(0,0) ) + ( ba::tuple_list_of(1,1)(9,1) ) + ( ba::tuple_list_of(9,1)(9,9) ) + ( ba::tuple_list_of(9,9)(1,9) ) + ( ba::tuple_list_of(1,9)(1,1) ) + ); + +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::cout << std::endl << std::endl << std::endl; +#endif +} + +//====================================================================== +//====================================================================== + +BOOST_AUTO_TEST_CASE( test_multi_linestring_segment_iterator ) +{ +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::cout << "*** MULTILINESTRING ***" << std::endl; +#endif + + typedef tuple_multi_linestring_type TML; + typedef multi_linestring_type G; + + typedef test_segment_iterator_of_geometry tester; + + tester::apply(from_wkt("MULTILINESTRING((0 0,1 1,2 2,3 3,4 4),(5 5,6 6,7 7,8 8),(9 9,10 10))"), + ba::list_of + ( ba::tuple_list_of(0,0)(1,1) ) + ( ba::tuple_list_of(1,1)(2,2) ) + ( ba::tuple_list_of(2,2)(3,3) ) + ( ba::tuple_list_of(3,3)(4,4) ) + ( ba::tuple_list_of(5,5)(6,6) ) + ( ba::tuple_list_of(6,6)(7,7) ) + ( ba::tuple_list_of(7,7)(8,8) ) + ( ba::tuple_list_of(9,9)(10,10) ) + ); + +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::cout << std::endl << std::endl << std::endl; +#endif +} + +//====================================================================== +//====================================================================== + +BOOST_AUTO_TEST_CASE( test_multi_polygon_segment_iterator ) +{ +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::cout << "*** MULTIPOLYGON ***" << std::endl; +#endif + + typedef tuple_multi_linestring_type TML; + typedef multi_polygon_cw_open_type OG; + typedef multi_polygon_cw_closed_type CG; + + typedef dual_tester tester; + + tester::apply(from_wkt("MULTIPOLYGON(((0 0,0 10,10 10,10 0),(1 1,9 1,9 9,1 9)),((20 0,20 10,30 10,30 0),(21 1,29 1,29 9,21 9)))"), + ba::list_of + ( ba::tuple_list_of(0,0)(0,10) ) + ( ba::tuple_list_of(0,10)(10,10) ) + ( ba::tuple_list_of(10,10)(10,0) ) + ( ba::tuple_list_of(10,0)(0,0) ) + ( ba::tuple_list_of(1,1)(9,1) ) + ( ba::tuple_list_of(9,1)(9,9) ) + ( ba::tuple_list_of(9,9)(1,9) ) + ( ba::tuple_list_of(1,9)(1,1) ) + ( ba::tuple_list_of(20,0)(20,10) ) + ( ba::tuple_list_of(20,10)(30,10) ) + ( ba::tuple_list_of(30,10)(30,0) ) + ( ba::tuple_list_of(30,0)(20,0) ) + ( ba::tuple_list_of(21,1)(29,1) ) + ( ba::tuple_list_of(29,1)(29,9) ) + ( ba::tuple_list_of(29,9)(21,9) ) + ( ba::tuple_list_of(21,9)(21,1) ) + ); + +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::cout << std::endl << std::endl << std::endl; +#endif +} From 08c0eee65f51909c70e02961d115f066c04cec5d Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Wed, 24 Sep 2014 08:51:51 +0300 Subject: [PATCH 12/34] [test][iterators] add the unit test for segment_iterator in the Jamfile; re-arrange the unit tests in the iterators' Jamfile in alphabetical ordering; --- test/iterators/Jamfile.v2 | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/test/iterators/Jamfile.v2 b/test/iterators/Jamfile.v2 index 40273145d..1f760858c 100644 --- a/test/iterators/Jamfile.v2 +++ b/test/iterators/Jamfile.v2 @@ -16,8 +16,9 @@ test-suite boost-geometry-iterators : [ run closing_iterator.cpp ] - [ run ever_circling_iterator.cpp ] - [ run point_iterator.cpp ] [ run concatenate_iterator.cpp ] + [ run ever_circling_iterator.cpp ] [ run flatten_iterator.cpp ] + [ run point_iterator.cpp ] + [ run segment_iterator.cpp ] ; From 039f8f7a488ec4dc6f0e53b24802849d219453f3 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Fri, 26 Sep 2014 09:41:31 +0300 Subject: [PATCH 13/34] [algorithms][turns] add missing include that causes compilation error when -DBOOST_GEOMETRY_TEST_DEBUG is defined, and re-arrange order of includes --- include/boost/geometry/algorithms/detail/turns/debug_turn.hpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/include/boost/geometry/algorithms/detail/turns/debug_turn.hpp b/include/boost/geometry/algorithms/detail/turns/debug_turn.hpp index 910324c5e..5c4f03277 100644 --- a/include/boost/geometry/algorithms/detail/turns/debug_turn.hpp +++ b/include/boost/geometry/algorithms/detail/turns/debug_turn.hpp @@ -14,8 +14,10 @@ #include #include -#include #include + +#include +#include #endif // BOOST_GEOMETRY_DEBUG_TURNS From 333ef4bbbac956f097b6375272afd813d5fe66db Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Fri, 26 Sep 2014 10:05:54 +0300 Subject: [PATCH 14/34] [test][iterators][segment_iterator] re-arrange the test code; add test with std::copy algorithm: use the segment iterator to copy the segments of a geometry into a vector; --- test/iterators/segment_iterator.cpp | 33 +++++++++++++++++++++-------- 1 file changed, 24 insertions(+), 9 deletions(-) diff --git a/test/iterators/segment_iterator.cpp b/test/iterators/segment_iterator.cpp index a651db4f5..1dce3a589 100644 --- a/test/iterators/segment_iterator.cpp +++ b/test/iterators/segment_iterator.cpp @@ -13,6 +13,7 @@ #define BOOST_TEST_MODULE test_segment_iterator #endif +#include #include #include #include @@ -22,6 +23,8 @@ #include +#include + #include #include @@ -176,9 +179,8 @@ struct test_segment_iterator_of_geometry << bg::dsv(geometry) << std::endl; std::cout << "geometry's closure: " << closure << std::endl; print_geometry_range(std::cout, begin, end, "segment range: "); - std::cout << std::endl; - typedef bg::segment_iterator segment_range_iterator; + std::cout << std::endl; print_geometry_range(std::cout, bg::segments_begin(segment_range), @@ -186,21 +188,17 @@ struct test_segment_iterator_of_geometry "expected segment range: "); std::cout << std::endl; #endif - } - - static inline void apply(Geometry geometry, - SegmentRange const& segment_range) - { - base_test(geometry, segment_range, "const"); // testing dereferencing typedef typename std::iterator_traits < - bg::segment_iterator + segment_iterator >::value_type value_type; value_type first_segment = *bg::segments_begin(geometry); + boost::ignore_unused(first_segment); + #ifdef BOOST_GEOMETRY_TEST_DEBUG std::cout << "first segment in geometry: " << bg::wkt(first_segment) @@ -208,6 +206,23 @@ struct test_segment_iterator_of_geometry std::cout << std::endl << std::endl; #endif + + // test copying all segments to a vector + std::vector segments; + std::copy(bg::segments_begin(geometry), + bg::segments_end(geometry), + std::back_inserter(segments)); + + BOOST_CHECK( std::distance(bg::segments_begin(geometry), + bg::segments_end(geometry)) + == + segments.size() ); + } + + static inline void apply(Geometry geometry, + SegmentRange const& segment_range) + { + base_test(geometry, segment_range, "const"); } }; From 8fc8bd9773c2551ffafc2c613d915269dfba4108 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Fri, 26 Sep 2014 10:07:20 +0300 Subject: [PATCH 15/34] [geometries][pointing_segment] introduce a new segment class called pointing segment; this segment is default constructible, copy constructible and assignable; it stores pointers to points instead of the points themselves (for efficiency); this segment class is meant to be the value type of the segment iterator; --- .../geometry/geometries/pointing_segment.hpp | 148 ++++++++++++++++++ 1 file changed, 148 insertions(+) create mode 100644 include/boost/geometry/geometries/pointing_segment.hpp diff --git a/include/boost/geometry/geometries/pointing_segment.hpp b/include/boost/geometry/geometries/pointing_segment.hpp new file mode 100644 index 000000000..771010c48 --- /dev/null +++ b/include/boost/geometry/geometries/pointing_segment.hpp @@ -0,0 +1,148 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2014, Oracle and/or its affiliates. + +// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle + +// Licensed under the Boost Software License version 1.0. +// http://www.boost.org/users/license.html + +#ifndef BOOST_GEOMETRY_GEOMETRIES_POINTING_SEGMENT_HPP +#define BOOST_GEOMETRY_GEOMETRIES_POINTING_SEGMENT_HPP + +#include + +#include +#include +#include +#include + +#include + +#include +#include + + +namespace boost { namespace geometry +{ + +namespace model +{ + +// const or non-const segment type that is meant to be +// * default constructible +// * copy constructible +// * assignable +// referring_segment does not fit these requirements, hence the +// pointing_segment class +// +// this class is used by the segment_iterator as its value type +template +class pointing_segment +{ + BOOST_CONCEPT_ASSERT( ( + typename boost::mpl::if_ + < + boost::is_const, + concept::Point, + concept::ConstPoint + > + ) ); + + typedef ConstOrNonConstPoint point_type; + +public: + point_type* first; + point_type* second; + + inline pointing_segment() + {} + + inline pointing_segment(point_type const& p1, point_type const& p2) + : first(boost::addressof(p1)) + , second(boost::addressof(p2)) + {} + + inline pointing_segment(pointing_segment const& other) + : first(other.first) + , second(other.second) + {} + + inline pointing_segment& operator=(pointing_segment const& other) + { + first = other.first; + second = other.second; + return *this; + } +}; + + +} // namespace model + + +// Traits specializations for segment above +#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS +namespace traits +{ + +template +struct tag > +{ + typedef segment_tag type; +}; + +template +struct point_type > +{ + typedef Point type; +}; + +template +struct indexed_access, 0, Dimension> +{ + typedef model::pointing_segment segment_type; + typedef typename geometry::coordinate_type + < + segment_type + >::type coordinate_type; + + static inline coordinate_type get(segment_type const& s) + { + return geometry::get(*s.first); + } + + static inline void set(segment_type& s, coordinate_type const& value) + { + geometry::set(*s.first, value); + } +}; + + +template +struct indexed_access, 1, Dimension> +{ + typedef model::pointing_segment segment_type; + typedef typename geometry::coordinate_type + < + segment_type + >::type coordinate_type; + + static inline coordinate_type get(segment_type const& s) + { + return geometry::get(*s.second); + } + + static inline void set(segment_type& s, coordinate_type const& value) + { + geometry::set(*s.second, value); + } +}; + + + +} // namespace traits +#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS + +}} // namespace boost::geometry + +#endif // BOOST_GEOMETRY_GEOMETRIES_POINTING_SEGMENT_HPP From 6388a43089f13346b3e90ec342dcd7266cd8c900 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Fri, 26 Sep 2014 11:41:20 +0300 Subject: [PATCH 16/34] [iterators][segment_iterator] change the value type of the segment iterator from referring_segment to pointing_segment --- include/boost/geometry/iterators/segment_iterator_type.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/boost/geometry/iterators/segment_iterator_type.hpp b/include/boost/geometry/iterators/segment_iterator_type.hpp index 7ff62e1e2..7b531d31b 100644 --- a/include/boost/geometry/iterators/segment_iterator_type.hpp +++ b/include/boost/geometry/iterators/segment_iterator_type.hpp @@ -22,7 +22,7 @@ #include #include -#include +#include #include #include @@ -40,7 +40,7 @@ struct segment_iterator_value_type Geometry >::type point_iterator_value_type; - typedef geometry::model::referring_segment + typedef geometry::model::pointing_segment < point_iterator_value_type > type; From bffac4a108a018f485028e93aa1f9c0b316d368b Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Sat, 27 Sep 2014 14:04:35 +0300 Subject: [PATCH 17/34] [geometries][pointing_segment] initialize member variables in default constructor with NULL; in get/set access methods check that the pointers of the segment are not NULL (via assertion); remove copy constructor and assignment operator: they are the same as those the compiler would produce automatically; --- .../geometry/geometries/pointing_segment.hpp | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-) diff --git a/include/boost/geometry/geometries/pointing_segment.hpp b/include/boost/geometry/geometries/pointing_segment.hpp index 771010c48..681752ef2 100644 --- a/include/boost/geometry/geometries/pointing_segment.hpp +++ b/include/boost/geometry/geometries/pointing_segment.hpp @@ -12,6 +12,7 @@ #include +#include #include #include #include @@ -56,24 +57,14 @@ public: point_type* second; inline pointing_segment() + : first(NULL) + , second(NULL) {} inline pointing_segment(point_type const& p1, point_type const& p2) : first(boost::addressof(p1)) , second(boost::addressof(p2)) {} - - inline pointing_segment(pointing_segment const& other) - : first(other.first) - , second(other.second) - {} - - inline pointing_segment& operator=(pointing_segment const& other) - { - first = other.first; - second = other.second; - return *this; - } }; @@ -108,11 +99,13 @@ struct indexed_access, 0, Dimension> static inline coordinate_type get(segment_type const& s) { + BOOST_ASSERT( s.first != NULL ); return geometry::get(*s.first); } static inline void set(segment_type& s, coordinate_type const& value) { + BOOST_ASSERT( s.first != NULL ); geometry::set(*s.first, value); } }; @@ -129,11 +122,13 @@ struct indexed_access, 1, Dimension> static inline coordinate_type get(segment_type const& s) { + BOOST_ASSERT( s.second != NULL ); return geometry::get(*s.second); } static inline void set(segment_type& s, coordinate_type const& value) { + BOOST_ASSERT( s.second != NULL ); geometry::set(*s.second, value); } }; From 84b54af2053973cc7d5abec63e203d9ad18b0436 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Mon, 29 Sep 2014 17:05:35 +0300 Subject: [PATCH 18/34] [iterators][segment_iterator] correct comments --- .../{ => detail/segment_iterator}/range_segment_iterator.hpp | 0 .../boost/geometry/iterators/dispatch/segment_iterator.hpp | 4 ++-- 2 files changed, 2 insertions(+), 2 deletions(-) rename include/boost/geometry/iterators/{ => detail/segment_iterator}/range_segment_iterator.hpp (100%) diff --git a/include/boost/geometry/iterators/range_segment_iterator.hpp b/include/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp similarity index 100% rename from include/boost/geometry/iterators/range_segment_iterator.hpp rename to include/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp diff --git a/include/boost/geometry/iterators/dispatch/segment_iterator.hpp b/include/boost/geometry/iterators/dispatch/segment_iterator.hpp index 3c50c7a20..0c0a1b09a 100644 --- a/include/boost/geometry/iterators/dispatch/segment_iterator.hpp +++ b/include/boost/geometry/iterators/dispatch/segment_iterator.hpp @@ -22,7 +22,7 @@ namespace dispatch { -// dispatch for points_begin +// dispatch for segments_begin template ::type> struct segments_begin : not_implemented @@ -30,7 +30,7 @@ struct segments_begin -// dispatch for points_end +// dispatch for segments_end template ::type> struct segments_end : not_implemented From 2a0dceece9b167963a465dd2967660049b2c6be1 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Mon, 29 Sep 2014 17:06:41 +0300 Subject: [PATCH 19/34] [iterators][segment_iterator] correct comments; fix code length to be at most 80 characters; --- .../geometry/iterators/segment_iterator.hpp | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/include/boost/geometry/iterators/segment_iterator.hpp b/include/boost/geometry/iterators/segment_iterator.hpp index e9747d55b..5dbbab887 100644 --- a/include/boost/geometry/iterators/segment_iterator.hpp +++ b/include/boost/geometry/iterators/segment_iterator.hpp @@ -33,7 +33,7 @@ namespace dispatch { -// specializations for points_begin +// specializations for segments_begin template @@ -79,7 +79,10 @@ struct segments_begin < inner_range >::apply(geometry::exterior_ring(polygon)), - segments_end::apply(geometry::exterior_ring(polygon)), + segments_end + < + inner_range + >::apply(geometry::exterior_ring(polygon)), flatten_iterator(boost::begin(geometry::interior_rings(polygon)), boost::end(geometry::interior_rings(polygon)) ), @@ -129,7 +132,7 @@ namespace dispatch { -// specializations for points_end +// specializations for segments_end template @@ -171,7 +174,10 @@ struct segments_end typedef typename return_type::second_iterator_type flatten_iterator; return return_type - (segments_end::apply(geometry::exterior_ring(polygon)), + (segments_end + < + inner_range + >::apply(geometry::exterior_ring(polygon)), flatten_iterator(boost::begin(geometry::interior_rings(polygon)), boost::end(geometry::interior_rings(polygon)) ), @@ -214,7 +220,10 @@ class segment_iterator : public dispatch::segment_iterator_type::type { private: - typedef typename dispatch::segment_iterator_type::type base; + typedef typename dispatch::segment_iterator_type + < + Geometry const + >::type base; base const* base_ptr() const { From 67e418e705efa5704ae4447cd68f19613e5fbb53 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Mon, 29 Sep 2014 17:10:24 +0300 Subject: [PATCH 20/34] [iterators][segment_iterator] move range_segment_iterator class to detail::segment_iterator namespace; move bg::segment_iterator_value_type to bg::detail::segment_iterator::value_type; --- .../range_segment_iterator.hpp | 28 +++++++- .../detail/segment_iterator/value_type.hpp | 43 +++++++++++++ .../iterators/segment_iterator_type.hpp | 64 +++++++++---------- 3 files changed, 99 insertions(+), 36 deletions(-) create mode 100644 include/boost/geometry/iterators/detail/segment_iterator/value_type.hpp diff --git a/include/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp b/include/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp index 2d6320c03..40ac68dba 100644 --- a/include/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp +++ b/include/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp @@ -24,6 +24,10 @@ namespace boost { namespace geometry { +#ifndef DOXYGEN_NO_DETAIL +namespace detail { namespace segment_iterator +{ + template ::value> struct range_iterator_type @@ -114,7 +118,12 @@ public: : m_it(--range_iterator_end::apply(r)) {} - template + template + < + typename OtherRange, + typename OtherValue, + typename OtherReference + > range_segment_iterator(range_segment_iterator < OtherRange, @@ -134,7 +143,12 @@ public: BOOST_MPL_ASSERT_MSG((are_conv), NOT_CONVERTIBLE, (types)); } - template + template + < + typename OtherRange, + typename OtherValue, + typename OtherReference + > range_segment_iterator operator=(range_segment_iterator < OtherRange, @@ -169,7 +183,12 @@ private: return Reference(*m_it, *next); } - template + template + < + typename OtherRange, + typename OtherValue, + typename OtherReference + > inline bool equal(range_segment_iterator < OtherRange, @@ -195,6 +214,9 @@ private: }; +}} // namespace detail::segment_iterator +#endif // DOXYGEN_NO_DETAIL + }} // namespace boost::geometry diff --git a/include/boost/geometry/iterators/detail/segment_iterator/value_type.hpp b/include/boost/geometry/iterators/detail/segment_iterator/value_type.hpp new file mode 100644 index 000000000..6b11aa37c --- /dev/null +++ b/include/boost/geometry/iterators/detail/segment_iterator/value_type.hpp @@ -0,0 +1,43 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2014, Oracle and/or its affiliates. + +// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle + +// Licensed under the Boost Software License version 1.0. +// http://www.boost.org/users/license.html + +#ifndef BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_VALUE_TYPE_HPP +#define BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_VALUE_TYPE_HPP + +#include +#include + + +namespace boost { namespace geometry +{ + +#ifndef DOXYGEN_NO_DETAIL +namespace detail { namespace segment_iterator +{ + +template +struct value_type +{ + typedef typename detail_dispatch::point_iterator_value_type + < + Geometry + >::type point_iterator_value_type; + + typedef geometry::model::pointing_segment + < + point_iterator_value_type + > type; +}; + +}} // namespace detail::segment_iterator +#endif // DOXYGEN_NO_DETAIL + +}} // namespace boost::geometry + +#endif // BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_VALUE_TYPE_HPP diff --git a/include/boost/geometry/iterators/segment_iterator_type.hpp b/include/boost/geometry/iterators/segment_iterator_type.hpp index 7b531d31b..3027a6ee2 100644 --- a/include/boost/geometry/iterators/segment_iterator_type.hpp +++ b/include/boost/geometry/iterators/segment_iterator_type.hpp @@ -20,7 +20,8 @@ #include #include #include -#include +#include +#include #include @@ -31,23 +32,6 @@ namespace boost { namespace geometry { - -template -struct segment_iterator_value_type -{ - typedef typename detail_dispatch::point_iterator_value_type - < - Geometry - >::type point_iterator_value_type; - - typedef geometry::model::pointing_segment - < - point_iterator_value_type - > type; -}; - - - #ifndef DOXYGEN_NO_DISPATCH namespace dispatch { @@ -56,10 +40,10 @@ namespace dispatch template struct segment_iterator_type { - typedef range_segment_iterator + typedef detail::segment_iterator::range_segment_iterator < Linestring, - typename segment_iterator_value_type::type + typename detail::segment_iterator::value_type::type > type; }; @@ -67,10 +51,10 @@ struct segment_iterator_type template struct segment_iterator_type { - typedef range_segment_iterator + typedef detail::segment_iterator::range_segment_iterator < Ring, - typename segment_iterator_value_type::type + typename detail::segment_iterator::value_type::type > type; }; @@ -84,13 +68,17 @@ private: Polygon >::type inner_range; + typedef typename detail::segment_iterator::value_type + < + Polygon + >::type value_type; + public: typedef concatenate_iterator < - range_segment_iterator + detail::segment_iterator::range_segment_iterator < - inner_range, - typename segment_iterator_value_type::type + inner_range, value_type >, flatten_iterator < @@ -99,13 +87,13 @@ public: typename geometry::interior_type::type >::type, typename dispatch::segment_iterator_type::type, - typename segment_iterator_value_type::type, + value_type, dispatch::segments_begin, dispatch::segments_end, - typename segment_iterator_value_type::type + value_type >, - typename segment_iterator_value_type::type, - typename segment_iterator_value_type::type + value_type, + value_type > type; }; @@ -119,15 +107,20 @@ private: MultiLinestring >::type inner_range; + typedef typename detail::segment_iterator::value_type + < + MultiLinestring + >::type value_type; + public: typedef flatten_iterator < typename boost::range_iterator::type, typename dispatch::segment_iterator_type::type, - typename segment_iterator_value_type::type, + value_type, dispatch::segments_begin, dispatch::segments_end, - typename segment_iterator_value_type::type + value_type > type; }; @@ -141,15 +134,20 @@ private: MultiPolygon >::type inner_range; + typedef typename detail::segment_iterator::value_type + < + MultiPolygon + >::type value_type; + public: typedef flatten_iterator < typename boost::range_iterator::type, typename dispatch::segment_iterator_type::type, - typename segment_iterator_value_type::type, + value_type, dispatch::segments_begin, dispatch::segments_end, - typename segment_iterator_value_type::type + value_type > type; }; From 029cb92952d6ad68e769f6c76580c93074b80fde Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Mon, 29 Sep 2014 17:15:23 +0300 Subject: [PATCH 21/34] [iterators][segment_iterator] fix file-inclusion guarding macro to reflect true file path --- .../detail/segment_iterator/range_segment_iterator.hpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/include/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp b/include/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp index 40ac68dba..d79fda84d 100644 --- a/include/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp +++ b/include/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp @@ -7,8 +7,8 @@ // Licensed under the Boost Software License version 1.0. // http://www.boost.org/users/license.html -#ifndef BOOST_GEOMETRY_ITERATORS_RANGE_SEGMENT_ITERATOR_HPP -#define BOOST_GEOMETRY_ITERATORS_RANGE_SEGMENT_ITERATOR_HPP +#ifndef BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_RANGE_SEGMENT_ITERATOR_HPP +#define BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_RANGE_SEGMENT_ITERATOR_HPP #include #include @@ -220,4 +220,4 @@ private: }} // namespace boost::geometry -#endif // BOOST_GEOMETRY_ITERATORS_RANGE_SEGMENT_ITERATOR_HPP +#endif // BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_RANGE_SEGMENT_ITERATOR_HPP From 404ca1cbe678c3a7b70ab94bb68bb1afdf8e3ed4 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Tue, 30 Sep 2014 09:49:26 +0300 Subject: [PATCH 22/34] [iterators][segment_iterator] move implementation of bg::segment_iterator_type to bg::detail::segment_iterator namespace; rename the class segment_iterator_type to iterator_type; --- .../segment_iterator/iterator_type.hpp} | 90 +++++++++---------- .../dispatch/segment_iterator_type.hpp | 37 -------- 2 files changed, 40 insertions(+), 87 deletions(-) rename include/boost/geometry/iterators/{segment_iterator_type.hpp => detail/segment_iterator/iterator_type.hpp} (57%) delete mode 100644 include/boost/geometry/iterators/dispatch/segment_iterator_type.hpp diff --git a/include/boost/geometry/iterators/segment_iterator_type.hpp b/include/boost/geometry/iterators/detail/segment_iterator/iterator_type.hpp similarity index 57% rename from include/boost/geometry/iterators/segment_iterator_type.hpp rename to include/boost/geometry/iterators/detail/segment_iterator/iterator_type.hpp index 3027a6ee2..885c5f644 100644 --- a/include/boost/geometry/iterators/segment_iterator_type.hpp +++ b/include/boost/geometry/iterators/detail/segment_iterator/iterator_type.hpp @@ -7,60 +7,65 @@ // Licensed under the Boost Software License version 1.0. // http://www.boost.org/users/license.html -#ifndef BOOST_GEOMETRY_ITERATORS_SEGMENT_ITERATOR_TYPE_HPP -#define BOOST_GEOMETRY_ITERATORS_SEGMENT_ITERATOR_TYPE_HPP +#ifndef BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_ITERATOR_TYPE_HPP +#define BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_ITERATOR_TYPE_HPP #include #include #include #include +#include #include +#include + #include #include #include + #include #include -#include - -#include #include namespace boost { namespace geometry { -#ifndef DOXYGEN_NO_DISPATCH -namespace dispatch +#ifndef DOXYGEN_NO_DETAIL +namespace detail { namespace segment_iterator { +template ::type> +struct iterator_type + : not_implemented +{}; + + template -struct segment_iterator_type +struct iterator_type { - typedef detail::segment_iterator::range_segment_iterator + typedef range_segment_iterator < - Linestring, - typename detail::segment_iterator::value_type::type + Linestring, typename value_type::type > type; }; template -struct segment_iterator_type +struct iterator_type { - typedef detail::segment_iterator::range_segment_iterator + typedef range_segment_iterator < - Ring, - typename detail::segment_iterator::value_type::type + Ring, typename value_type::type > type; }; template -class segment_iterator_type +class iterator_type { private: typedef typename detail_dispatch::point_iterator_inner_range_type @@ -68,17 +73,13 @@ private: Polygon >::type inner_range; - typedef typename detail::segment_iterator::value_type - < - Polygon - >::type value_type; - public: typedef concatenate_iterator < - detail::segment_iterator::range_segment_iterator + range_segment_iterator < - inner_range, value_type + inner_range, + typename value_type::type >, flatten_iterator < @@ -86,20 +87,20 @@ public: < typename geometry::interior_type::type >::type, - typename dispatch::segment_iterator_type::type, - value_type, + typename iterator_type::type, + typename value_type::type, dispatch::segments_begin, dispatch::segments_end, - value_type + typename value_type::type >, - value_type, - value_type + typename value_type::type, + typename value_type::type > type; }; template -class segment_iterator_type +class iterator_type { private: typedef typename detail_dispatch::point_iterator_inner_range_type @@ -107,57 +108,46 @@ private: MultiLinestring >::type inner_range; - typedef typename detail::segment_iterator::value_type - < - MultiLinestring - >::type value_type; - public: typedef flatten_iterator < typename boost::range_iterator::type, - typename dispatch::segment_iterator_type::type, - value_type, + typename iterator_type::type, + typename value_type::type, dispatch::segments_begin, dispatch::segments_end, - value_type + typename value_type::type > type; }; template -class segment_iterator_type +class iterator_type { private: typedef typename detail_dispatch::point_iterator_inner_range_type < MultiPolygon >::type inner_range; - - typedef typename detail::segment_iterator::value_type - < - MultiPolygon - >::type value_type; - public: typedef flatten_iterator < typename boost::range_iterator::type, - typename dispatch::segment_iterator_type::type, - value_type, + typename iterator_type::type, + typename value_type::type, dispatch::segments_begin, dispatch::segments_end, - value_type + typename value_type::type > type; }; -} // namespace dispatch -#endif // DOXYGEN_NO_DISPATCH +}} // namespace detail::segment_iterator +#endif // DOXYGEN_NO_DETAIL }} // namespace boost::geometry -#endif // BOOST_GEOMETRY_ITERATORS_SEGMENT_ITERATOR_TYPE_HPP +#endif // BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_ITERATOR_TYPE_HPP diff --git a/include/boost/geometry/iterators/dispatch/segment_iterator_type.hpp b/include/boost/geometry/iterators/dispatch/segment_iterator_type.hpp deleted file mode 100644 index f4817ee42..000000000 --- a/include/boost/geometry/iterators/dispatch/segment_iterator_type.hpp +++ /dev/null @@ -1,37 +0,0 @@ -// Boost.Geometry (aka GGL, Generic Geometry Library) - -// Copyright (c) 2014, Oracle and/or its affiliates. - -// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle - -// Licensed under the Boost Software License version 1.0. -// http://www.boost.org/users/license.html - -#ifndef BOOST_GEOMETRY_ITERATORS_DISPATCH_SEGMENT_ITERATOR_TYPE_HPP -#define BOOST_GEOMETRY_ITERATORS_DISPATCH_SEGMENT_ITERATOR_TYPE_HPP - -#include -#include - -namespace boost { namespace geometry -{ - - -#ifndef DOXYGEN_NO_DISPATCH -namespace dispatch -{ - -template ::type> -struct segment_iterator_type - : not_implemented -{}; - - - -} // namespace dispatch -#endif // DOXYGEN_NO_DISPATCH - - -}} // namespace boost::geometry - -#endif // BOOST_GEOMETRY_ITERATORS_DISPATCH_SEGMENT_ITERATOR_TYPE_HPP From 10ce79898ab9113d513678e3065363248427f9b2 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Tue, 30 Sep 2014 09:50:47 +0300 Subject: [PATCH 23/34] [iterators][segment_iterator] update implementation of segment_iterator due to the change of namespace and name of the segment_iterator_type class; make constructors of bg::segment_iterator class inline; change the return type of segments_begin and segments_end to be segment_iterator; --- .../geometry/iterators/segment_iterator.hpp | 115 +++++++++++------- 1 file changed, 73 insertions(+), 42 deletions(-) diff --git a/include/boost/geometry/iterators/segment_iterator.hpp b/include/boost/geometry/iterators/segment_iterator.hpp index 5dbbab887..5397e4a98 100644 --- a/include/boost/geometry/iterators/segment_iterator.hpp +++ b/include/boost/geometry/iterators/segment_iterator.hpp @@ -19,7 +19,7 @@ #include #include -#include +#include #include @@ -39,11 +39,14 @@ namespace dispatch template struct segments_begin { - typedef typename segment_iterator_type::type result_type; + typedef typename detail::segment_iterator::iterator_type + < + Linestring + >::type return_type; - static inline result_type apply(Linestring& linestring) + static inline return_type apply(Linestring& linestring) { - return result_type(linestring); + return return_type(linestring); } }; @@ -51,11 +54,14 @@ struct segments_begin template struct segments_begin { - typedef typename segment_iterator_type::type result_type; + typedef typename detail::segment_iterator::iterator_type + < + Ring + >::type return_type; - static inline result_type apply(Ring& ring) + static inline return_type apply(Ring& ring) { - return result_type(ring); + return return_type(ring); } }; @@ -68,7 +74,10 @@ struct segments_begin Polygon >::type inner_range; - typedef typename segment_iterator_type::type return_type; + typedef typename detail::segment_iterator::iterator_type + < + Polygon + >::type return_type; static inline return_type apply(Polygon& polygon) { @@ -97,11 +106,14 @@ struct segments_begin template struct segments_begin { - typedef typename segment_iterator_type::type result_type; + typedef typename detail::segment_iterator::iterator_type + < + MultiLinestring + >::type return_type; - static inline result_type apply(MultiLinestring& multilinestring) + static inline return_type apply(MultiLinestring& multilinestring) { - return result_type(boost::begin(multilinestring), + return return_type(boost::begin(multilinestring), boost::end(multilinestring)); } }; @@ -110,11 +122,14 @@ struct segments_begin template struct segments_begin { - typedef typename segment_iterator_type::type result_type; + typedef typename detail::segment_iterator::iterator_type + < + MultiPolygon + >::type return_type; - static inline result_type apply(MultiPolygon& multipolygon) + static inline return_type apply(MultiPolygon& multipolygon) { - return result_type(boost::begin(multipolygon), + return return_type(boost::begin(multipolygon), boost::end(multipolygon)); } }; @@ -138,11 +153,14 @@ namespace dispatch template struct segments_end { - typedef typename segment_iterator_type::type result_type; + typedef typename detail::segment_iterator::iterator_type + < + Linestring + >::type return_type; - static inline result_type apply(Linestring& linestring) + static inline return_type apply(Linestring& linestring) { - return result_type(linestring, true); + return return_type(linestring, true); } }; @@ -150,11 +168,14 @@ struct segments_end template struct segments_end { - typedef typename segment_iterator_type::type result_type; + typedef typename detail::segment_iterator::iterator_type + < + Ring + >::type return_type; - static inline result_type apply(Ring& ring) + static inline return_type apply(Ring& ring) { - return result_type(ring, true); + return return_type(ring, true); } }; @@ -167,7 +188,10 @@ struct segments_end Polygon >::type inner_range; - typedef typename segment_iterator_type::type return_type; + typedef typename detail::segment_iterator::iterator_type + < + Polygon + >::type return_type; static inline return_type apply(Polygon& polygon) { @@ -190,11 +214,14 @@ struct segments_end template struct segments_end { - typedef typename segment_iterator_type::type result_type; + typedef typename detail::segment_iterator::iterator_type + < + MultiLinestring + >::type return_type; - static inline result_type apply(MultiLinestring& multilinestring) + static inline return_type apply(MultiLinestring& multilinestring) { - return result_type(boost::end(multilinestring)); + return return_type(boost::end(multilinestring)); } }; @@ -202,10 +229,14 @@ struct segments_end template struct segments_end { - typedef typename segment_iterator_type::type result_type; - static inline result_type apply(MultiPolygon& multipolygon) + typedef typename detail::segment_iterator::iterator_type + < + MultiPolygon + >::type return_type; + + static inline return_type apply(MultiPolygon& multipolygon) { - return result_type(boost::end(multipolygon)); + return return_type(boost::end(multipolygon)); } }; @@ -217,15 +248,15 @@ struct segments_end // MK:: need to add doc here template class segment_iterator - : public dispatch::segment_iterator_type::type + : public detail::segment_iterator::iterator_type::type { private: - typedef typename dispatch::segment_iterator_type + typedef typename detail::segment_iterator::iterator_type < - Geometry const + Geometry >::type base; - base const* base_ptr() const + inline base const* base_ptr() const { return this; } @@ -233,39 +264,39 @@ private: template friend class segment_iterator; template - friend inline segment_iterator segments_begin(G const&); + friend inline segment_iterator segments_begin(G const&); template - friend inline segment_iterator segments_end(G const&); + friend inline segment_iterator segments_end(G const&); - segment_iterator(base const& base_it) : base(base_it) {} + inline segment_iterator(base const& base_it) : base(base_it) {} public: - segment_iterator() {} + inline segment_iterator() {} template - segment_iterator(segment_iterator const& other) + inline segment_iterator(segment_iterator const& other) : base(*other.base_ptr()) { static const bool is_conv = boost::is_convertible< - typename dispatch::segment_iterator_type + typename detail::segment_iterator::iterator_type < - OtherGeometry const + OtherGeometry >::type, - typename dispatch::segment_iterator_type::type + typename detail::segment_iterator::iterator_type::type >::value; BOOST_MPL_ASSERT_MSG((is_conv), NOT_CONVERTIBLE, - (segment_iterator)); + (segment_iterator)); } }; // MK:: need to add doc here template -inline segment_iterator +inline segment_iterator segments_begin(Geometry const& geometry) { return dispatch::segments_begin::apply(geometry); @@ -274,7 +305,7 @@ segments_begin(Geometry const& geometry) // MK:: need to add doc here template -inline segment_iterator +inline segment_iterator segments_end(Geometry const& geometry) { return dispatch::segments_end::apply(geometry); From 9d75411a90b6c5e167458054ddb2f662d35d0d21 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Tue, 30 Sep 2014 09:53:09 +0300 Subject: [PATCH 24/34] [test][iterators][segment_iterator] change the return type of segments_begin and segments_end to be segment_iterator --- test/iterators/segment_iterator.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/iterators/segment_iterator.cpp b/test/iterators/segment_iterator.cpp index 1dce3a589..eea028465 100644 --- a/test/iterators/segment_iterator.cpp +++ b/test/iterators/segment_iterator.cpp @@ -153,7 +153,7 @@ struct test_segment_iterator_of_geometry SegmentRange const& segment_range, std::string const& header) { - typedef bg::segment_iterator segment_iterator; + typedef bg::segment_iterator segment_iterator; segment_iterator begin = bg::segments_begin(geometry); segment_iterator end = bg::segments_end(geometry); From b9c496a1d82bec8bd81ec267d4559873334d1ecb Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Tue, 30 Sep 2014 15:00:42 +0300 Subject: [PATCH 25/34] [iterators][point_reverse_iterator] mark methods and constructors as inline --- .../boost/geometry/iterators/point_reverse_iterator.hpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/include/boost/geometry/iterators/point_reverse_iterator.hpp b/include/boost/geometry/iterators/point_reverse_iterator.hpp index 5cce66795..1c2ac0169 100644 --- a/include/boost/geometry/iterators/point_reverse_iterator.hpp +++ b/include/boost/geometry/iterators/point_reverse_iterator.hpp @@ -29,12 +29,12 @@ class point_reverse_iterator private: typedef std::reverse_iterator > base; - base* base_ptr() + inline base* base_ptr() { return this; } - base const* base_ptr() const + inline base const* base_ptr() const { return this; } @@ -46,12 +46,13 @@ private: template friend inline point_reverse_iterator points_rend(G&); - point_reverse_iterator(base const& base_it) : base(base_it) {} + inline point_reverse_iterator(base const& base_it) : base(base_it) {} public: - point_reverse_iterator() {} + inline point_reverse_iterator() {} template + inline point_reverse_iterator(point_reverse_iterator const& other) : base(*other.base_ptr()) { From 60f184e3ce63d3de2c6dfa033a7cb4e0f8a7ac27 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Tue, 30 Sep 2014 15:02:20 +0300 Subject: [PATCH 26/34] [iterators][point_iterator] change file/directory structure for point iterator; use detail::point_iterator namespace for the implementation details of the point iterator; --- .../point_iterator/inner_range_type.hpp | 66 ++++++ .../detail/point_iterator/iterator_type.hpp | 136 ++++++++++++ .../detail/point_iterator/value_type.hpp | 47 ++++ .../dispatch/point_iterator_type.hpp | 37 ---- .../geometry/iterators/point_iterator.hpp | 114 ++++++---- .../iterators/point_iterator_type.hpp | 208 ------------------ 6 files changed, 321 insertions(+), 287 deletions(-) create mode 100644 include/boost/geometry/iterators/detail/point_iterator/inner_range_type.hpp create mode 100644 include/boost/geometry/iterators/detail/point_iterator/iterator_type.hpp create mode 100644 include/boost/geometry/iterators/detail/point_iterator/value_type.hpp delete mode 100644 include/boost/geometry/iterators/dispatch/point_iterator_type.hpp delete mode 100644 include/boost/geometry/iterators/point_iterator_type.hpp diff --git a/include/boost/geometry/iterators/detail/point_iterator/inner_range_type.hpp b/include/boost/geometry/iterators/detail/point_iterator/inner_range_type.hpp new file mode 100644 index 000000000..b2239fb8d --- /dev/null +++ b/include/boost/geometry/iterators/detail/point_iterator/inner_range_type.hpp @@ -0,0 +1,66 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2014, Oracle and/or its affiliates. + +// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle + +// Licensed under the Boost Software License version 1.0. +// http://www.boost.org/users/license.html + +#ifndef BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_INNER_RANGE_TYPE_HPP +#define BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_INNER_RANGE_TYPE_HPP + +#include +#include +#include + +#include +#include +#include + + +namespace boost { namespace geometry +{ + + +#ifndef DOXYGEN_NO_DETAIL +namespace detail { namespace point_iterator +{ + + +template +< + typename Geometry, + typename Tag = typename tag::type +> +struct inner_range_type +{ + typedef typename boost::mpl::if_c + < + !boost::is_const::type::value, + typename boost::range_value::type, + typename boost::range_value::type const + >::type type; +}; + + +template +struct inner_range_type +{ + typedef typename boost::mpl::if_c + < + !boost::is_const::type::value, + typename geometry::ring_type::type, + typename geometry::ring_type::type const + >::type type; +}; + + +}} // namespace detail::point_iterator +#endif // DOXYGEN_NO_DETAIL + + +}} // namespace boost::geometry + + +#endif // BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_INNER_RANGE_TYPE_HPP diff --git a/include/boost/geometry/iterators/detail/point_iterator/iterator_type.hpp b/include/boost/geometry/iterators/detail/point_iterator/iterator_type.hpp new file mode 100644 index 000000000..a7805b127 --- /dev/null +++ b/include/boost/geometry/iterators/detail/point_iterator/iterator_type.hpp @@ -0,0 +1,136 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2014, Oracle and/or its affiliates. + +// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle + +// Licensed under the Boost Software License version 1.0. +// http://www.boost.org/users/license.html + +#ifndef BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_ITERATOR_TYPE_HPP +#define BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_ITERATOR_TYPE_HPP + +#include + +#include +#include + +#include + +#include +#include + +#include +#include + +#include + + +namespace boost { namespace geometry +{ + + +#ifndef DOXYGEN_NO_DETAIL +namespace detail { namespace point_iterator +{ + + +template ::type> +struct iterator_type + : not_implemented +{}; + + + + +template +struct iterator_type +{ + typedef typename boost::range_iterator::type type; +}; + + +template +struct iterator_type +{ + typedef typename boost::range_iterator::type type; +}; + + +template +class iterator_type +{ +private: + typedef typename inner_range_type::type inner_range; + +public: + typedef concatenate_iterator + < + typename boost::range_iterator::type, + flatten_iterator + < + typename boost::range_iterator + < + typename geometry::interior_type::type + >::type, + typename iterator_type::type, + typename value_type::type, + dispatch::points_begin, + dispatch::points_end + >, + typename value_type::type + > type; +}; + + +template +struct iterator_type +{ + typedef typename boost::range_iterator::type type; +}; + + +template +class iterator_type +{ +private: + typedef typename inner_range_type::type inner_range; + +public: + typedef flatten_iterator + < + typename boost::range_iterator::type, + typename iterator_type::type, + typename value_type::type, + dispatch::points_begin, + dispatch::points_end + > type; +}; + + +template +class iterator_type +{ +private: + typedef typename inner_range_type::type inner_range; + +public: + typedef flatten_iterator + < + typename boost::range_iterator::type, + typename iterator_type::type, + typename value_type::type, + dispatch::points_begin, + dispatch::points_end + > type; +}; + + +}} // namespace detail::point_iterator +#endif // DOXYGEN_NO_DETAIL + + +}} // namespace boost::geometry + + +#endif // BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_ITERATOR_TYPE_HPP diff --git a/include/boost/geometry/iterators/detail/point_iterator/value_type.hpp b/include/boost/geometry/iterators/detail/point_iterator/value_type.hpp new file mode 100644 index 000000000..7cdf36639 --- /dev/null +++ b/include/boost/geometry/iterators/detail/point_iterator/value_type.hpp @@ -0,0 +1,47 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2014, Oracle and/or its affiliates. + +// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle + +// Licensed under the Boost Software License version 1.0. +// http://www.boost.org/users/license.html + +#ifndef BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_VALUE_TYPE_HPP +#define BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_VALUE_TYPE_HPP + +#include +#include + +#include + + +namespace boost { namespace geometry +{ + + +#ifndef DOXYGEN_NO_DETAIL +namespace detail { namespace point_iterator +{ + + +template +struct value_type +{ + typedef typename boost::mpl::if_c + < + !boost::is_const::type::value, + typename geometry::point_type::type, + typename geometry::point_type::type const + >::type type; +}; + + +}} // namespace detail::point_iterator +#endif // DOXYGEN_NO_DETAIL + + +}} // namespace boost::geometry + + +#endif // BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_VALUE_TYPE_HPP diff --git a/include/boost/geometry/iterators/dispatch/point_iterator_type.hpp b/include/boost/geometry/iterators/dispatch/point_iterator_type.hpp deleted file mode 100644 index 02c40acae..000000000 --- a/include/boost/geometry/iterators/dispatch/point_iterator_type.hpp +++ /dev/null @@ -1,37 +0,0 @@ -// Boost.Geometry (aka GGL, Generic Geometry Library) - -// Copyright (c) 2014, Oracle and/or its affiliates. - -// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle - -// Licensed under the Boost Software License version 1.0. -// http://www.boost.org/users/license.html - -#ifndef BOOST_GEOMETRY_ITERATORS_DISPATCH_POINT_ITERATOR_TYPE_HPP -#define BOOST_GEOMETRY_ITERATORS_DISPATCH_POINT_ITERATOR_TYPE_HPP - -#include -#include - -namespace boost { namespace geometry -{ - - -#ifndef DOXYGEN_NO_DISPATCH -namespace dispatch -{ - -template ::type> -struct point_iterator_type - : not_implemented -{}; - - - -} // namespace dispatch -#endif // DOXYGEN_NO_DISPATCH - - -}} // namespace boost::geometry - -#endif // BOOST_GEOMETRY_ITERATORS_DISPATCH_POINT_ITERATOR_TYPE_HPP diff --git a/include/boost/geometry/iterators/point_iterator.hpp b/include/boost/geometry/iterators/point_iterator.hpp index bfe0065d4..075339aa5 100644 --- a/include/boost/geometry/iterators/point_iterator.hpp +++ b/include/boost/geometry/iterators/point_iterator.hpp @@ -20,7 +20,7 @@ #include #include -#include +#include namespace boost { namespace geometry @@ -38,7 +38,10 @@ namespace dispatch template struct points_begin { - static inline typename point_iterator_type::type + static inline typename detail::point_iterator::iterator_type + < + Linestring + >::type apply(Linestring& linestring) { return boost::begin(linestring); @@ -49,7 +52,7 @@ struct points_begin template struct points_begin { - static inline typename point_iterator_type::type + static inline typename detail::point_iterator::iterator_type::type apply(Ring& ring) { return boost::begin(ring); @@ -60,7 +63,10 @@ struct points_begin template struct points_begin { - typedef typename point_iterator_type::type return_type; + typedef typename detail::point_iterator::iterator_type + < + Polygon + >::type return_type; static inline return_type apply(Polygon& polygon) { @@ -83,7 +89,10 @@ struct points_begin template struct points_begin { - static inline typename point_iterator_type::type + static inline typename detail::point_iterator::iterator_type + < + MultiPoint + >::type apply(MultiPoint& multipoint) { return boost::begin(multipoint); @@ -94,13 +103,15 @@ struct points_begin template struct points_begin { - static inline typename point_iterator_type::type - apply(MultiLinestring& multilinestring) + typedef typename detail::point_iterator::iterator_type + < + MultiLinestring + >::type return_type; + + static inline return_type apply(MultiLinestring& multilinestring) { - return typename point_iterator_type - < - MultiLinestring - >::type(boost::begin(multilinestring), boost::end(multilinestring)); + return return_type(boost::begin(multilinestring), + boost::end(multilinestring)); } }; @@ -108,13 +119,15 @@ struct points_begin template struct points_begin { - static inline typename point_iterator_type::type - apply(MultiPolygon& multipolygon) + typedef typename detail::point_iterator::iterator_type + < + MultiPolygon + >::type return_type; + + static inline return_type apply(MultiPolygon& multipolygon) { - return typename point_iterator_type - < - MultiPolygon - >::type(boost::begin(multipolygon), boost::end(multipolygon)); + return return_type(boost::begin(multipolygon), + boost::end(multipolygon)); } }; @@ -136,7 +149,10 @@ namespace dispatch template struct points_end { - static inline typename point_iterator_type::type + static inline typename detail::point_iterator::iterator_type + < + Linestring + >::type apply(Linestring& linestring) { return boost::end(linestring); @@ -147,7 +163,7 @@ struct points_end template struct points_end { - static inline typename point_iterator_type::type + static inline typename detail::point_iterator::iterator_type::type apply(Ring& ring) { return boost::end(ring); @@ -158,7 +174,10 @@ struct points_end template struct points_end { - typedef typename point_iterator_type::type return_type; + typedef typename detail::point_iterator::iterator_type + < + Polygon + >::type return_type; static inline return_type apply(Polygon& polygon) { @@ -178,7 +197,10 @@ struct points_end template struct points_end { - static inline typename point_iterator_type::type + static inline typename detail::point_iterator::iterator_type + < + MultiPoint + >::type apply(MultiPoint& multipoint) { return boost::end(multipoint); @@ -189,13 +211,14 @@ struct points_end template struct points_end { - static inline typename point_iterator_type::type - apply(MultiLinestring& multilinestring) + typedef typename detail::point_iterator::iterator_type + < + MultiLinestring + >::type return_type; + + static inline return_type apply(MultiLinestring& multilinestring) { - return typename point_iterator_type - < - MultiLinestring - >::type(boost::end(multilinestring)); + return return_type(boost::end(multilinestring)); } }; @@ -203,13 +226,14 @@ struct points_end template struct points_end { - static inline typename point_iterator_type::type - apply(MultiPolygon& multipolygon) + typedef typename detail::point_iterator::iterator_type + < + MultiPolygon + >::type return_type; + + static inline return_type apply(MultiPolygon& multipolygon) { - return typename point_iterator_type - < - MultiPolygon - >::type(boost::end(multipolygon)); + return return_type(boost::end(multipolygon)); } }; @@ -221,17 +245,17 @@ struct points_end // MK:: need to add doc here template class point_iterator - : public dispatch::point_iterator_type::type + : public detail::point_iterator::iterator_type::type { private: - typedef typename dispatch::point_iterator_type::type base; + typedef typename detail::point_iterator::iterator_type::type base; - base* base_ptr() + inline base* base_ptr() { return this; } - base const* base_ptr() const + inline base const* base_ptr() const { return this; } @@ -240,19 +264,25 @@ private: template friend inline point_iterator points_begin(G&); template friend inline point_iterator points_end(G&); - point_iterator(base const& base_it) : base(base_it) {} + inline point_iterator(base const& base_it) : base(base_it) {} public: - point_iterator() {} + inline point_iterator() {} template - point_iterator(point_iterator const& other) + inline point_iterator(point_iterator const& other) : base(*other.base_ptr()) { static const bool is_conv = boost::is_convertible< - typename dispatch::point_iterator_type::type, - typename dispatch::point_iterator_type::type + typename detail::point_iterator::iterator_type + < + OtherGeometry + >::type, + typename detail::point_iterator::iterator_type + < + Geometry + >::type >::value; BOOST_MPL_ASSERT_MSG((is_conv), diff --git a/include/boost/geometry/iterators/point_iterator_type.hpp b/include/boost/geometry/iterators/point_iterator_type.hpp deleted file mode 100644 index 28a7d4e81..000000000 --- a/include/boost/geometry/iterators/point_iterator_type.hpp +++ /dev/null @@ -1,208 +0,0 @@ -// Boost.Geometry (aka GGL, Generic Geometry Library) - -// Copyright (c) 2014, Oracle and/or its affiliates. - -// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle - -// Licensed under the Boost Software License version 1.0. -// http://www.boost.org/users/license.html - -#ifndef BOOST_GEOMETRY_ITERATORS_POINT_ITERATOR_TYPE_HPP -#define BOOST_GEOMETRY_ITERATORS_POINT_ITERATOR_TYPE_HPP - -#include -#include - -#include -#include -#include - -#include -#include -#include -#include - -#include -#include - - -namespace boost { namespace geometry -{ - - - -#ifndef DOXYGEN_NO_DETAIL -namespace detail_dispatch -{ - - -template -struct point_iterator_value_type -{ - typedef typename boost::mpl::if_c - < - !boost::is_const::type::value, - typename geometry::point_type::type, - typename geometry::point_type::type const - >::type type; -}; - - - - -template -< - typename Geometry, - typename Tag = typename tag::type -> -struct point_iterator_inner_range_type -{ - typedef typename boost::mpl::if_c - < - !boost::is_const::type::value, - typename boost::range_value::type, - typename boost::range_value::type const - >::type type; -}; - - -template -struct point_iterator_inner_range_type -{ - typedef typename boost::mpl::if_c - < - !boost::is_const::type::value, - typename geometry::ring_type::type, - typename geometry::ring_type::type const - >::type type; -}; - - - -} // namespace detail_dispatch -#endif // DOXYGEN_NO_DETAIL - - - - - -#ifndef DOXYGEN_NO_DISPATCH -namespace dispatch -{ - - -template -struct point_iterator_type -{ - typedef typename boost::range_iterator::type type; -}; - - -template -struct point_iterator_type -{ - typedef typename boost::range_iterator::type type; -}; - - -template -class point_iterator_type -{ -private: - typedef typename detail_dispatch::point_iterator_inner_range_type - < - Polygon - >::type inner_range; - -public: - typedef concatenate_iterator - < - typename boost::range_iterator::type, - flatten_iterator - < - typename boost::range_iterator - < - typename geometry::interior_type::type - >::type, - typename dispatch::point_iterator_type - < - inner_range - >::type, - typename detail_dispatch::point_iterator_value_type - < - Polygon - >::type, - dispatch::points_begin, - dispatch::points_end - >, - typename detail_dispatch::point_iterator_value_type::type - > type; -}; - - -template -struct point_iterator_type -{ - typedef typename boost::range_iterator::type type; -}; - - -template -class point_iterator_type -{ -private: - typedef typename detail_dispatch::point_iterator_inner_range_type - < - MultiLinestring - >::type inner_range; - -public: - typedef flatten_iterator - < - typename boost::range_iterator::type, - typename dispatch::point_iterator_type::type, - typename detail_dispatch::point_iterator_value_type - < - MultiLinestring - >::type, - dispatch::points_begin, - dispatch::points_end - > type; -}; - - -template -class point_iterator_type -{ -private: - typedef typename detail_dispatch::point_iterator_inner_range_type - < - MultiPolygon - >::type inner_range; - -public: - typedef flatten_iterator - < - typename boost::range_iterator::type, - typename dispatch::point_iterator_type::type, - typename detail_dispatch::point_iterator_value_type - < - MultiPolygon - >::type, - dispatch::points_begin, - dispatch::points_end - > type; -}; - - - - - -} // namespace dispatch -#endif // DOXYGEN_NO_DISPATCH - - -}} // namespace boost::geometry - - -#endif // BOOST_GEOMETRY_ITERATORS_POINT_ITERATOR_TYPE_HPP From fb35d9db7a5b40c37b358049d433812557ba2a07 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Tue, 30 Sep 2014 15:04:10 +0300 Subject: [PATCH 27/34] [iterators][segment_iterator] update segment_iterator implementation following the changes in the point_iterator implementation design and file/directory layout --- .../iterators/detail/segment_iterator/iterator_type.hpp | 8 ++++---- .../iterators/detail/segment_iterator/value_type.hpp | 4 ++-- include/boost/geometry/iterators/segment_iterator.hpp | 6 +++--- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/include/boost/geometry/iterators/detail/segment_iterator/iterator_type.hpp b/include/boost/geometry/iterators/detail/segment_iterator/iterator_type.hpp index 885c5f644..57a524e7e 100644 --- a/include/boost/geometry/iterators/detail/segment_iterator/iterator_type.hpp +++ b/include/boost/geometry/iterators/detail/segment_iterator/iterator_type.hpp @@ -22,7 +22,7 @@ #include #include -#include +#include #include #include @@ -68,7 +68,7 @@ template class iterator_type { private: - typedef typename detail_dispatch::point_iterator_inner_range_type + typedef typename detail::point_iterator::inner_range_type < Polygon >::type inner_range; @@ -103,7 +103,7 @@ template class iterator_type { private: - typedef typename detail_dispatch::point_iterator_inner_range_type + typedef typename detail::point_iterator::inner_range_type < MultiLinestring >::type inner_range; @@ -125,7 +125,7 @@ template class iterator_type { private: - typedef typename detail_dispatch::point_iterator_inner_range_type + typedef typename detail::point_iterator::inner_range_type < MultiPolygon >::type inner_range; diff --git a/include/boost/geometry/iterators/detail/segment_iterator/value_type.hpp b/include/boost/geometry/iterators/detail/segment_iterator/value_type.hpp index 6b11aa37c..0b3c66670 100644 --- a/include/boost/geometry/iterators/detail/segment_iterator/value_type.hpp +++ b/include/boost/geometry/iterators/detail/segment_iterator/value_type.hpp @@ -10,7 +10,7 @@ #ifndef BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_VALUE_TYPE_HPP #define BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_VALUE_TYPE_HPP -#include +#include #include @@ -24,7 +24,7 @@ namespace detail { namespace segment_iterator template struct value_type { - typedef typename detail_dispatch::point_iterator_value_type + typedef typename detail::point_iterator::value_type < Geometry >::type point_iterator_value_type; diff --git a/include/boost/geometry/iterators/segment_iterator.hpp b/include/boost/geometry/iterators/segment_iterator.hpp index 5397e4a98..206d7fc50 100644 --- a/include/boost/geometry/iterators/segment_iterator.hpp +++ b/include/boost/geometry/iterators/segment_iterator.hpp @@ -18,7 +18,7 @@ #include #include -#include +#include #include #include @@ -69,7 +69,7 @@ struct segments_begin template struct segments_begin { - typedef typename detail_dispatch::point_iterator_inner_range_type + typedef typename detail::point_iterator::inner_range_type < Polygon >::type inner_range; @@ -183,7 +183,7 @@ struct segments_end template struct segments_end { - typedef typename detail_dispatch::point_iterator_inner_range_type + typedef typename detail::point_iterator::inner_range_type < Polygon >::type inner_range; From f3ee1dedcdf5f61dbdc155a96091e0d6019e3bbd Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Tue, 30 Sep 2014 17:04:34 +0300 Subject: [PATCH 28/34] [algorithms][distance] qualify point_iterator by geometry namespace (needed because of the changes in the point_iterator class, namely the introduction of the bg::detail::point_iterator namespace) --- .../detail/distance/geometry_to_geometry_rtree.hpp | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/include/boost/geometry/algorithms/detail/distance/geometry_to_geometry_rtree.hpp b/include/boost/geometry/algorithms/detail/distance/geometry_to_geometry_rtree.hpp index 8dcbddddc..fc5318405 100644 --- a/include/boost/geometry/algorithms/detail/distance/geometry_to_geometry_rtree.hpp +++ b/include/boost/geometry/algorithms/detail/distance/geometry_to_geometry_rtree.hpp @@ -220,10 +220,13 @@ public: Strategy const& strategy, bool check_intersection = true) { - point_iterator first1 = points_begin(geometry1); - point_iterator beyond1 = points_end(geometry1); - point_iterator first2 = points_begin(geometry2); - point_iterator beyond2 = points_end(geometry2); + typedef geometry::point_iterator const_point_iterator1; + typedef geometry::point_iterator const_point_iterator2; + + const_point_iterator1 first1 = points_begin(geometry1); + const_point_iterator1 beyond1 = points_end(geometry1); + const_point_iterator2 first2 = points_begin(geometry2); + const_point_iterator2 beyond2 = points_end(geometry2); if ( geometry::has_one_element(first1, beyond1) ) { From ac32f9dd583f133de8d987afa7a242ace66c3102 Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Tue, 30 Sep 2014 17:08:15 +0300 Subject: [PATCH 29/34] [algorithms][for_each] fix bug with for_each_segment for open geometries: for_each_segment was not considering the last implicit segment of open geometries; the patch fixes this; --- .../boost/geometry/algorithms/for_each.hpp | 29 +++++++++++++++---- 1 file changed, 23 insertions(+), 6 deletions(-) diff --git a/include/boost/geometry/algorithms/for_each.hpp b/include/boost/geometry/algorithms/for_each.hpp index 036109d3c..f23a42d21 100644 --- a/include/boost/geometry/algorithms/for_each.hpp +++ b/include/boost/geometry/algorithms/for_each.hpp @@ -1,10 +1,15 @@ // Boost.Geometry (aka GGL, Generic Geometry Library) -// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. -// Copyright (c) 2008-2012 Bruno Lalande, Paris, France. -// Copyright (c) 2009-2012 Mateusz Loskot, London, UK. +// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands. +// Copyright (c) 2008-2014 Bruno Lalande, Paris, France. +// Copyright (c) 2009-2014 Mateusz Loskot, London, UK. // Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland. +// This file was modified by Oracle on 2014. +// Modifications copyright (c) 2014, Oracle and/or its affiliates. + +// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle + // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. @@ -24,6 +29,7 @@ #include #include +#include #include #include #include @@ -36,6 +42,9 @@ #include +#include + + namespace boost { namespace geometry { @@ -91,17 +100,25 @@ struct fe_range_per_segment template static inline void apply(Range& range, Functor& f) { + typedef typename closeable_view + < + Range, closure::value + >::type view_type; + typedef typename add_const_if_c < is_const::value, typename point_type::type >::type point_type; - typedef typename boost::range_iterator::type + + typedef typename boost::range_iterator::type iterator_type; - iterator_type it = boost::begin(range); + view_type view(range); + + iterator_type it = boost::begin(view); iterator_type previous = it++; - while(it != boost::end(range)) + while(it != boost::end(view)) { model::referring_segment s(*previous, *it); f(s); From c81a75f1dd6b9ab4d96b2854487e6512fa740afb Mon Sep 17 00:00:00 2001 From: Menelaos Karavelas Date: Tue, 30 Sep 2014 17:12:50 +0300 Subject: [PATCH 30/34] [test][algorithms][distance] add test case for open polygon and linestring where the distance is materialized between the linestring and the last (implicit) segment of the polygon --- test/algorithms/distance_linear_areal.cpp | 25 +++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/test/algorithms/distance_linear_areal.cpp b/test/algorithms/distance_linear_areal.cpp index b44475c1e..1665da019 100644 --- a/test/algorithms/distance_linear_areal.cpp +++ b/test/algorithms/distance_linear_areal.cpp @@ -26,6 +26,7 @@ typedef bg::model::segment int_segment_type; typedef bg::model::linestring linestring_type; typedef bg::model::multi_linestring multi_linestring_type; typedef bg::model::polygon polygon_type; +typedef bg::model::polygon open_polygon_type; typedef bg::model::multi_polygon multi_polygon_type; typedef bg::model::ring ring_type; typedef bg::model::box box_type; @@ -80,6 +81,10 @@ void test_distance_linestring_polygon(Strategy const& strategy) "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))", 10, 100, strategy, true); + tester::apply("linestring(-5 1,-2 1)", + "polygon((0 0,10 0,10 10,0 10,0 0))", + 2, 4, strategy, true); + tester::apply("linestring(-1 20,1 20,1 5)", "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))", 0, 0, strategy, true); @@ -91,6 +96,25 @@ void test_distance_linestring_polygon(Strategy const& strategy) //=========================================================================== +template +void test_distance_linestring_open_polygon(Strategy const& strategy) +{ +#ifdef BOOST_GEOMETRY_TEST_DEBUG + std::cout << std::endl; + std::cout << "linestring/open polygon distance tests" << std::endl; +#endif + typedef test_distance_of_geometries + < + linestring_type, open_polygon_type + > tester; + + tester::apply("linestring(-5 1,-2 1)", + "polygon((0 0,10 0,10 10,0 10))", + 2, 4, strategy, true); +} + +//=========================================================================== + template void test_distance_multilinestring_polygon(Strategy const& strategy) { @@ -843,6 +867,7 @@ BOOST_AUTO_TEST_CASE( test_all_segment_polygon ) BOOST_AUTO_TEST_CASE( test_all_linestring_polygon ) { test_distance_linestring_polygon(point_segment_strategy()); + test_distance_linestring_open_polygon(point_segment_strategy()); } BOOST_AUTO_TEST_CASE( test_all_multilinestring_polygon ) From e4e6dbc5e2d0ec76715c77d3c202e2732e5c4826 Mon Sep 17 00:00:00 2001 From: Adam Wulkiewicz Date: Wed, 1 Oct 2014 02:19:20 +0200 Subject: [PATCH 31/34] [test][iterators] Fix signed/unsigned comparison warnings in point_iterator test. --- test/iterators/point_iterator.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/iterators/point_iterator.cpp b/test/iterators/point_iterator.cpp index 62bd1b2cd..dff15eabe 100644 --- a/test/iterators/point_iterator.cpp +++ b/test/iterators/point_iterator.cpp @@ -208,7 +208,9 @@ struct test_point_iterator_of_geometry point_iterator begin = bg::points_begin(geometry); point_iterator end = bg::points_end(geometry); - BOOST_CHECK( std::distance(begin, end) == bg::num_points(geometry) ); + BOOST_CHECK( std::size_t(std::distance(begin, end)) + == + bg::num_points(geometry) ); BOOST_CHECK( equals::apply(begin, end, bg::points_begin(point_range), From 439f570d0255c3a85f6e9af25342baac47d14c8e Mon Sep 17 00:00:00 2001 From: Adam Wulkiewicz Date: Wed, 1 Oct 2014 02:19:37 +0200 Subject: [PATCH 32/34] [test][iterators] Fix signed/unsigned comparison warnings in segment_iterator test. --- test/iterators/segment_iterator.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/test/iterators/segment_iterator.cpp b/test/iterators/segment_iterator.cpp index eea028465..167ff9326 100644 --- a/test/iterators/segment_iterator.cpp +++ b/test/iterators/segment_iterator.cpp @@ -158,7 +158,9 @@ struct test_segment_iterator_of_geometry segment_iterator begin = bg::segments_begin(geometry); segment_iterator end = bg::segments_end(geometry); - BOOST_CHECK( std::distance(begin, end) == bg::num_segments(geometry) ); + BOOST_CHECK( std::size_t(std::distance(begin, end)) + == + bg::num_segments(geometry) ); BOOST_CHECK( equals::apply(begin, end, bg::segments_begin(segment_range), @@ -213,8 +215,8 @@ struct test_segment_iterator_of_geometry bg::segments_end(geometry), std::back_inserter(segments)); - BOOST_CHECK( std::distance(bg::segments_begin(geometry), - bg::segments_end(geometry)) + BOOST_CHECK( std::size_t( std::distance(bg::segments_begin(geometry), + bg::segments_end(geometry)) ) == segments.size() ); } From 5d93d7a1162f0fb44076b45f0780ddc9b6ea4a5c Mon Sep 17 00:00:00 2001 From: Barend Gehrels Date: Wed, 1 Oct 2014 10:23:39 +0200 Subject: [PATCH 33/34] [debug] fix operator<< of segment_identifier, now using os --- .../algorithms/detail/overlay/segment_identifier.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/include/boost/geometry/algorithms/detail/overlay/segment_identifier.hpp b/include/boost/geometry/algorithms/detail/overlay/segment_identifier.hpp index 007113ffb..e510b5bf9 100644 --- a/include/boost/geometry/algorithms/detail/overlay/segment_identifier.hpp +++ b/include/boost/geometry/algorithms/detail/overlay/segment_identifier.hpp @@ -68,12 +68,12 @@ struct segment_identifier #if defined(BOOST_GEOMETRY_DEBUG_SEGMENT_IDENTIFIER) friend std::ostream& operator<<(std::ostream &os, segment_identifier const& seg_id) { - std::cout + os << "s:" << seg_id.source_index - << ", v:" << seg_id.segment_index // ~vertex + << ", v:" << seg_id.segment_index // v:vertex because s is used for source ; - if (seg_id.ring_index >= 0) std::cout << ", r:" << seg_id.ring_index; - if (seg_id.multi_index >= 0) std::cout << ", m:" << seg_id.multi_index; + if (seg_id.ring_index >= 0) os << ", r:" << seg_id.ring_index; + if (seg_id.multi_index >= 0) os << ", m:" << seg_id.multi_index; return os; } #endif From cfb66e85b3c1d71540099f64370eea7fbb92b1c1 Mon Sep 17 00:00:00 2001 From: Barend Gehrels Date: Wed, 1 Oct 2014 10:24:21 +0200 Subject: [PATCH 34/34] [debug] extend operator<< of segment_ratio, now displaying the real value too --- include/boost/geometry/policies/robustness/segment_ratio.hpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/include/boost/geometry/policies/robustness/segment_ratio.hpp b/include/boost/geometry/policies/robustness/segment_ratio.hpp index 41068c0eb..8b55605c7 100644 --- a/include/boost/geometry/policies/robustness/segment_ratio.hpp +++ b/include/boost/geometry/policies/robustness/segment_ratio.hpp @@ -211,7 +211,10 @@ public : #if defined(BOOST_GEOMETRY_DEFINE_STREAM_OPERATOR_SEGMENT_RATIO) friend std::ostream& operator<<(std::ostream &os, segment_ratio const& ratio) { - os << ratio.m_numerator << "/" << ratio.m_denominator; + os << ratio.m_numerator << "/" << ratio.m_denominator + << " (" << (static_cast(ratio.m_numerator) + / static_cast(ratio.m_denominator)) + << ")"; return os; } #endif