range.h

Go to the documentation of this file.

#ifndef META_UTIL_RANGE_H_
#define META_UTIL_RANGE_H_

#include <cmath>
#include <iterator>

namespace meta
{
namespace util
{

template <class T>
class basic_range
{
  public:
    template <class Plus>
    class iterator_t
    {
      public:
        using self_type = iterator_t;
        using value_type = T;
        using reference = const T&;
        using pointer = const T*;
        using iterator_category = std::forward_iterator_tag;
        using difference_type = std::ptrdiff_t;

        friend class basic_range<T>;

        self_type& operator++()
        {
            _curr = _plus(_curr, _range->_step);
            ++_idx;
            return *this;
        }

        self_type operator++(int)
        {
            self_type temp = *this;
            ++(*this);
            return temp;
        }

        reference operator*()
        {
            return _curr;
        }

        pointer operator->()
        {
            return &_curr;
        }

        friend bool operator==(const iterator_t& lhs, const iterator_t& rhs)
        {
            return lhs._range == rhs._range && lhs._idx == rhs._idx;
        }

        friend bool operator!=(const iterator_t& lhs, const iterator_t& rhs)
        {
            return !(lhs == rhs);
        }

      private:
        iterator_t(const basic_range<T>* range, const T& start, size_t idx)
            : _curr(start), _idx(idx), _range(range)
        {
            // nothing
        }

        T _curr;
        size_t _idx;
        Plus _plus;
        const basic_range<T>* _range;
    };

    using iterator = iterator_t<std::plus<T>>;
    using const_iterator = iterator;

    using reverse_iterator = iterator_t<std::minus<T>>;
    using const_reverse_iterator = reverse_iterator;

    friend iterator;
    friend reverse_iterator;

    iterator begin() const
    {
        return iterator(this, _begin, 0);
    }

    iterator end() const
    {
        return iterator(this, _end, _num);
    }

    reverse_iterator rbegin() const
    {
        return reverse_iterator(this, _end, 0);
    }

    reverse_iterator rend() const
    {
        return reverse_iterator(this, _begin, _num);
    }

    basic_range(const T& begin, const T& end, const T& step)
        : _begin(begin), _end(end), _num((end - begin) / step + 1), _step(step)
    {
        // nothing
    }

    basic_range(const basic_range&) = default;
    basic_range(basic_range&&) = default;
    basic_range& operator=(const basic_range&) = default;
    basic_range& operator=(basic_range&&) = default;

    ~basic_range() = default;

  private:
    T _begin;
    T _end;
    size_t _num;
    T _step;
};

template <class T>
basic_range<T> range(const T& begin, const T& end)
{
    return basic_range<T>(begin, end, T{1});
}

template <class T>
basic_range<T> range(const T& begin, const T& end, const T& step)
{
    return basic_range<T>(begin, end, step);
}
}
}

#endif