proxy_iterator.hpp

新版本TR1的stl

    {
        return m_begin;
    }
    /// The proxy iterator endpoint
    ///
    /// \return A pointer to the end point of the proxy iterator
    element_type const  *end() const
    {
        return m_end;
    }
/// @}

/// \name Iterator methods
/// @{
public:
    /// Pre-increment operator
    class_type& operator ++()
    {
        STLSOFT_MESSAGE_ASSERT("Incrementing invalid iterator", m_begin != m_end);

        ++m_begin;

        m_modified = true;

        return *this;
    }
    /// Post-increment operator
    class_type operator ++(int)
    {
        class_type  r(*this);

        operator ++();

        return r;
    }
    /// Pre-decrement operator
    class_type& operator --()
    {
        --m_begin;

        m_modified = true;

        return *this;
    }
    /// Post-decrement operator
    class_type operator --(int)
    {
        class_type  r(*this);

        operator --();

        return r;
    }
    /// Dereference to return a value at the current position of type V
    const_reference operator *() const
    {
        STLSOFT_MESSAGE_ASSERT("Attempting to dereference an invalid iterator", m_begin != m_end);

        if(m_modified)
        {
            // Can't make m_value mutable, as it confuses too many compilers
            remove_const(m_value) = value_type(traits_type::make_value(*m_begin));

            m_modified = false;
        }

        return m_value;
    }

    /// Evaluates whether \c this and \c rhs are equivalent
    ss_bool_t equal(class_type const& rhs) const
    {
        ss_bool_t   bEqual;

        if(m_end == rhs.m_end)
        {
            // It's a copy of the same iterator, so it's only equal if the m_begin's are the tame
            bEqual = m_begin == rhs.m_begin;
        }
        else
        {
            // It's sourced from a different iterator, so they're only the same if they're both closed
            bEqual = (m_begin == m_end) == (rhs.m_begin == rhs.m_end);
        }

        return bEqual;
    }

    ss_ptrdiff_t compare(class_type const& rhs) const
    {
        return m_begin - rhs.m_begin;
    }
/// @}

private:
    element_type            *m_begin;
    element_type            *m_end;
    value_type              m_value;    // Can't make this mutable, as it confuses too many compilers
    ss_mutable_k ss_bool_t  m_modified;
};

/* /////////////////////////////////////////////////////////////////////////
 * Operators
 */

template<   ss_typename_param_k E
        ,   ss_typename_param_k V
        ,   ss_typename_param_k T
        ,   ss_typename_param_k C
        ,   ss_typename_param_k R
        ,   ss_typename_param_k P
        >
inline ss_bool_t operator ==(proxy_iterator<E, V, T, C, R, P> const& lhs, proxy_iterator<E, V, T, C, R, P> const& rhs)
{
    return lhs.equal(rhs);
}

template<   ss_typename_param_k E
        ,   ss_typename_param_k V
        ,   ss_typename_param_k T
        ,   ss_typename_param_k C
        ,   ss_typename_param_k R
        ,   ss_typename_param_k P
        >
inline ss_bool_t operator !=(proxy_iterator<E, V, T, C, R, P> const& lhs, proxy_iterator<E, V, T, C, R, P> const& rhs)
{
    return !lhs.equal(rhs);
}

template<   ss_typename_param_k E
        ,   ss_typename_param_k V
        ,   ss_typename_param_k T
        ,   ss_typename_param_k C
        ,   ss_typename_param_k R
        ,   ss_typename_param_k P
        >
inline proxy_iterator<E, V, T, C, R, P> operator +(proxy_iterator<E, V, T, C, R, P> const& lhs, ss_ptrdiff_t d)
{
    return proxy_iterator<E, V, T, C, R, P>(lhs.begin() + d, lhs.end());
}

template<   ss_typename_param_k E
        ,   ss_typename_param_k V
        ,   ss_typename_param_k T
        ,   ss_typename_param_k C
        ,   ss_typename_param_k R
        ,   ss_typename_param_k P
        >
inline proxy_iterator<E, V, T, C, R, P> operator +(ss_ptrdiff_t d, proxy_iterator<E, V, T, C, R, P> const& rhs)
{
    return proxy_iterator<E, V, T, C, R, P>(rhs.begin() + d, rhs.end());
}

template<   ss_typename_param_k E
        ,   ss_typename_param_k V
        ,   ss_typename_param_k T
        ,   ss_typename_param_k C
        ,   ss_typename_param_k R
        ,   ss_typename_param_k P
        >
inline proxy_iterator<E, V, T, C, R, P> operator -(proxy_iterator<E, V, T, C, R, P> const& lhs, ss_ptrdiff_t d)
{
    return proxy_iterator<E, V, T, C, R, P>(lhs.begin() - d, lhs.end());
}

template<   ss_typename_param_k E
        ,   ss_typename_param_k V
        ,   ss_typename_param_k T
        ,   ss_typename_param_k C
        ,   ss_typename_param_k R
        ,   ss_typename_param_k P
        >
inline ss_ptrdiff_t operator -(proxy_iterator<E, V, T, C, R, P> const& lhs, proxy_iterator<E, V, T, C, R, P> const& rhs)
{
    return rhs.begin() - lhs.begin();
}

template<   ss_typename_param_k E
        ,   ss_typename_param_k V
        ,   ss_typename_param_k T
        ,   ss_typename_param_k C
        ,   ss_typename_param_k R
        ,   ss_typename_param_k P
        >
inline ss_ptrdiff_t operator <(proxy_iterator<E, V, T, C, R, P> const& lhs, proxy_iterator<E, V, T, C, R, P> const& rhs)
{
    return lhs.compare(rhs) < 0;
}

template<   ss_typename_param_k E
        ,   ss_typename_param_k V
        ,   ss_typename_param_k T
        ,   ss_typename_param_k C
        ,   ss_typename_param_k R
        ,   ss_typename_param_k P
        >
inline ss_ptrdiff_t operator <=(proxy_iterator<E, V, T, C, R, P> const& lhs, proxy_iterator<E, V, T, C, R, P> const& rhs)
{
    return lhs.compare(rhs) <= 0;
}

template<   ss_typename_param_k E
        ,   ss_typename_param_k V
        ,   ss_typename_param_k T
        ,   ss_typename_param_k C
        ,   ss_typename_param_k R
        ,   ss_typename_param_k P
        >
inline ss_ptrdiff_t operator >(proxy_iterator<E, V, T, C, R, P> const& lhs, proxy_iterator<E, V, T, C, R, P> const& rhs)
{
    return lhs.compare(rhs) > 0;
}


template<   ss_typename_param_k E
        ,   ss_typename_param_k V
        ,   ss_typename_param_k T
        ,   ss_typename_param_k C
        ,   ss_typename_param_k R
        ,   ss_typename_param_k P
        >
inline ss_ptrdiff_t operator >=(proxy_iterator<E, V, T, C, R, P> const& lhs, proxy_iterator<E, V, T, C, R, P> const& rhs)
{
    return lhs.compare(rhs) >= 0;
}

/* /////////////////////////////////////////////////////////////////////////
 * Warnings
 */

#if defined(STLSOFT_COMPILER_IS_MSVC)
# if _MSC_VER >= 1200
#  pragma warning(pop)
# else /* ? compiler */
#  pragma warning(default: 4355)
# endif /* _MSC_VER */
#endif /* compiler */

/* ////////////////////////////////////////////////////////////////////// */

#ifndef _STLSOFT_NO_NAMESPACE
} /* namespace stlsoft */
#endif /* _STLSOFT_NO_NAMESPACE */

/* ////////////////////////////////////////////////////////////////////// */

#endif /* !STLSOFT_INCL_STLSOFT_OBSOLETE_HPP_PROXY_ITERATOR */

/* ////////////////////////////////////////////////////////////////////// */