| ///////////////////////////////////////////////////////////////////////////// |
| // |
| // (C) Copyright Ion Gaztanaga 2007-2009 |
| // |
| // Distributed under 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) |
| // |
| // See http://www.boost.org/libs/intrusive for documentation. |
| // |
| ///////////////////////////////////////////////////////////////////////////// |
| |
| #ifndef BOOST_INTRUSIVE_DETAIL_TRANSFORM_ITERATOR_HPP |
| #define BOOST_INTRUSIVE_DETAIL_TRANSFORM_ITERATOR_HPP |
| |
| #include <boost/intrusive/detail/config_begin.hpp> |
| #include <iterator> |
| #include <boost/intrusive/detail/mpl.hpp> |
| |
| namespace boost { |
| namespace intrusive { |
| namespace detail { |
| |
| template <class PseudoReference> |
| struct operator_arrow_proxy |
| { |
| operator_arrow_proxy(const PseudoReference &px) |
| : m_value(px) |
| {} |
| |
| PseudoReference* operator->() const { return &m_value; } |
| // This function is needed for MWCW and BCC, which won't call operator-> |
| // again automatically per 13.3.1.2 para 8 |
| // operator T*() const { return &m_value; } |
| mutable PseudoReference m_value; |
| }; |
| |
| template <class T> |
| struct operator_arrow_proxy<T&> |
| { |
| operator_arrow_proxy(T &px) |
| : m_value(px) |
| {} |
| |
| T* operator->() const { return &m_value; } |
| // This function is needed for MWCW and BCC, which won't call operator-> |
| // again automatically per 13.3.1.2 para 8 |
| // operator T*() const { return &m_value; } |
| T &m_value; |
| }; |
| |
| template <class Iterator, class UnaryFunction> |
| class transform_iterator |
| : public std::iterator |
| < typename Iterator::iterator_category |
| , typename detail::remove_reference<typename UnaryFunction::result_type>::type |
| , typename Iterator::difference_type |
| , operator_arrow_proxy<typename UnaryFunction::result_type> |
| , typename UnaryFunction::result_type> |
| { |
| public: |
| explicit transform_iterator(const Iterator &it, const UnaryFunction &f = UnaryFunction()) |
| : members_(it, f) |
| {} |
| |
| explicit transform_iterator() |
| : members_() |
| {} |
| |
| Iterator get_it() const |
| { return members_.m_it; } |
| |
| //Constructors |
| transform_iterator& operator++() |
| { increment(); return *this; } |
| |
| transform_iterator operator++(int) |
| { |
| transform_iterator result (*this); |
| increment(); |
| return result; |
| } |
| |
| friend bool operator== (const transform_iterator& i, const transform_iterator& i2) |
| { return i.equal(i2); } |
| |
| friend bool operator!= (const transform_iterator& i, const transform_iterator& i2) |
| { return !(i == i2); } |
| |
| /* |
| friend bool operator> (const transform_iterator& i, const transform_iterator& i2) |
| { return i2 < i; } |
| |
| friend bool operator<= (const transform_iterator& i, const transform_iterator& i2) |
| { return !(i > i2); } |
| |
| friend bool operator>= (const transform_iterator& i, const transform_iterator& i2) |
| { return !(i < i2); } |
| */ |
| friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2) |
| { return i2.distance_to(i); } |
| |
| //Arithmetic |
| transform_iterator& operator+=(typename Iterator::difference_type off) |
| { this->advance(off); return *this; } |
| |
| transform_iterator operator+(typename Iterator::difference_type off) const |
| { |
| transform_iterator other(*this); |
| other.advance(off); |
| return other; |
| } |
| |
| friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right) |
| { return right + off; } |
| |
| transform_iterator& operator-=(typename Iterator::difference_type off) |
| { this->advance(-off); return *this; } |
| |
| transform_iterator operator-(typename Iterator::difference_type off) const |
| { return *this + (-off); } |
| |
| typename UnaryFunction::result_type operator*() const |
| { return dereference(); } |
| |
| operator_arrow_proxy<typename UnaryFunction::result_type> |
| operator->() const |
| { return operator_arrow_proxy<typename UnaryFunction::result_type>(dereference()); } |
| |
| private: |
| struct members |
| : UnaryFunction |
| { |
| members(const Iterator &it, const UnaryFunction &f) |
| : UnaryFunction(f), m_it(it) |
| {} |
| |
| members() |
| {} |
| |
| Iterator m_it; |
| } members_; |
| |
| |
| void increment() |
| { ++members_.m_it; } |
| |
| void decrement() |
| { --members_.m_it; } |
| |
| bool equal(const transform_iterator &other) const |
| { return members_.m_it == other.members_.m_it; } |
| |
| bool less(const transform_iterator &other) const |
| { return other.members_.m_it < members_.m_it; } |
| |
| typename UnaryFunction::result_type dereference() const |
| { return members_(*members_.m_it); } |
| |
| void advance(typename Iterator::difference_type n) |
| { std::advance(members_.m_it, n); } |
| |
| typename Iterator::difference_type distance_to(const transform_iterator &other)const |
| { return std::distance(other.members_.m_it, members_.m_it); } |
| }; |
| |
| } //namespace detail |
| } //namespace intrusive |
| } //namespace boost |
| |
| #include <boost/intrusive/detail/config_end.hpp> |
| |
| #endif //BOOST_INTRUSIVE_DETAIL_TRANSFORM_ITERATOR_HPP |