iterator_tracker.h

00001 #ifndef _GLIBCXX_PROFILE_ITERATOR_TRACKER
00002 #define _GLIBCXX_PROFILE_ITERATOR_TRACKER 1
00003 
00004 #include <ext/type_traits.h>
00005 
00006 namespace std
00007 {
00008 namespace __profile
00009 {
00010 
00011 template<typename _Iterator, typename _Sequence>
00012 class __iterator_tracker 
00013 {
00014   typedef __iterator_tracker _Self;
00015   // The underlying iterator
00016   _Iterator _M_current;
00017   // The underlying data structure
00018   const _Sequence* _M_ds;
00019   typedef std::iterator_traits<_Iterator> _Traits;
00020 
00021  public:
00022   typedef _Iterator                   _Base_iterator;
00023   typedef typename _Traits::iterator_category iterator_category; 
00024   typedef typename _Traits::value_type        value_type;
00025   typedef typename _Traits::difference_type   difference_type;
00026   typedef typename _Traits::reference         reference;
00027   typedef typename _Traits::pointer           pointer;
00028 
00029   __iterator_tracker() : _M_current(), _M_ds(0) { }
00030   __iterator_tracker(const _Iterator& __i, const _Sequence* seq) 
00031       : _M_current(__i), _M_ds(seq) { }
00032   __iterator_tracker(const __iterator_tracker& __x) 
00033       : _M_current(__x._M_current), _M_ds(__x._M_ds) { }
00034   template<typename _MutableIterator>
00035   __iterator_tracker(const __iterator_tracker<_MutableIterator, typename __gnu_cxx::__enable_if<(std::__are_same<_MutableIterator, typename _Sequence::iterator::_Base_iterator>::__value), _Sequence>::__type>& __x)
00036       :  _M_current(__x.base()), _M_ds(__x._M_get_sequence()) { }
00037 
00038   _Iterator
00039   base() const { return _M_current; }
00040   /**
00041    * @brief Conversion to underlying non-debug iterator to allow
00042    * better interaction with non-profile containers.
00043    */
00044   operator _Iterator() const { return _M_current; }
00045 
00046   pointer
00047   operator->() const { return &*_M_current; }
00048 
00049   __iterator_tracker&
00050   operator++()
00051   {
00052     _M_ds->_M_profile_iterate();
00053     ++_M_current;
00054     return *this;
00055   }
00056 
00057   __iterator_tracker&
00058   operator++(int)
00059   {
00060     _M_ds->_M_profile_iterate();
00061     __iterator_tracker __tmp(*this);
00062     ++_M_current;
00063     return __tmp;
00064   }
00065 
00066   __iterator_tracker&
00067   operator--()
00068   {
00069     _M_ds->_M_profile_iterate(1);
00070     --_M_current;
00071     return *this;
00072   }
00073 
00074   __iterator_tracker&
00075   operator--(int)
00076   {
00077     _M_ds->_M_profile_iterate(1);
00078     __iterator_tracker __tmp(*this);
00079     --_M_current;
00080     return __tmp;
00081   }
00082 
00083   __iterator_tracker&
00084   operator=(const __iterator_tracker& __x)
00085   {
00086     _M_current = __x._M_current;
00087     return *this;
00088   }
00089 
00090   reference
00091   operator*() const
00092   {
00093     return *_M_current;
00094   }
00095 
00096  // ------ Random access iterator requirements ------
00097   reference
00098   operator[](const difference_type& __n) const 
00099   {
00100     return _M_current[__n];
00101   }
00102 
00103   __iterator_tracker&
00104   operator+=(const difference_type& __n)
00105   {
00106     _M_current += __n;
00107     return *this;
00108   }
00109 
00110   __iterator_tracker
00111   operator+(const difference_type& __n) const
00112   {
00113     __iterator_tracker __tmp(*this);
00114     __tmp += __n;
00115     return __tmp;
00116   }
00117 
00118   __iterator_tracker&
00119   operator-=(const difference_type& __n)
00120   {
00121     _M_current += -__n;
00122     return *this;
00123   }
00124 
00125   __iterator_tracker
00126   operator-(const difference_type& __n) const
00127   {
00128     __iterator_tracker __tmp(*this);
00129     __tmp -= __n;
00130     return __tmp;
00131   }
00132 
00133   void
00134   _M_find()
00135   {
00136     _M_ds->_M_profile_find();
00137   }
00138 
00139   const _Sequence*
00140   _M_get_sequence() const
00141   {
00142     return static_cast<const _Sequence*>(_M_ds);
00143   }
00144 };
00145 
00146 template<typename _IteratorL, typename _IteratorR, typename _Sequence>
00147 inline bool
00148 operator==(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
00149            const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
00150 {
00151   return __lhs.base() == __rhs.base();
00152 }
00153 
00154 template<typename _Iterator, typename _Sequence>
00155 inline bool
00156 operator==(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
00157            const __iterator_tracker<_Iterator, _Sequence>& __rhs)
00158 {
00159   return __lhs.base() == __rhs.base();
00160 }
00161 
00162 template<typename _IteratorL, typename _IteratorR, typename _Sequence>
00163 inline bool
00164 operator!=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
00165            const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
00166 {
00167   return __lhs.base() != __rhs.base();
00168 }
00169 
00170 template<typename _Iterator, typename _Sequence>
00171 inline bool
00172 operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
00173                const __iterator_tracker<_Iterator, _Sequence>& __rhs)
00174 {
00175   return __lhs.base() != __rhs.base();
00176 }
00177 
00178 template<typename _IteratorL, typename _IteratorR, typename _Sequence>
00179 inline bool
00180 operator<(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
00181           const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
00182 {
00183   return __lhs.base() < __rhs.base();
00184 }
00185 
00186 template<typename _Iterator, typename _Sequence>
00187 inline bool
00188 operator<(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
00189           const __iterator_tracker<_Iterator, _Sequence>& __rhs)
00190 {
00191   return __lhs.base() < __rhs.base();
00192 }
00193 
00194 template<typename _IteratorL, typename _IteratorR, typename _Sequence>
00195 inline bool
00196 operator<=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
00197            const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
00198 {
00199   return __lhs.base() <= __rhs.base();
00200 }
00201 
00202 template<typename _Iterator, typename _Sequence>
00203 inline bool
00204 operator<=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
00205            const __iterator_tracker<_Iterator, _Sequence>& __rhs)
00206 {
00207   return __lhs.base() <= __rhs.base();
00208 }
00209 
00210 template<typename _IteratorL, typename _IteratorR, typename _Sequence>
00211 inline bool
00212 operator>(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
00213           const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
00214 {
00215   return __lhs.base() > __rhs.base();
00216 }
00217 
00218 template<typename _Iterator, typename _Sequence>
00219 inline bool
00220 operator>(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
00221           const __iterator_tracker<_Iterator, _Sequence>& __rhs)
00222 {
00223   return __lhs.base() > __rhs.base();
00224 }
00225 
00226 template<typename _IteratorL, typename _IteratorR, typename _Sequence>
00227 inline bool
00228 operator>=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
00229            const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
00230 {
00231   return __lhs.base() >= __rhs.base();
00232 }
00233 
00234 template<typename _Iterator, typename _Sequence>
00235 inline bool
00236 operator>=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
00237            const __iterator_tracker<_Iterator, _Sequence>& __rhs)
00238 {
00239   return __lhs.base() >= __rhs.base();
00240 }
00241 
00242 // _GLIBCXX_RESOLVE_LIB_DEFECTS
00243 // According to the resolution of DR179 not only the various comparison
00244 // operators but also operator- must accept mixed iterator/const_iterator
00245 // parameters.
00246   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
00247   inline typename __iterator_tracker<_IteratorL, _Sequence>::difference_type
00248   operator-(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
00249             const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
00250 {
00251   return __lhs.base() - __rhs.base();
00252 }
00253 
00254 template<typename _Iterator, typename _Sequence>
00255 inline typename __iterator_tracker<_Iterator, _Sequence>::difference_type
00256 operator-(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
00257           const __iterator_tracker<_Iterator, _Sequence>& __rhs)
00258 {
00259   return __lhs.base() - __rhs.base();
00260 }
00261 
00262 template<typename _Iterator, typename _Sequence>
00263 inline __iterator_tracker<_Iterator, _Sequence>
00264 operator+(typename __iterator_tracker<_Iterator,_Sequence>::difference_type
00265           __n,
00266           const __iterator_tracker<_Iterator, _Sequence>& __i)
00267 {
00268   return __i + __n;
00269 }
00270         
00271 }  // namespace __profile
00272 }  // namespace std
00273 #endif

Generated on 11 Jan 2010 for libstdc++ by  doxygen 1.6.1