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
{};
 
// OPERATIONS
 
namespace {
 
    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, 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;
}
 
namespace {
 
    template <class RandomAccessIterator>
    inline int distance(RandomAccessIterator &first, const RandomAccessIterator &last, RandomAccessIteratorTag)
    {
        return last - first;
    }
 
    template <class ForwardIterator>
    inline int distance(ForwardIterator &first, const ForwardIterator &last, ForwardIteratorTag)
    {
        int counter = 0;
 
        for (; first != last; ++first)
            counter++;
 
        return counter;
    }
 
}
 
template <class Iterator>
inline int distance(Iterator first, const Iterator last)
{
    return distance(first, last, 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