SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT > Class Template Reference

#include <iterator.h>

Inheritance diagram for SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >:

Classes
class	ReferenceProxy

Public Types
using	iterator_category = IteratorCategoryT
using	value_type = T
using	difference_type = DifferenceTypeT
using	pointer = PointerT
using	reference = ReferenceT

Public Member Functions
DerivedT	operator+ (DifferenceTypeT n) const
DerivedT	operator- (DifferenceTypeT n) const
DerivedT &	operator++ ()
DerivedT	operator++ (int)
DerivedT &	operator-- ()
DerivedT	operator-- (int)
bool	operator!= (const DerivedT &RHS) const
bool	operator> (const DerivedT &RHS) const
bool	operator<= (const DerivedT &RHS) const
bool	operator>= (const DerivedT &RHS) const
PointerT	operator-> ()
PointerT	operator-> () const
ReferenceProxy	operator[] (DifferenceTypeT n)
ReferenceProxy	operator[] (DifferenceTypeT n) const

Protected Types
enum	{ IsRandomAccess , IsBidirectional }

Friends
DerivedT	operator+ (DifferenceTypeT n, const DerivedT &i)

Detailed Description

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>
class SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >

CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of the interface.

Use this when it is reasonable to implement most of the iterator functionality in terms of a core subset. If you need special behavior or there are performance implications for this, you may want to override the relevant members instead.

Note, one abstraction that this does not provide is implementing subtraction in terms of addition by negating the difference. Negation isn't always information preserving, and I can see very reasonable iterator designs where this doesn't work well. It doesn't really force much added boilerplate anyways.

Another abstraction that this doesn't provide is implementing increment in terms of addition of one. These aren't equivalent for all iterator categories, and respecting that adds a lot of complexity for little gain.

Classes wishing to use iter_facade_base should implement the following methods:

Forward Iterators: (All of the following methods)

• DerivedT &operator=(const DerivedT &R);
• bool operator==(const DerivedT &R) const;
• const T &operator*() const;
• T &operator*();
• DerivedT &operator++();

Bidirectional Iterators: (All methods of forward iterators, plus the following)

• DerivedT &operator--();

Random-access Iterators: (All methods of bidirectional iterators excluding the following)

• DerivedT &operator++();
• DerivedT &operator--(); (and plus the following)
• bool operator<(const DerivedT &RHS) const;
• DifferenceTypeT operator-(const DerivedT &R) const;
• DerivedT &operator+=(DifferenceTypeT N);
• DerivedT &operator-=(DifferenceTypeT N);

Definition at line 67 of file iterator.h.

Member Typedef Documentation

difference_type

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

using SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::difference_type = DifferenceTypeT

Definition at line 72 of file iterator.h.

iterator_category

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

using SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::iterator_category = IteratorCategoryT

Definition at line 70 of file iterator.h.

pointer

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

using SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::pointer = PointerT

Definition at line 73 of file iterator.h.

reference

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

using SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::reference = ReferenceT

Definition at line 74 of file iterator.h.

value_type

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

using SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::value_type = T

Definition at line 71 of file iterator.h.

Member Enumeration Documentation

anonymous enum

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

anonymous enum

protected

Enumerator
IsRandomAccess
IsBidirectional

Definition at line 77 of file iterator.h.

    {
        IsRandomAccess = std::is_base_of<std::random_access_iterator_tag,
        IteratorCategoryT>::value,
        IsBidirectional = std::is_base_of<std::bidirectional_iterator_tag,
        IteratorCategoryT>::value,
    };

Member Function Documentation

operator!=()

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

bool SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator!= ( const DerivedT & RHS ) const

inline

Definition at line 164 of file iterator.h.

    {
        return !(static_cast<const DerivedT &>(*this) == RHS);
    }

operator+()

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

DerivedT SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator+ ( DifferenceTypeT n ) const

inline

Definition at line 106 of file iterator.h.

    {
        static_assert(std::is_base_of<iter_facade_base, DerivedT>::value,
                      "Must pass the derived type to this template!");
        static_assert(
            IsRandomAccess,
            "The '+' operator is only defined for random access iterators.");
        DerivedT tmp = *static_cast<const DerivedT *>(this);
        tmp += n;
        return tmp;
    }

operator++() [1/2]

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

DerivedT & SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator++ ( )

inline

Definition at line 134 of file iterator.h.

    {
        static_assert(std::is_base_of<iter_facade_base, DerivedT>::value,
                      "Must pass the derived type to this template!");
        return static_cast<DerivedT *>(this)->operator+=(1);
    }

operator++() [2/2]

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

DerivedT SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator++ ( int )

inline

Definition at line 140 of file iterator.h.

    {
        DerivedT tmp = *static_cast<DerivedT *>(this);
        ++*static_cast<DerivedT *>(this);
        return tmp;
    }

operator-()

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

DerivedT SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator- ( DifferenceTypeT n ) const

inline

Definition at line 124 of file iterator.h.

    {
        static_assert(
            IsRandomAccess,
            "The '-' operator is only defined for random access iterators.");
        DerivedT tmp = *static_cast<const DerivedT *>(this);
        tmp -= n;
        return tmp;
    }

operator--() [1/2]

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

DerivedT & SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator-- ( )

inline

Definition at line 146 of file iterator.h.

    {
        static_assert(
            IsBidirectional,
            "The decrement operator is only defined for bidirectional iterators.");
        return static_cast<DerivedT *>(this)->operator-=(1);
    }

operator--() [2/2]

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

DerivedT SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator-- ( int )

inline

Definition at line 153 of file iterator.h.

    {
        static_assert(
            IsBidirectional,
            "The decrement operator is only defined for bidirectional iterators.");
        DerivedT tmp = *static_cast<DerivedT *>(this);
        --*static_cast<DerivedT *>(this);
        return tmp;
    }

operator->() [1/2]

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

PointerT SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator-> ( )

inline

Definition at line 193 of file iterator.h.

    {
        return &static_cast<DerivedT *>(this)->operator*();
    }

operator->() [2/2]

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

PointerT SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator-> ( ) const

inline

Definition at line 197 of file iterator.h.

    {
        return &static_cast<const DerivedT *>(this)->operator*();
    }

operator<=()

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

bool SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator<= ( const DerivedT & RHS ) const

inline

Definition at line 178 of file iterator.h.

    {
        static_assert(
            IsRandomAccess,
            "Relational operators are only defined for random access iterators.");
        return !(static_cast<const DerivedT &>(*this) > RHS);
    }

operator>()

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

bool SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator> ( const DerivedT & RHS ) const

inline

Definition at line 170 of file iterator.h.

    {
        static_assert(
            IsRandomAccess,
            "Relational operators are only defined for random access iterators.");
        return !(static_cast<const DerivedT &>(*this) < RHS) &&
               !(static_cast<const DerivedT &>(*this) == RHS);
    }

operator>=()

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

bool SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator>= ( const DerivedT & RHS ) const

inline

Definition at line 185 of file iterator.h.

    {
        static_assert(
            IsRandomAccess,
            "Relational operators are only defined for random access iterators.");
        return !(static_cast<const DerivedT &>(*this) < RHS);
    }

operator[]() [1/2]

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

ReferenceProxy SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator[] ( DifferenceTypeT n )

inline

Definition at line 201 of file iterator.h.

    {
        static_assert(IsRandomAccess,
                      "Subscripting is only defined for random access iterators.");
        return ReferenceProxy(static_cast<DerivedT *>(this)->operator+(n));
    }

operator[]() [2/2]

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

ReferenceProxy SVF::iter_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::operator[] ( DifferenceTypeT n ) const

inline

Definition at line 207 of file iterator.h.

    {
        static_assert(IsRandomAccess,
                      "Subscripting is only defined for random access iterators.");
        return ReferenceProxy(static_cast<const DerivedT *>(this)->operator+(n));
    }

Friends And Related Symbol Documentation

operator+

template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *, typename ReferenceT = T &>

DerivedT operator+ ( DifferenceTypeT n, const DerivedT & i )

friend

Definition at line 117 of file iterator.h.

    {
        static_assert(
            IsRandomAccess,
            "The '+' operator is only defined for random access iterators.");
        return i + n;
    }

---

The documentation for this class was generated from the following file:

• /home/runner/work/SVF/SVF/svf/include/Util/iterator.h