marvin_StrideView.h

Go to the documentation of this file.

// ========================================================================================================
//  _______ _______ ______ ___ ___ _______ _______
// |   |   |   _   |   __ \   |   |_     _|    |  |
// |       |       |      <   |   |_|   |_|       |
// |__|_|__|___|___|___|__|\_____/|_______|__|____|
//
// This file is part of the Marvin open source library and is licensed under the terms of the MIT License.
//
// ========================================================================================================
 
#ifndef MARVIN_STRIDED_VIEW
#define MARVIN_STRIDED_VIEW
#include <type_traits>
#include <iterator>
#include <span>
#include <vector>
namespace marvin::containers {
    template <typename T, size_t Stride>
    requires(Stride > 0)
    class StrideView final {
    public:
        class iterator final {
        public:
            using value_type = T;
            using difference_type = std::ptrdiff_t;
            using pointer = T*;
            using reference = T&;
            using iterator_category = std::forward_iterator_tag;

            iterator() = delete;

            iterator(pointer ptr) : m_internal(ptr) {
            }

            operator bool() const {
                return m_internal;
            }

            reference operator*() const {
                return *m_internal;
            }

            pointer operator->() const {
                return m_internal;
            }

            iterator& operator++() {
                m_internal += Stride;
                return *this;
            }

            iterator operator++(int) {
                auto temp = *this;
                m_internal += Stride;
                return temp;
            }

            iterator& operator--() {
                m_internal -= Stride;
                return *this;
            }

            iterator operator--(int) {
                auto temp = *this;
                m_internal -= Stride;
                return temp;
            }

            iterator& operator+=(difference_type n) {
                const auto stridedN = Stride * n;
                m_internal += stridedN;
                return *this;
            }

            iterator& operator-=(difference_type n) {
                const auto stridedN = Stride * n;
                m_internal -= stridedN;
                return *this;
            }

            friend bool operator==(const iterator& lhs, const iterator& rhs) {
                return lhs.m_internal == rhs.m_internal;
            }

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

            friend bool operator<(const iterator& lhs, const iterator& rhs) {
                return lhs.m_internal < rhs.m_internal;
            }

            friend bool operator>(const iterator& lhs, const iterator& rhs) {
                return lhs.m_internal > rhs.m_internal;
            }

            friend bool operator<=(const iterator& lhs, const iterator& rhs) {
                return lhs.m_internal <= rhs.m_internal;
            }

            friend bool operator>=(const iterator& lhs, const iterator& rhs) {
                return lhs.m_internal >= rhs.m_internal;
            }

            friend iterator operator+(const iterator& iter, difference_type n) {
                iterator temp = iter;
                temp += n;
                return temp;
            }

            friend iterator operator+(difference_type n, const iterator& iter) {
                return iter + n;
            }

            friend iterator operator-(const iterator& iter, difference_type n) {
                iterator temp = iter;
                temp -= n;
                return temp;
            }

            friend difference_type operator-(const iterator& lhs, const iterator& rhs) {
                return lhs.m_internal - rhs.m_internal;
            }
 
        private:
            T* m_internal{ nullptr };
        };

        class const_iterator {
        public:
            using value_type = T;
            using difference_type = std::ptrdiff_t;
            using pointer = T*;
            using reference = T&;
            using iterator_category = std::forward_iterator_tag;

            const_iterator() = delete;

            const_iterator(pointer ptr) : m_internal(ptr) {
            }

            operator bool() const {
                return m_internal;
            }

            const T& operator*() const {
                return *m_internal;
            }

            const T* operator->() const {
                return m_internal;
            }

            const_iterator& operator++() {
                m_internal += Stride;
                return *this;
            }

            const_iterator operator++(int) {
                auto temp = *this;
                m_internal += Stride;
                return temp;
            }

            const_iterator& operator--() {
                m_internal -= Stride;
                return *this;
            }

            const_iterator operator--(int) {
                auto temp = *this;
                m_internal -= Stride;
                return *this;
            }

            const_iterator& operator+=(difference_type n) {
                const auto stridedDiff = n * Stride;
                m_internal += stridedDiff;
                return *this;
            }

            const_iterator& operator-=(difference_type n) {
                const auto stridedDiff = n * Stride;
                m_internal -= stridedDiff;
                return *this;
            }

            friend bool operator==(const const_iterator& lhs, const const_iterator& rhs) {
                return lhs.m_internal == rhs.m_internal;
            }

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

            friend bool operator<(const const_iterator& lhs, const const_iterator& rhs) {
                return lhs.m_internal < rhs.m_internal;
            }

            friend bool operator>(const const_iterator& lhs, const const_iterator& rhs) {
                return lhs.m_internal > rhs.m_internal;
            }

            friend bool operator<=(const const_iterator& lhs, const const_iterator& rhs) {
                return lhs.m_internal <= rhs.m_internal;
            }

            friend bool operator>=(const const_iterator& lhs, const const_iterator& rhs) {
                return lhs.m_internal >= rhs.m_internal;
            }

            friend const_iterator operator+(const const_iterator& iter, difference_type n) {
                const_iterator temp = iter;
                temp += n;
                return temp;
            }

            friend const_iterator operator+(difference_type n, const const_iterator& iter) {
                return iter + n;
            }

            friend const_iterator operator-(const const_iterator& iter, difference_type n) {
                const_iterator temp = iter;
                temp -= n;
                return temp;
            }

            friend const_iterator operator-(const const_iterator& lhs, const const_iterator& rhs) {
                return lhs.m_internal - rhs.m_internal;
            }
 
 
        private:
            pointer m_internal{ nullptr };
        };
 

        StrideView(T* data, size_t size) : m_internalView(data, size) {
        }

        template <std::input_or_output_iterator Iter>
        requires std::is_same_v<typename Iter::value_type, T>
        StrideView(Iter begin, Iter end) {
            // Apple clang don't have a constructor for spans that takes iterators yet...
            const auto size = static_cast<size_t>(std::distance(begin, end));
            const auto data = &(*begin);
            m_internalView = { data, size };
        }

        explicit StrideView(std::span<T> arrayLike) : m_internalView(arrayLike) {
        }

        [[nodiscard]] size_t size() const noexcept {
            const auto stridedSize = m_internalView.size() / Stride;
            return stridedSize;
        }

        T& operator[](size_t idx) {
            const auto stridedIdx = Stride * idx;
            return m_internalView[stridedIdx];
        }

        const T& operator[](size_t idx) const {
            const auto stridedIdx = Stride * idx;
            return m_internalView[stridedIdx];
        }

        iterator begin() {
            auto* ptr = &(*m_internalView.begin());
            return iterator{ ptr };
        }

        const_iterator begin() const {
            auto* ptr = &(*m_internalView.begin());
            return const_iterator{ ptr };
        }

        const_iterator cbegin() const {
            auto* ptr = &(*m_internalView.begin());
            return const_iterator{ ptr };
        }

        iterator end() {
            auto beginIt = begin();
            const auto endIndex = static_cast<std::ptrdiff_t>(m_internalView.size() / Stride);
            auto endIt = beginIt + endIndex;
            return endIt;
        }

        const_iterator end() const {
            auto beginIt = begin();
            const auto endIndex = static_cast<std::ptrdiff_t>(m_internalView.size() / Stride);
            auto endIt = beginIt + endIndex;
            return endIt;
        }

        const_iterator cend() const {
            auto beginIt = cbegin();
            const auto endIndex = static_cast<std::ptrdiff_t>(m_internalView.size() / Stride);
            auto endIt = beginIt + endIndex;
            return endIt;
        }

        [[nodiscard]] std::span<T> underlying() {
            return m_internalView;
        }
 
    private:
        std::span<T> m_internalView{};
    };
} // namespace marvin::containers
 
#endif