iterator.h

#ifndef NCTL_ITERATOR
#define NCTL_ITERATOR
 
namespace nctl {
 
struct ForwardIteratorTag
{};
struct BidirectionalIteratorTag : public ForwardIteratorTag
{};
struct RandomAccessIteratorTag : public BidirectionalIteratorTag
{};
 
template <class Iterator>
struct IteratorTraits
{};
 
template <class T>
struct IteratorTraits<T *>
{
    using ValueType = T;
    using Pointer = T *;
    using Reference = T &;
    using IteratorCategory = RandomAccessIteratorTag;
};
 
template <class T>
struct IteratorTraits<const T *>
{
    using ValueType = T;
    using Pointer = const T *;
    using Reference = const T &;
    using IteratorCategory = RandomAccessIteratorTag;
};
 
// OPERATIONS
 
template <class Iterator>
inline void advance(Iterator &it, int n, RandomAccessIteratorTag)
{
    it += n;
}
 
template <class Iterator>
inline void advance(Iterator &it, int n, BidirectionalIteratorTag)
{
    if (n < 0)
    {
        while (n++)
            --it;
    }
    else
    {
        while (n--)
            ++it;
    }
}
 
template <class Iterator>
inline void advance(Iterator &it, int n, ForwardIteratorTag)
{
    if (n > 0)
    {
        while (n--)
            ++it;
    }
}
 
template <class Iterator>
inline void advance(Iterator &it, int n)
{
    advance(it, n, typename IteratorTraits<Iterator>::IteratorCategory());
}
 
template <class Iterator>
inline Iterator next(Iterator it, unsigned int n)
{
    advance(it, n);
    return it;
}
 
template <class Iterator>
inline Iterator next(Iterator it)
{
    advance(it, 1);
    return it;
}
 
template <class Iterator>
inline Iterator prev(Iterator it, unsigned int n)
{
    advance(it, -n);
    return it;
}
 
template <class Iterator>
inline Iterator prev(Iterator it)
{
    advance(it, -1);
    return it;
}
 
template <class RandomAccessIterator>
inline int distance(RandomAccessIterator first, RandomAccessIterator last, RandomAccessIteratorTag)
{
    return last - first;
}
 
template <class ForwardIterator>
inline int distance(ForwardIterator first, ForwardIterator last, ForwardIteratorTag)
{
    int counter = 0;
 
    for (; first != last; ++first)
        counter++;
 
    return counter;
}
 
template <class Iterator>
inline int distance(Iterator first, Iterator last)
{
    return distance(first, last, typename IteratorTraits<Iterator>::IteratorCategory());
}
 
// REVERSE RANGE ADAPTER
 
template <class T>
struct ReversionWrapper
{
    T &iterable;
};
 
template <class T>
auto begin(ReversionWrapper<T> c) -> decltype(rBegin(c.iterable))
{
    return rBegin(c.iterable);
}
 
template <class T>
auto end(ReversionWrapper<T> c) -> decltype(rEnd(c.iterable))
{
    return rEnd(c.iterable);
}
 
template <class T>
ReversionWrapper<T> reverse(T &&iterable)
{
    return { iterable };
}
 
// RANGE
 
template <class Container>
typename Container::Iterator begin(Container &c)
{
    return c.begin();
}
 
template <class Container>
typename Container::ConstIterator cBegin(const Container &c)
{
    return c.begin();
}
 
template <class Container>
typename Container::Iterator end(Container &c)
{
    return c.end();
}
 
template <class Container>
typename Container::ConstIterator cEnd(const Container &c)
{
    return c.end();
}
 
template <class Container>
typename Container::ReverseIterator rBegin(Container &c)
{
    return c.rBegin();
}
 
template <class Container>
typename Container::ConstReverseIterator crBegin(const Container &c)
{
    return c.rBegin();
}
 
template <class Container>
typename Container::ReverseIterator rEnd(Container &c)
{
    return c.rEnd();
}
 
template <class Container>
typename Container::ConstReverseIterator crEnd(const Container &c)
{
    return c.rEnd();
}
 
}
 
#endif