iterator.hpp

Go to the documentation of this file.

//=======================================================================
// Copyright (c) 2014-2023 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
//  http://opensource.org/licenses/MIT)
//=======================================================================

#pragma once

#include <iterator>

namespace etl {

template <typename Expr>
struct iterator {
private:
    Expr* expr; 
    size_t i;   

public:
    using iterator_category = std::random_access_iterator_tag;
    using value_type        = value_t<Expr>;                                         
    using reference         = decltype(std::declval<Expr>()[i]);                     
    using pointer           = std::add_pointer_t<decltype(std::declval<Expr>()[i])>; 
    using difference_type   = size_t;                                                

    iterator(Expr& expr, size_t i) : expr(&expr), i(i) {}

    reference operator*() {
        return (*expr)[i];
    }

    reference operator[](difference_type n) {
        return (*expr)[i + n];
    }

    auto operator-> () {
        return &(*expr)[i];
    }

    iterator& operator--() {
        --i;
        return *this;
    }

    iterator operator--(int) {
        iterator prev(*this);
        --i;
        return prev;
    }

    iterator& operator++() {
        ++i;
        return *this;
    }

    iterator operator++(int) {
        iterator prev(*this);
        ++i;
        return prev;
    }

    iterator& operator+=(difference_type n) {
        i += n;
        return *this;
    }

    iterator& operator-=(difference_type n) {
        i -= n;
        return *this;
    }

    iterator operator+(difference_type n) {
        iterator it(*this);
        it += n;
        return it;
    }

    iterator operator-(difference_type n) {
        iterator it(*this);
        it -= n;
        return it;
    }

    difference_type operator-(const iterator& it) {
        return i - it.i;
    }

    bool operator==(const iterator& other) const {
        return expr == other.expr && i == other.i;
    }

    bool operator!=(const iterator& other) const {
        return !(*this == other);
    }

    bool operator>(const iterator& other) const {
        return i > other.i;
    }

    bool operator>=(const iterator& other) const {
        return i >= other.i;
    }

    bool operator<(const iterator& other) const {
        return i < other.i;
    }

    bool operator<=(const iterator& other) const {
        return i <= other.i;
    }
};

} //end of namespace etl