Iterator¶

digraph g {
CopyConstructible -> Iterator;
CopyAssignable -> Iterator;
Destructible -> Iterator;
Swappable -> Iterator;
}

Requirements¶

requires(It r)
{
        {*r};
        {++r} -> It &;
}

InputIterator¶

digraph g {
Iterator -> InputIterator;
EqualityComparable -> InputIterator;
}

Requirements¶

requires(It i, It j)
{
        {i != j} -> bool;
        {*i} -> typename std::iterator_traits<It>::reference;
        {*i++} -> typename std::iterator_traits<It>::value_type;
        //{i->m};
}

OutputIterator¶

digraph g {
Iterator -> OutputIterator;
}

Requirements¶

requires(It r)//, Writable o, Writable a)
{
        {++r} -> It &;
        {r++} -> It;
        //{*r = o};
        //{*r++ = o};
}

ForwardIterator¶

digraph g {
InputIterator -> ForwardIterator;
DefaultConstructible -> ForwardIterator;
OutputIterator -> ForwardIterator [style=dotted];
}

Requirements¶

requires(It r)//, Writable o, Writable a)
{
        {++r} -> It &;
        {r++} -> It;
        //{*r = o};
        //{*r++ = o};
}

Additional Notes¶

Iff ForwardIterator satisfies OutputIterator, the type std::iterator_traits<It>::reference is a const reference.

BidirectionalIterator¶

digraph g {
ForwardIterator -> BidirectionalIterator;
}

Requirements¶

requires(It a)
{
        {--a} -> It &;
        {a--} -> It;
        {*a--} -> typename std::iterator_traits<It>::reference;
}

RandomAccessIterator¶

digraph g {
BidirectionalIterator -> RandomAccessIterator;
}

Requirements¶

requires(It i,
         It a,
         It b,
         It &r,
         typename std::iterator_traits<It>::difference_type n)
{
        {r + n}  -> It;
        {a + n}  -> It;
        {n + a}  -> It;

        {r -= n} -> It &;
        {i - n}  -> It;
        {b - a}  -> typename std::iterator_traits<It>::difference_type;
        {i[n]}   -> typename std::iterator_traits<It>::reference;
}

MutableIterator¶

digraph g {
InputIterator -> MutableIterator;
OutputIterator -> MutableIterator;
}

ValueSwappable¶

digraph g {
Iterator -> ValueSwappable;
}

Requirements¶

requires(T t, T u) { {std::swap(*t, *u)}; } ||
requires(T t, T u) { {swap(*t, *u) }; };