simplepointeriterator.h

Go to the documentation of this file.

 
#ifndef _SIMPLE_POINTER_ITERATOR_CLASS_HEADER_
#define _SIMPLE_POINTER_ITERATOR_CLASS_HEADER_
 
#include <iterator>
#include <cstddef>
 
namespace A_UTILS_NS
{
 
template<typename TypeT>
class simple_pointer_iterator
{
protected:
    TypeT* m_pData;
public:
    typedef std::random_access_iterator_tag iterator_category;
    typedef TypeT value_type;
    typedef std::ptrdiff_t difference_type;
    typedef TypeT& reference;
    typedef TypeT* pointer;
 
    simple_pointer_iterator() : m_pData(nullptr)
    {
    }
 
    template<typename T2>
    simple_pointer_iterator(const simple_pointer_iterator<T2>& r) : m_pData(&(*r))
    {
    }
 
    simple_pointer_iterator(pointer pData) : m_pData(pData)
    {
    }
 
    template<typename T2>
    simple_pointer_iterator& operator=(const simple_pointer_iterator<T2>& r)
    {
        m_pData = &(*r); return *this;
    }
 
    simple_pointer_iterator& operator++()  // PREFIX
    {
        ++m_pData; return *this;
    }
    simple_pointer_iterator& operator--()  // PREFIX
    {
        --m_pData; return *this;
    }
    simple_pointer_iterator operator++(tInt)  // POSTFIX
    {
        return simple_pointer_iterator(m_pData++);
    }
    simple_pointer_iterator operator--(tInt)  // POSTFIX
    {
        return simple_pointer_iterator(m_pData--);
    }
    simple_pointer_iterator operator+(const difference_type& n) const
    {
        return simple_pointer_iterator(m_pData + n);
    }
    simple_pointer_iterator& operator+=(const difference_type& n)
    {
        m_pData += n;
        return *this;
    }
    simple_pointer_iterator operator-(const difference_type& n) const
    {
        return simple_pointer_iterator(pointer(m_pData - n));
    }
    simple_pointer_iterator& operator-=(const difference_type& n)
    {
        m_pData -= n;
        return *this;
    }
    reference operator*() const
    {
        return *m_pData;
    }
    reference operator->() const
    {
        return *m_pData;
    }
    reference operator[](const difference_type& n) const
    {
        return m_pData[n];
    }
 
    template<typename T>
    friend bool operator==(const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2);
 
    template<typename T>
    friend bool operator!=(const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2);
 
    template<typename T>
    friend bool operator<(const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2);
 
    template<typename T>
    friend bool operator>(const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2);
 
    template<typename T>
    friend bool operator<=(const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2);
 
    template<typename T>
    friend bool operator>=(const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2);
 
    template<typename T>
    friend typename simple_pointer_iterator<T>::difference_type operator+(
        const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2);
 
    template<typename T>
    friend typename simple_pointer_iterator<T>::difference_type operator-(
        const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2);
};
 
template<typename T>
bool operator==(const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2)
{
    return (r1.m_pData == r2.m_pData);
}
 
template<typename T>
bool operator!=(const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2)
{
    return (r1.m_pData != r2.m_pData);
}
 
template<typename T>
bool operator<(const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2)
{
    return (r1.m_pData < r2.m_pData);
}
 
template<typename T>
bool operator>(const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2)
{
    return (r1.m_pData > r2.m_pData);
}
 
template<typename T>
bool operator<=(const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2)
{
    return (r1.m_pData <= r2.m_pData);
}
 
template<typename T>
bool operator>=(const simple_pointer_iterator<T>& r1, const simple_pointer_iterator<T>& r2)
{
    return (r1.m_pData >= r2.m_pData);
}
 
template<typename T>
typename simple_pointer_iterator<T>::difference_type operator+(const simple_pointer_iterator<T>& r1,
                                                              const simple_pointer_iterator<T>& r2)
{
    return simple_pointer_iterator<T>(r1.m_pData + r2.m_pData);
}
 
template<typename T>
typename simple_pointer_iterator<T>::difference_type operator-(const simple_pointer_iterator<T>& r1,
                                                              const simple_pointer_iterator<T>& r2)
{
    return r1.m_pData - r2.m_pData;
}
 
 
 
 
 
} // namespace A_UTILS_NS
 
 
 
 
#endif // _SIMPLE_POINTER_ITERATOR_CLASS_HEADER_