00001
00007 #ifndef INCLUDE_KDTREE_ITERATOR_HPP
00008 #define INCLUDE_KDTREE_ITERATOR_HPP
00009
00010 #include <iterator>
00011
00012 #include <kdtree++/node.hpp>
00013
00014 namespace KDTree
00015 {
00016 template <typename _Val, typename _Ref, typename _Ptr>
00017 class _Iterator;
00018
00019 template<typename _Val, typename _Ref, typename _Ptr>
00020 inline bool
00021 operator==(_Iterator<_Val, _Ref, _Ptr> const&,
00022 _Iterator<_Val, _Ref, _Ptr> const&);
00023
00024 template<typename _Val>
00025 inline bool
00026 operator==(_Iterator<_Val, const _Val&, const _Val*> const&,
00027 _Iterator<_Val, _Val&, _Val*> const&);
00028
00029 template<typename _Val>
00030 inline bool
00031 operator==(_Iterator<_Val, _Val&, _Val*> const&,
00032 _Iterator<_Val, const _Val&, const _Val*> const&);
00033
00034 template<typename _Val, typename _Ref, typename _Ptr>
00035 inline bool
00036 operator!=(_Iterator<_Val, _Ref, _Ptr> const&,
00037 _Iterator<_Val, _Ref, _Ptr> const&);
00038
00039 template<typename _Val>
00040 inline bool
00041 operator!=(_Iterator<_Val, const _Val&, const _Val*> const&,
00042 _Iterator<_Val, _Val&, _Val*> const&);
00043
00044 template<typename _Val>
00045 inline bool
00046 operator!=(_Iterator<_Val, _Val&, _Val*> const&,
00047 _Iterator<_Val, const _Val&, const _Val*> const&);
00048
00049 class _Base_iterator
00050 {
00051 protected:
00052 typedef _Node_base::_Base_const_ptr _Base_const_ptr;
00053 _Base_const_ptr _M_node;
00054
00055 inline _Base_iterator(_Base_const_ptr const __N = NULL)
00056 : _M_node(__N) {}
00057 inline _Base_iterator(_Base_iterator const& __THAT)
00058 : _M_node(__THAT._M_node) {}
00059
00060 inline void
00061 _M_increment()
00062 {
00063 if (_M_node->_M_right)
00064 {
00065 _M_node = _M_node->_M_right;
00066 while (_M_node->_M_left) _M_node = _M_node->_M_left;
00067 }
00068 else
00069 {
00070 _Base_const_ptr __p = _M_node->_M_parent;
00071 while (__p && _M_node == __p->_M_right)
00072 {
00073 _M_node = __p;
00074 __p = _M_node->_M_parent;
00075 }
00076 if (__p)
00077
00078 _M_node = __p;
00079 }
00080 }
00081
00082 inline void
00083 _M_decrement()
00084 {
00085 if (!_M_node->_M_parent)
00086 {
00087 _M_node = _M_node->_M_right;
00088 }
00089 else if (_M_node->_M_left)
00090 {
00091 _Base_const_ptr x = _M_node->_M_left;
00092 while (x->_M_right) x = x->_M_right;
00093 _M_node = x;
00094 }
00095 else
00096 {
00097 _Base_const_ptr __p = _M_node->_M_parent;
00098 while (__p && _M_node == __p->_M_left)
00099 {
00100 _M_node = __p;
00101 __p = _M_node->_M_parent;
00102 }
00103 if (__p)
00104
00105 _M_node = __p;
00106 }
00107 }
00108
00109 template <size_t const __K, typename _Val, typename _Acc,
00110 typename _Dist, typename _Cmp, typename _Alloc>
00111 friend class KDTree;
00112 };
00113
00114 template <typename _Val, typename _Ref, typename _Ptr>
00115 class _Iterator : protected _Base_iterator
00116 {
00117 public:
00118 typedef _Val value_type;
00119 typedef _Ref reference;
00120 typedef _Ptr pointer;
00121 typedef _Iterator<_Val, _Val&, _Val*> iterator;
00122 typedef _Iterator<_Val, _Val const&, _Val const*> const_iterator;
00123 typedef _Iterator<_Val, _Ref, _Ptr> _Self;
00124 typedef _Node<_Val> const* _Link_const_type;
00125 typedef std::bidirectional_iterator_tag iterator_category;
00126 typedef ptrdiff_t difference_type;
00127
00128 inline _Iterator()
00129 : _Base_iterator() {}
00130 inline _Iterator(_Link_const_type const __N)
00131 : _Base_iterator(__N) {}
00132 inline _Iterator(iterator const& __THAT)
00133 : _Base_iterator(__THAT) {}
00134
00135 _Link_const_type get_raw_node() const
00136 {
00137 return _Link_const_type(_M_node);
00138 }
00139
00140 reference
00141 operator*() const
00142 {
00143 return _Link_const_type(_M_node)->_M_value;
00144 }
00145
00146 pointer
00147 operator->() const
00148 {
00149 return &(operator*());
00150 }
00151
00152 _Self
00153 operator++()
00154 {
00155 _M_increment();
00156 return *this;
00157 }
00158
00159 _Self
00160 operator++(int)
00161 {
00162 _Self ret = *this;
00163 _M_increment();
00164 return ret;
00165 }
00166
00167 _Self&
00168 operator--()
00169 {
00170 _M_decrement();
00171 return *this;
00172 }
00173
00174 _Self
00175 operator--(int)
00176 {
00177 _Self ret = *this;
00178 _M_decrement();
00179 return ret;
00180 }
00181
00182 friend bool
00183 operator== <>(_Iterator<_Val, _Ref, _Ptr> const&,
00184 _Iterator<_Val, _Ref, _Ptr> const&);
00185
00186 friend bool
00187 operator== <>(_Iterator<_Val, const _Val&, const _Val*> const&,
00188 _Iterator<_Val, _Val&, _Val*> const&);
00189
00190 friend bool
00191 operator== <>(_Iterator<_Val, _Val&, _Val*> const&,
00192 _Iterator<_Val, const _Val&, const _Val*> const&);
00193
00194 friend bool
00195 operator!= <>(_Iterator<_Val, _Ref, _Ptr> const&,
00196 _Iterator<_Val, _Ref, _Ptr> const&);
00197
00198 friend bool
00199 operator!= <>(_Iterator<_Val, const _Val&, const _Val*> const&,
00200 _Iterator<_Val, _Val&, _Val*> const&);
00201
00202 friend bool
00203 operator!= <>(_Iterator<_Val, _Val&, _Val*> const&,
00204 _Iterator<_Val, const _Val&, const _Val*> const&);
00205 };
00206
00207 template<typename _Val, typename _Ref, typename _Ptr>
00208 inline bool
00209 operator==(_Iterator<_Val, _Ref, _Ptr> const& __X,
00210 _Iterator<_Val, _Ref, _Ptr> const& __Y)
00211 { return __X._M_node == __Y._M_node; }
00212
00213 template<typename _Val>
00214 inline bool
00215 operator==(_Iterator<_Val, const _Val&, const _Val*> const& __X,
00216 _Iterator<_Val, _Val&, _Val*> const& __Y)
00217 { return __X._M_node == __Y._M_node; }
00218
00219 template<typename _Val>
00220 inline bool
00221 operator==(_Iterator<_Val, _Val&, _Val*> const& __X,
00222 _Iterator<_Val, const _Val&, const _Val*> const& __Y)
00223 { return __X._M_node == __Y._M_node; }
00224
00225 template<typename _Val, typename _Ref, typename _Ptr>
00226 inline bool
00227 operator!=(_Iterator<_Val, _Ref, _Ptr> const& __X,
00228 _Iterator<_Val, _Ref, _Ptr> const& __Y)
00229 { return __X._M_node != __Y._M_node; }
00230
00231 template<typename _Val>
00232 inline bool
00233 operator!=(_Iterator<_Val, const _Val&, const _Val*> const& __X,
00234 _Iterator<_Val, _Val&, _Val*> const& __Y)
00235 { return __X._M_node != __Y._M_node; }
00236
00237 template<typename _Val>
00238 inline bool
00239 operator!=(_Iterator<_Val, _Val&, _Val*> const& __X,
00240 _Iterator<_Val, const _Val&, const _Val*> const& __Y)
00241 { return __X._M_node != __Y._M_node; }
00242
00243 }
00244
00245 #endif // include guard
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258