iterator.hpp

Go to the documentation of this file.

#ifndef GENERATOR_ITERATOR_HPP
#define GENERATOR_ITERATOR_HPP
 
#include <cassert>
#include <stdexcept>
#include <type_traits>
#include <utility>
 
#include "utils.hpp"
 
namespace generator
{
 
template<typename generator_t, typename = std::void_t<decltype(std::declval<const generator_t>().generate())>>
class gen_iterator_t
{
private:
    generator_t* generator_;
 
    typename generated_type<generator_t>::type value_;
 
public:
    using iterator_category = std::input_iterator_tag;
 
    using value_type = typename generated_type<generator_t>::type;
 
    using difference_type = std::ptrdiff_t;
 
    using pointer = value_type*;
 
    using reference = value_type&;
 
    gen_iterator_t() noexcept : generator_{nullptr}, value_{}
    {
    }
 
    gen_iterator_t(generator_t& generator) noexcept : generator_{&generator}, value_{}
    {
        if(generator_->done())
            generator_ = nullptr;
        else
            value_ = generator_->generate();
    }
 
    gen_iterator_t& operator++()
    {
        if(!generator_)
            throw std::out_of_range("Iterator out of range!");
        generator_->next();
        if(generator_->done())
            generator_ = nullptr;
        else
            value_ = generator_->generate();
        return *this;
    }
 
    const typename gen_iterator_t::value_type& operator*() const
    {
        if(!generator_)
            throw std::out_of_range("Iterator out of range!");
        return value_;
    }
 
    const typename gen_iterator_t::value_type* operator->() const
    {
        if(!generator_)
            throw std::out_of_range("Iterator out of range!");
        return &value_;
    }
 
    bool operator==(const gen_iterator_t& that) const noexcept
    {
        return generator_ == that.generator_;
    }
 
    bool operator!=(const gen_iterator_t& that) const noexcept
    {
        return generator_ != that.generator_;
    }
};
 
template<typename generator_t, typename = std::void_t<decltype(std::declval<const generator_t>().generate())>>
gen_iterator_t<generator_t> begin(generator_t& generator) noexcept
{
    return gen_iterator_t<generator_t>{generator};
}
 
template<typename generator_t, typename = std::void_t<decltype(std::declval<const generator_t>().generate())>>
gen_iterator_t<generator_t> end(const generator_t&) noexcept
{
    return gen_iterator_t<generator_t>{};
}
} // namespace generator
 
#endif