variant_matrix_views_internal.hpp

#ifndef SEQUENCE_VARIANT_MATRIX_INTERNAL_HPP__
#define SEQUENCE_VARIANT_MATRIX_INTERNAL_HPP__

#include <cstdint>
#include <cstddef>
#include <stdexcept>
#include <vector>
#include <type_traits>
#include "col_view_iterator.hpp"

namespace Sequence
{
    namespace internal
    {
        template <typename T> struct row_view_
        {
            static_assert(std::is_pointer<T>::value, "T must be pointer type");
            T data;
            using value_type = typename std::remove_pointer<T>::type;

            std::size_t row_size;

            row_view_(T data_, std::size_t row_size_)
                : data(data_), row_size(row_size_)
            {
            }
            inline value_type& operator[](const std::size_t i)
            {
                return data[i];
            }
            inline const value_type& operator[](const std::size_t i) const
            {
                return data[i];
            }
            inline value_type&
            at(const std::size_t i)
            {
                if (i >= row_size)
                    {
                        throw std::out_of_range("index out of range");
                    }
                return data[i];
            }
            inline const value_type&
            at(const std::size_t i) const
            {
                if (i >= row_size)
                    {
                        throw std::out_of_range("index out of range");
                    }
                return data[i];
            }
            std::size_t
            size() const
            {
                return row_size;
            }

            using iterator = value_type*;
            using const_iterator = const value_type*;
            using reverse_iterator = std::reverse_iterator<iterator>;
            using const_reverse_iterator
                = std::reverse_iterator<const_iterator>;

            iterator
            begin()
            {
                return data;
            }
            iterator
            end()
            {
                return data + row_size;
            }
            const_iterator
            begin() const
            {
                return data;
            }
            const_iterator
            end() const
            {
                return data + row_size;
            }
            const_iterator
            cbegin() const
            {
                return this->begin();
            }
            const_iterator
            cend() const
            {
                return this->end();
            }

            // Reverse iterators
            reverse_iterator
            rbegin()
            {
                return reverse_iterator(data + row_size);
            }
            reverse_iterator
            rend()
            {
                return reverse_iterator(data);
            }
            const_reverse_iterator
            rbegin() const
            {
                return reverse_iterator(data + row_size);
            }
            const_reverse_iterator
            rend() const
            {
                return reverse_iterator(data);
            }
            const_reverse_iterator
            crbegin() const
            {
                return this->rbegin();
            }
            const_reverse_iterator
            crend() const
            {
                return this->rend();
            }

            std::vector<std::int8_t>
            copy() const
            {
                return std::vector<std::int8_t>(this->cbegin(), this->cend());
            }

            friend void
            swap(row_view_& a, row_view_& b)
            {
                if (a.size() != b.size())
                    {
                        throw std::invalid_argument(
                            "cannot swap row views of different size");
                    }
                auto bi = b.begin();
                for (auto ai = a.begin(); ai != a.end(); ++ai, ++bi)
                    {
                        std::swap(*ai, *bi);
                    }
            }
        };

        template <typename T> struct col_view_
        {
            static_assert(std::is_pointer<T>::value, "T must be pointer type");
            T data;
            using value_type = typename std::remove_pointer<T>::type;

            std::size_t col_end;
            std::size_t stride;

            col_view_(T data_, std::size_t col_end_, std::size_t stride_)
                : data(data_), col_end(col_end_), stride(stride_)
            {
            }
            inline value_type& operator[](const std::size_t i)
            {
                return data[i * stride];
            }
            inline const value_type& operator[](const std::size_t i) const
            {
                return data[i * stride];
            }
            inline value_type&
            at(const std::size_t i)
            {
                if (i >= col_end / stride)
                    {
                        throw std::out_of_range("index out of range");
                    }
                return data[i * stride];
            }
            inline const value_type&
            at(const std::size_t i) const
            {
                if (i >= col_end / stride)
                    {
                        throw std::out_of_range("index out of range");
                    }
                return data[i * stride];
            }
            std::size_t
            size() const
            {
                return col_end / stride;
            }

            using iterator = col_view_iterator<value_type*>;
            using const_iterator = col_view_iterator<const value_type*>;
            using reverse_iterator = std::reverse_iterator<iterator>;
            using const_reverse_iterator
                = std::reverse_iterator<const_iterator>;

            iterator
            begin()
            {
                return iterator(
                    data,
                    static_cast<typename iterator::difference_type>(stride),
                    0);
            }
            iterator
            end()
            {
                return iterator(
                    data,
                    static_cast<typename iterator::difference_type>(stride),
                    static_cast<typename iterator::difference_type>(col_end));
            }
            const_iterator
            begin() const
            {
                return const_iterator(
                    data,
                    static_cast<typename iterator::difference_type>(stride),
                    0);
            }
            const_iterator
            end() const
            {
                return const_iterator(
                    data,
                    static_cast<typename iterator::difference_type>(stride),
                    static_cast<typename iterator::difference_type>(col_end));
            }
            const_iterator
            cbegin() const
            {
                return this->begin();
            }
            const_iterator
            cend() const
            {
                return this->end();
            }

            // Reverse iterators
            reverse_iterator
            rbegin()
            {
                return reverse_iterator(end());
            }
            reverse_iterator
            rend()
            {
                return reverse_iterator(begin());
            }

            const_reverse_iterator
            rbegin() const
            {
                return const_reverse_iterator(end());
            }
            const_reverse_iterator
            rend() const
            {
                return const_reverse_iterator(begin());
            }
            const_reverse_iterator
            crbegin() const
            {
                return this->rbegin();
            }
            const_reverse_iterator
            crend() const
            {
                return this->rend();
            }

            std::vector<std::int8_t>
            copy() const
            {
                return std::vector<std::int8_t>(this->cbegin(), this->cend());
            }

            friend void
            swap(col_view_& a, col_view_& b)
            {
                if (a.size() != b.size())
                    {
                        throw std::invalid_argument(
                            "cannot swap column views of different size");
                    }
                auto bi = b.begin();
                for (auto ai = a.begin(); ai != a.end(); ++ai, ++bi)
                    {
                        std::swap(*ai, *bi);
                    }
            }
        };
    } // namespace internal
} // namespace Sequence

#endif