Imported Upstream version 1.59.0

Change-Id: I2dde00f4eca71df3eea9d251dcaecde18a6c90a5
Signed-off-by: DongHun Kwak <dh0128.kwak@samsung.com>

11 files changed, 403 insertions, 59 deletions

diff --git a/boost/geometry/index/detail/assert.hpp b/boost/geometry/index/detail/assert.hpp
index 311f37f640..08889df478 100644
--- a/boost/geometry/index/detail/assert.hpp
+++ b/boost/geometry/index/detail/assert.hpp
@@ -1,6 +1,6 @@
 // Boost.Geometry Index
 //
-// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
 //
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -9,13 +9,11 @@
 #ifndef BOOST_GEOMETRY_INDEX_DETAIL_ASSERT_HPP
 #define BOOST_GEOMETRY_INDEX_DETAIL_ASSERT_HPP
 
-#include <boost/assert.hpp>
+#include <boost/geometry/core/assert.hpp>
 
-#ifndef BOOST_GEOMETRY_INDEX_ASSERT
+#undef BOOST_GEOMETRY_INDEX_ASSERT
 
 #define BOOST_GEOMETRY_INDEX_ASSERT(CONDITION, TEXT_MSG) \
-    BOOST_ASSERT_MSG(CONDITION, TEXT_MSG)
-
-#endif // BOOST_GEOMETRY_INDEX_ASSERT
+    BOOST_GEOMETRY_ASSERT_MSG(CONDITION, TEXT_MSG)
 
 #endif // BOOST_GEOMETRY_INDEX_DETAIL_ASSERT_HPP
diff --git a/boost/geometry/index/detail/bounded_view.hpp b/boost/geometry/index/detail/bounded_view.hpp
index 0cd882fc94..e5f489d76b 100644
--- a/boost/geometry/index/detail/bounded_view.hpp
+++ b/boost/geometry/index/detail/bounded_view.hpp
@@ -3,7 +3,7 @@
 // This view makes possible to treat some simple primitives as its bounding geometry
 // e.g. box, nsphere, etc.
 //
-// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2014-2015 Adam Wulkiewicz, Lodz, Poland.
 //
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -12,6 +12,8 @@
 #ifndef BOOST_GEOMETRY_INDEX_DETAIL_BOUNDED_VIEW_HPP
 #define BOOST_GEOMETRY_INDEX_DETAIL_BOUNDED_VIEW_HPP
 
+#include <boost/geometry/algorithms/envelope.hpp>
+
 namespace boost { namespace geometry {
 
 namespace index { namespace detail {
@@ -19,7 +21,8 @@ namespace index { namespace detail {
 template <typename Geometry,
           typename BoundingGeometry,
           typename Tag = typename geometry::tag<Geometry>::type,
-          typename BoundingTag = typename geometry::tag<BoundingGeometry>::type>
+          typename BoundingTag = typename geometry::tag<BoundingGeometry>::type,
+          typename CSystem = typename geometry::coordinate_system<Geometry>::type>
 struct bounded_view
 {
     BOOST_MPL_ASSERT_MSG(
@@ -32,7 +35,7 @@ struct bounded_view
 // Segment -> Box
 
 template <typename Segment, typename Box>
-struct bounded_view<Segment, Box, segment_tag, box_tag>
+struct bounded_view<Segment, Box, segment_tag, box_tag, cs::cartesian>
 {
 public:
     typedef typename geometry::coordinate_type<Box>::type coordinate_type;
@@ -61,10 +64,37 @@ private:
     Segment const& m_segment;
 };
 
+template <typename Segment, typename Box, typename CSystem>
+struct bounded_view<Segment, Box, segment_tag, box_tag, CSystem>
+{
+public:
+    typedef typename geometry::coordinate_type<Box>::type coordinate_type;
+
+    explicit bounded_view(Segment const& segment)
+    {
+        geometry::envelope(segment, m_box);
+    }
+
+    template <std::size_t Dimension>
+    inline coordinate_type get_min() const
+    {
+        return geometry::get<min_corner, Dimension>(m_box);
+    }
+
+    template <std::size_t Dimension>
+    inline coordinate_type get_max() const
+    {
+        return geometry::get<max_corner, Dimension>(m_box);
+    }
+
+private:
+    Box m_box;
+};
+
 // Box -> Box
 
-template <typename BoxIn, typename Box>
-struct bounded_view<BoxIn, Box, box_tag, box_tag>
+template <typename BoxIn, typename Box, typename CSystem>
+struct bounded_view<BoxIn, Box, box_tag, box_tag, CSystem>
 {
 public:
     typedef typename geometry::coordinate_type<Box>::type coordinate_type;
@@ -93,8 +123,8 @@ private:
 
 // Point -> Box
 
-template <typename Point, typename Box>
-struct bounded_view<Point, Box, point_tag, box_tag>
+template <typename Point, typename Box, typename CSystem>
+struct bounded_view<Point, Box, point_tag, box_tag, CSystem>
 {
 public:
     typedef typename geometry::coordinate_type<Box>::type coordinate_type;
@@ -129,23 +159,23 @@ private:
 namespace traits
 {
 
-template <typename Geometry, typename Box, typename Tag>
-struct tag< index::detail::bounded_view<Geometry, Box, Tag, box_tag> >
+template <typename Geometry, typename Box, typename Tag, typename CSystem>
+struct tag< index::detail::bounded_view<Geometry, Box, Tag, box_tag, CSystem> >
 {
     typedef box_tag type;
 };
 
-template <typename Segment, typename Box, typename Tag>
-struct point_type< index::detail::bounded_view<Segment, Box, Tag, box_tag> >
+template <typename Geometry, typename Box, typename Tag, typename CSystem>
+struct point_type< index::detail::bounded_view<Geometry, Box, Tag, box_tag, CSystem> >
 {
     typedef typename point_type<Box>::type type;
 };
 
-template <typename Segment, typename Box, typename Tag, std::size_t Dimension>
-struct indexed_access<index::detail::bounded_view<Segment, Box, Tag, box_tag>,
+template <typename Geometry, typename Box, typename Tag, typename CSystem, std::size_t Dimension>
+struct indexed_access<index::detail::bounded_view<Geometry, Box, Tag, box_tag, CSystem>,
                       min_corner, Dimension>
 {
-    typedef index::detail::bounded_view<Segment, Box, Tag, box_tag> box_type;
+    typedef index::detail::bounded_view<Geometry, Box, Tag, box_tag, CSystem> box_type;
     typedef typename geometry::coordinate_type<Box>::type coordinate_type;
 
     static inline coordinate_type get(box_type const& b)
@@ -159,11 +189,11 @@ struct indexed_access<index::detail::bounded_view<Segment, Box, Tag, box_tag>,
     //}
 };
 
-template <typename Segment, typename Box, typename Tag, std::size_t Dimension>
-struct indexed_access<index::detail::bounded_view<Segment, Box, Tag, box_tag>,
+template <typename Geometry, typename Box, typename Tag, typename CSystem, std::size_t Dimension>
+struct indexed_access<index::detail::bounded_view<Geometry, Box, Tag, box_tag, CSystem>,
                       max_corner, Dimension>
 {
-    typedef index::detail::bounded_view<Segment, Box, Tag, box_tag> box_type;
+    typedef index::detail::bounded_view<Geometry, Box, Tag, box_tag, CSystem> box_type;
     typedef typename geometry::coordinate_type<Box>::type coordinate_type;
 
     static inline coordinate_type get(box_type const& b)
diff --git a/boost/geometry/index/detail/predicates.hpp b/boost/geometry/index/detail/predicates.hpp
index 60f80207d8..01afd16ba6 100644
--- a/boost/geometry/index/detail/predicates.hpp
+++ b/boost/geometry/index/detail/predicates.hpp
@@ -25,6 +25,7 @@ namespace predicates {
 template <typename Fun, bool IsFunction>
 struct satisfies_impl
 {
+    satisfies_impl() : fun(NULL) {}
     satisfies_impl(Fun f) : fun(f) {}
     Fun * fun;
 };
@@ -32,6 +33,7 @@ struct satisfies_impl
 template <typename Fun>
 struct satisfies_impl<Fun, false>
 {
+    satisfies_impl() {}
     satisfies_impl(Fun const& f) : fun(f) {}
     Fun fun;
 };
@@ -42,6 +44,7 @@ struct satisfies
 {
     typedef satisfies_impl<Fun, ::boost::is_function<Fun>::value> base;
 
+    satisfies() {}
     satisfies(Fun const& f) : base(f) {}
     satisfies(base const& b) : base(b) {}
 };
@@ -60,6 +63,7 @@ struct within_tag {};
 template <typename Geometry, typename Tag, bool Negated>
 struct spatial_predicate
 {
+    spatial_predicate() {}
     spatial_predicate(Geometry const& g) : geometry(g) {}
     Geometry geometry;
 };
@@ -75,6 +79,9 @@ struct spatial_predicate
 template <typename PointOrRelation>
 struct nearest
 {
+    nearest()
+//        : count(0)
+    {}
     nearest(PointOrRelation const& por, unsigned k)
         : point_or_relation(por)
         , count(k)
@@ -86,6 +93,9 @@ struct nearest
 template <typename SegmentOrLinestring>
 struct path
 {
+    path()
+//        : count(0)
+    {}
     path(SegmentOrLinestring const& g, unsigned k)
         : geometry(g)
         , count(k)
diff --git a/boost/geometry/index/detail/rtree/iterators.hpp b/boost/geometry/index/detail/rtree/iterators.hpp
new file mode 100644
index 0000000000..a47dd7ea43
--- /dev/null
+++ b/boost/geometry/index/detail/rtree/iterators.hpp
@@ -0,0 +1,122 @@
+// Boost.Geometry Index
+//
+// R-tree iterators
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_ITERATORS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_ITERATORS_HPP
+
+namespace boost { namespace geometry { namespace index { namespace detail { namespace rtree { namespace iterators {
+
+template <typename Value, typename Allocators>
+struct end_iterator
+{
+    typedef std::forward_iterator_tag iterator_category;
+    typedef Value value_type;
+    typedef typename Allocators::const_reference reference;
+    typedef typename Allocators::difference_type difference_type;
+    typedef typename Allocators::const_pointer pointer;
+
+    reference operator*() const
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "iterator not dereferencable");
+        pointer p(0);
+        return *p;
+    }
+
+    const value_type * operator->() const
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "iterator not dereferencable");
+        const value_type * p = 0;
+        return p;
+    }
+
+    end_iterator & operator++()
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "iterator not incrementable");
+        return *this;
+    }
+
+    end_iterator operator++(int)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "iterator not incrementable");
+        return *this;
+    }
+
+    friend bool operator==(end_iterator const& /*l*/, end_iterator const& /*r*/)
+    {
+        return true;
+    }
+};
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class iterator
+{
+    typedef visitors::iterator<Value, Options, Translator, Box, Allocators> visitor_type;
+    typedef typename visitor_type::node_pointer node_pointer;
+
+public:
+    typedef std::forward_iterator_tag iterator_category;
+    typedef Value value_type;
+    typedef typename Allocators::const_reference reference;
+    typedef typename Allocators::difference_type difference_type;
+    typedef typename Allocators::const_pointer pointer;
+
+    inline iterator()
+    {}
+
+    inline iterator(node_pointer root)
+    {
+        m_visitor.initialize(root);
+    }
+
+    reference operator*() const
+    {
+        return m_visitor.dereference();
+    }
+
+    const value_type * operator->() const
+    {
+        return boost::addressof(m_visitor.dereference());
+    }
+
+    iterator & operator++()
+    {
+        m_visitor.increment();
+        return *this;
+    }
+
+    iterator operator++(int)
+    {
+        iterator temp = *this;
+        this->operator++();
+        return temp;
+    }
+
+    friend bool operator==(iterator const& l, iterator const& r)
+    {
+        return l.m_visitor == r.m_visitor;
+    }
+
+    friend bool operator==(iterator const& l, end_iterator<Value, Allocators> const& /*r*/)
+    {
+        return l.m_visitor.is_end();
+    }
+
+    friend bool operator==(end_iterator<Value, Allocators> const& /*l*/, iterator const& r)
+    {
+        return r.m_visitor.is_end();
+    }
+    
+private:
+    visitor_type m_visitor;
+};
+
+}}}}}} // namespace boost::geometry::index::detail::rtree::iterators
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_ITERATORS_HPP
diff --git a/boost/geometry/index/detail/rtree/node/node.hpp b/boost/geometry/index/detail/rtree/node/node.hpp
index 528d473170..b04744c85a 100644
--- a/boost/geometry/index/detail/rtree/node/node.hpp
+++ b/boost/geometry/index/detail/rtree/node/node.hpp
@@ -46,11 +46,7 @@ inline Box elements_box(FwdIter first, FwdIter last, Translator const& tr)
 {
     Box result;
 
-    if ( first == last )
-    {
-        geometry::assign_inverse(result);
-        return result;
-    }
+    BOOST_GEOMETRY_INDEX_ASSERT(first != last, "non-empty range required");
 
     detail::bounds(element_indexable(*first, tr), result);
     ++first;
diff --git a/boost/geometry/index/detail/rtree/pack_create.hpp b/boost/geometry/index/detail/rtree/pack_create.hpp
index b7be41ab2b..ce07d293db 100644
--- a/boost/geometry/index/detail/rtree/pack_create.hpp
+++ b/boost/geometry/index/detail/rtree/pack_create.hpp
@@ -11,6 +11,9 @@
 #ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_PACK_CREATE_HPP
 #define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_PACK_CREATE_HPP
 
+#include <boost/geometry/algorithms/expand.hpp>
+#include <boost/geometry/index/detail/algorithms/bounds.hpp>
+
 namespace boost { namespace geometry { namespace index { namespace detail { namespace rtree {
 
 namespace pack_utils {
@@ -157,8 +160,7 @@ public:
         values_count = static_cast<size_type>(diff);
         entries.reserve(values_count);
         
-        Box hint_box;
-        geometry::assign_inverse(hint_box);
+        expandable_box<Box> hint_box;
         for ( ; first != last ; ++first )
         {
             // NOTE: support for iterators not returning true references adapted
@@ -172,7 +174,7 @@ public:
             // CONSIDER: alternative - ignore invalid indexable or throw an exception
             BOOST_GEOMETRY_INDEX_ASSERT(detail::is_valid(indexable), "Indexable is invalid");
 
-            geometry::expand(hint_box, indexable);
+            hint_box.expand(indexable);
 
             point_type pt;
             geometry::centroid(indexable, pt);
@@ -180,13 +182,49 @@ public:
         }
 
         subtree_elements_counts subtree_counts = calculate_subtree_elements_counts(values_count, parameters, leafs_level);
-        internal_element el = per_level(entries.begin(), entries.end(), hint_box, values_count, subtree_counts,
+        internal_element el = per_level(entries.begin(), entries.end(), hint_box.get(), values_count, subtree_counts,
                                         parameters, translator, allocators);
 
         return el.second;
     }
 
 private:
+    template <typename BoxType>
+    class expandable_box
+    {
+    public:
+        expandable_box()
+            : m_initialized(false)
+        {}
+
+        template <typename Indexable>
+        void expand(Indexable const& indexable)
+        {
+            if ( !m_initialized )
+            {
+                // it's guaranteed that the Box will be initialized
+                // only for Points, Boxes and Segments but that's ok
+                // since only those Geometries can be stored
+                detail::bounds(indexable, m_box);
+                m_initialized = true;
+            }
+            else
+            {
+                geometry::expand(m_box, indexable);
+            }
+        }
+
+        BoxType const& get() const
+        {
+            BOOST_GEOMETRY_INDEX_ASSERT(m_initialized, "uninitialized envelope accessed");
+            return m_box;
+        }
+
+    private:
+        bool m_initialized;
+        BoxType m_box;
+    };
+
     struct subtree_elements_counts
     {
         subtree_elements_counts(std::size_t ma, std::size_t mi) : maxc(ma), minc(mi) {}
@@ -216,19 +254,18 @@ private:
             // reserve space for values
             rtree::elements(l).reserve(values_count);                                                       // MAY THROW (A)
             // calculate values box and copy values
-            Box elements_box;
-            geometry::assign_inverse(elements_box);
+            expandable_box<Box> elements_box;
             for ( ; first != last ; ++first )
             {
                 // NOTE: push_back() must be called at the end in order to support move_iterator.
                 //       The iterator is dereferenced 2x (no temporary reference) to support
                 //       non-true reference types and move_iterator without boost::forward<>.
-                geometry::expand(elements_box, translator(*(first->second)));
+                elements_box.expand(translator(*(first->second)));
                 rtree::elements(l).push_back(*(first->second));                                             // MAY THROW (A?,C)
             }
 
             auto_remover.release();
-            return internal_element(elements_box, n);
+            return internal_element(elements_box.get(), n);
         }
 
         // calculate next max and min subtree counts
@@ -245,23 +282,22 @@ private:
         std::size_t nodes_count = calculate_nodes_count(values_count, subtree_counts);
         rtree::elements(in).reserve(nodes_count);                                                           // MAY THROW (A)
         // calculate values box and copy values
-        Box elements_box;
-        geometry::assign_inverse(elements_box);
-
+        expandable_box<Box> elements_box;
+        
         per_level_packets(first, last, hint_box, values_count, subtree_counts, next_subtree_counts,
                           rtree::elements(in), elements_box,
                           parameters, translator, allocators);
 
         auto_remover.release();
-        return internal_element(elements_box, n);
+        return internal_element(elements_box.get(), n);
     }
 
-    template <typename EIt> inline static
+    template <typename EIt, typename ExpandableBox> inline static
     void per_level_packets(EIt first, EIt last, Box const& hint_box,
                            std::size_t values_count,
                            subtree_elements_counts const& subtree_counts,
                            subtree_elements_counts const& next_subtree_counts,
-                           internal_elements & elements, Box & elements_box,
+                           internal_elements & elements, ExpandableBox & elements_box,
                            parameters_type const& parameters, Translator const& translator, Allocators & allocators)
     {
         BOOST_GEOMETRY_INDEX_ASSERT(0 < std::distance(first, last) && static_cast<std::size_t>(std::distance(first, last)) == values_count,
@@ -285,7 +321,7 @@ private:
             elements.push_back(el);                                                 // MAY THROW (A?,C) - however in normal conditions shouldn't
             auto_remover.release();
 
-            geometry::expand(elements_box, el.first);
+            elements_box.expand(el.first);
             return;
         }
         
diff --git a/boost/geometry/index/detail/rtree/quadratic/redistribute_elements.hpp b/boost/geometry/index/detail/rtree/quadratic/redistribute_elements.hpp
index 634d879864..928ffd47d9 100644
--- a/boost/geometry/index/detail/rtree/quadratic/redistribute_elements.hpp
+++ b/boost/geometry/index/detail/rtree/quadratic/redistribute_elements.hpp
@@ -2,7 +2,7 @@
 //
 // R-tree quadratic split algorithm implementation
 //
-// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
 //
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -57,7 +57,6 @@ inline void pick_seeds(Elements const& elements,
             indexable_type const& ind2 = rtree::element_indexable(elements[j], tr);
 
             box_type enlarged_box;
-            //geometry::convert(ind1, enlarged_box);
             detail::bounds(ind1, enlarged_box);
             geometry::expand(enlarged_box, ind2);
 
@@ -133,9 +132,7 @@ struct redistribute_elements<Value, Options, Translator, Box, Allocators, quadra
             elements2.push_back(elements_copy[seed2]);                                                      // MAY THROW, STRONG (alloc, copy)
 
             // calculate boxes
-            //geometry::convert(rtree::element_indexable(elements_copy[seed1], translator), box1);
             detail::bounds(rtree::element_indexable(elements_copy[seed1], translator), box1);
-            //geometry::convert(rtree::element_indexable(elements_copy[seed2], translator), box2);
             detail::bounds(rtree::element_indexable(elements_copy[seed2], translator), box2);
 
             // remove seeds
diff --git a/boost/geometry/index/detail/rtree/query_iterators.hpp b/boost/geometry/index/detail/rtree/query_iterators.hpp
index 74000d03ef..83be106b8b 100644
--- a/boost/geometry/index/detail/rtree/query_iterators.hpp
+++ b/boost/geometry/index/detail/rtree/query_iterators.hpp
@@ -20,7 +20,7 @@ namespace boost { namespace geometry { namespace index { namespace detail { name
 template <typename Value, typename Allocators>
 struct end_query_iterator
 {
-    typedef std::input_iterator_tag iterator_category;
+    typedef std::forward_iterator_tag iterator_category;
     typedef Value value_type;
     typedef typename Allocators::const_reference reference;
     typedef typename Allocators::difference_type difference_type;
@@ -65,12 +65,15 @@ class spatial_query_iterator
     typedef typename visitor_type::node_pointer node_pointer;
 
 public:
-    typedef std::input_iterator_tag iterator_category;
+    typedef std::forward_iterator_tag iterator_category;
     typedef Value value_type;
     typedef typename Allocators::const_reference reference;
     typedef typename Allocators::difference_type difference_type;
     typedef typename Allocators::const_pointer pointer;
 
+    inline spatial_query_iterator()
+    {}
+
     inline spatial_query_iterator(Translator const& t, Predicates const& p)
         : m_visitor(t, p)
     {}
@@ -130,12 +133,15 @@ class distance_query_iterator
     typedef typename visitor_type::node_pointer node_pointer;
 
 public:
-    typedef std::input_iterator_tag iterator_category;
+    typedef std::forward_iterator_tag iterator_category;
     typedef Value value_type;
     typedef typename Allocators::const_reference reference;
     typedef typename Allocators::difference_type difference_type;
     typedef typename Allocators::const_pointer pointer;
 
+    inline distance_query_iterator()
+    {}
+
     inline distance_query_iterator(Translator const& t, Predicates const& p)
         : m_visitor(t, p)
     {}
@@ -188,22 +194,19 @@ private:
     visitor_type m_visitor;
 };
 
+
 template <typename L, typename R>
 inline bool operator!=(L const& l, R const& r)
 {
     return !(l == r);
 }
 
-}}}}}} // namespace boost::geometry::index::detail::rtree::iterators
-
-
-namespace boost { namespace geometry { namespace index { namespace detail { namespace rtree { namespace iterators {
 
 template <typename Value, typename Allocators>
 class query_iterator_base
 {
 public:
-    typedef std::input_iterator_tag iterator_category;
+    typedef std::forward_iterator_tag iterator_category;
     typedef Value value_type;
     typedef typename Allocators::const_reference reference;
     typedef typename Allocators::difference_type difference_type;
@@ -226,12 +229,13 @@ class query_iterator_wrapper
     typedef query_iterator_base<Value, Allocators> base_t;
 
 public:
-    typedef std::input_iterator_tag iterator_category;
+    typedef std::forward_iterator_tag iterator_category;
     typedef Value value_type;
     typedef typename Allocators::const_reference reference;
     typedef typename Allocators::difference_type difference_type;
     typedef typename Allocators::const_pointer pointer;
 
+    query_iterator_wrapper() : m_iterator() {}
     explicit query_iterator_wrapper(Iterator const& it) : m_iterator(it) {}
 
     virtual base_t * clone() const { return new query_iterator_wrapper(m_iterator); }
@@ -258,13 +262,14 @@ class query_iterator
     typedef boost::scoped_ptr<iterator_base> iterator_ptr;
 
 public:
-    typedef std::input_iterator_tag iterator_category;
+    typedef std::forward_iterator_tag iterator_category;
     typedef Value value_type;
     typedef typename Allocators::const_reference reference;
     typedef typename Allocators::difference_type difference_type;
     typedef typename Allocators::const_pointer pointer;
 
-    query_iterator() {}
+    query_iterator()
+    {}
 
     template <typename It>
     query_iterator(It const& it)
diff --git a/boost/geometry/index/detail/rtree/visitors/distance_query.hpp b/boost/geometry/index/detail/rtree/visitors/distance_query.hpp
index fc0929e9ed..b930714433 100644
--- a/boost/geometry/index/detail/rtree/visitors/distance_query.hpp
+++ b/boost/geometry/index/detail/rtree/visitors/distance_query.hpp
@@ -337,6 +337,13 @@ public:
     };
     typedef std::vector<internal_stack_element> internal_stack_type;
 
+    inline distance_query_incremental()
+        : m_translator(NULL)
+//        , m_pred()
+        , current_neighbor((std::numeric_limits<size_type>::max)())
+//        , next_closest_node_distance((std::numeric_limits<node_distance_type>::max)())
+    {}
+
     inline distance_query_incremental(Translator const& translator, Predicates const& pred)
         : m_translator(::boost::addressof(translator))
         , m_pred(pred)
@@ -428,6 +435,7 @@ public:
     {
         BOOST_GEOMETRY_INDEX_ASSERT(l.current_neighbor != r.current_neighbor ||
                                     (std::numeric_limits<size_type>::max)() == l.current_neighbor ||
+                                    (std::numeric_limits<size_type>::max)() == r.current_neighbor ||
                                     l.neighbors[l.current_neighbor].second == r.neighbors[r.current_neighbor].second,
                                     "not corresponding iterators");
         return l.current_neighbor == r.current_neighbor;
diff --git a/boost/geometry/index/detail/rtree/visitors/iterator.hpp b/boost/geometry/index/detail/rtree/visitors/iterator.hpp
new file mode 100644
index 0000000000..621231ae9a
--- /dev/null
+++ b/boost/geometry/index/detail/rtree/visitors/iterator.hpp
@@ -0,0 +1,134 @@
+// Boost.Geometry Index
+//
+// R-tree iterator visitor implementation
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_ITERATOR_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_ITERATOR_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree { namespace visitors {
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class iterator
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+public:
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename Allocators::size_type size_type;
+    typedef typename Allocators::const_reference const_reference;
+    typedef typename Allocators::node_pointer node_pointer;
+
+    typedef typename rtree::elements_type<internal_node>::type::const_iterator internal_iterator;
+    typedef typename rtree::elements_type<leaf>::type leaf_elements;
+    typedef typename rtree::elements_type<leaf>::type::const_iterator leaf_iterator;
+
+    inline iterator()
+        : m_values(NULL)
+        , m_current()
+    {}
+
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        m_internal_stack.push_back(std::make_pair(elements.begin(), elements.end()));
+    }
+
+    inline void operator()(leaf const& n)
+    {
+        m_values = ::boost::addressof(rtree::elements(n));
+        m_current = rtree::elements(n).begin();
+    }
+
+    const_reference dereference() const
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(m_values, "not dereferencable");
+        return *m_current;
+    }
+
+    void initialize(node_pointer root)
+    {
+        rtree::apply_visitor(*this, *root);
+        search_value();
+    }
+
+    void increment()
+    {
+        ++m_current;
+        search_value();
+    }
+
+    void search_value()
+    {
+        for (;;)
+        {
+            // if leaf is choosen, move to the next value in leaf
+            if ( m_values )
+            {
+                // there are more values in the current leaf
+                if ( m_current != m_values->end() )
+                {
+                    return;
+                }
+                // no more values, clear current leaf
+                else
+                {
+                    m_values = 0;
+                }
+            }
+            // if leaf isn't choosen, move to the next leaf
+            else
+            {
+                // return if there is no more nodes to traverse
+                if ( m_internal_stack.empty() )
+                    return;
+
+                // no more children in current node, remove it from stack
+                if ( m_internal_stack.back().first == m_internal_stack.back().second )
+                {
+                    m_internal_stack.pop_back();
+                    continue;
+                }
+
+                internal_iterator it = m_internal_stack.back().first;
+                ++m_internal_stack.back().first;
+
+                // push the next node to the stack
+                rtree::apply_visitor(*this, *(it->second));
+            }
+        }
+    }
+
+    bool is_end() const
+    {
+        return 0 == m_values;
+    }
+
+    friend bool operator==(iterator const& l, iterator const& r)
+    {
+        return (l.m_values == r.m_values) && (0 == l.m_values || l.m_current == r.m_current );
+    }
+
+private:
+
+    std::vector< std::pair<internal_iterator, internal_iterator> > m_internal_stack;
+    const leaf_elements * m_values;
+    leaf_iterator m_current;
+};
+
+}}} // namespace detail::rtree::visitors
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_ITERATOR_HPP
diff --git a/boost/geometry/index/detail/rtree/visitors/spatial_query.hpp b/boost/geometry/index/detail/rtree/visitors/spatial_query.hpp
index f00189fe77..b9cd0ae2c0 100644
--- a/boost/geometry/index/detail/rtree/visitors/spatial_query.hpp
+++ b/boost/geometry/index/detail/rtree/visitors/spatial_query.hpp
@@ -94,10 +94,18 @@ public:
 
     static const unsigned predicates_len = index::detail::predicates_length<Predicates>::value;
 
+    inline spatial_query_incremental()
+        : m_translator(NULL)
+//        , m_pred()
+        , m_values(NULL)
+        , m_current()
+    {}
+
     inline spatial_query_incremental(Translator const& t, Predicates const& p)
         : m_translator(::boost::addressof(t))
         , m_pred(p)
-        , m_values(0)
+        , m_values(NULL)
+        , m_current()
     {}
 
     inline void operator()(internal_node const& n)