multiple_array_iterator.hh

#ifndef VTESTBED_BASE_MULTIPLE_ARRAY_ITERATOR_HH
#define VTESTBED_BASE_MULTIPLE_ARRAY_ITERATOR_HH

#include <array>
#include <cstddef>
#include <initializer_list>
#include <iterator>
#include <utility>

namespace vtb {

    namespace base {

        template <class Iterator, size_t N>
        class multiple_array_iterator {

            static_assert(N > 0, "bad N");

        private:
            typedef Iterator base_iterator;
            typedef std::iterator_traits<Iterator> traits_type;
            typedef std::pair<Iterator,Iterator> pair_type;
            typedef std::array<pair_type,N> pointer_array;

        public:
            typedef typename traits_type::value_type value_type;
            typedef typename traits_type::difference_type difference_type;
            typedef typename traits_type::pointer pointer;
            typedef typename traits_type::reference reference;
            typedef std::size_t size_type;
            typedef std::forward_iterator_tag iterator_category;
            typedef const pointer const_pointer;
            typedef const reference const_reference;

        private:
            pointer_array _ptrs;
            Iterator _ptr = nullptr;
            size_type _index = 0;

        public:

            template <class ... Args>
            inline
            multiple_array_iterator(const Args& ... ptrs):
            _ptrs{ptrs...}, _ptr(_ptrs.front().first) { this->advance_empty(); }

            template <class ... Args>
            inline
            multiple_array_iterator(int, const Args& ... ptrs):
            _ptrs{ptrs...}, _ptr(_ptrs.back().second), _index(N) {}

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

            inline bool
            operator==(const multiple_array_iterator& rhs) const {
                return this->_ptr == rhs._ptr && this->_index == rhs._index;
            }

            inline bool
            operator!=(const multiple_array_iterator& rhs) const {
                return !this->operator==(rhs);
            }

            inline pointer operator->() { return this->_ptr; }
            inline const_pointer operator->() const { return this->_ptr; }
            inline reference operator*() { return *this->_ptr; }
            inline const_reference operator*() const { return *this->_ptr; }

            inline reference
            operator++() {
                const auto& ptrs = this->_ptrs;
                auto& i = this->_index;
                auto& ptr = this->_ptr;
                if (i != N && ++ptr == ptrs[i].second && ++i != N) {
                    ptr = ptrs[i].first;
                    this->advance_empty();
                }
                return *ptr;
            }

            inline multiple_array_iterator
            operator++(int) {
                multiple_array_iterator tmp(*this);
                this->operator++();
                return *tmp;
            }

        private:

            inline void
            advance_empty() {
                const auto& ptrs = this->_ptrs;
                auto& i = this->_index;
                auto& ptr = this->_ptr;
                while (i != N && ptrs[i].first == ptrs[i].second) {
                    ptr = ptrs[++i].first;
                }
            }

        };

    }

}

#endif // vim:filetype=cpp