matrixSpan.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_MATRIXSPAN_HPP
#define RTCTK_COMPONENTFRAMEWORK_MATRIXSPAN_HPP
 
#include <rtctk/componentFramework/matrixBuffer.hpp>
 
#include <gsl/span>
 
#include <array>
#include <cassert>
#include <type_traits>
 
namespace rtctk::componentFramework {

template <typename T>
class MatrixSpan : public gsl::span<T> {
public:
    using typename gsl::span<T>::element_type;
    using typename gsl::span<T>::value_type;
    using typename gsl::span<T>::size_type;
    using typename gsl::span<T>::pointer;
    using const_pointer = const T*;
    using typename gsl::span<T>::reference;
    using const_reference = const T&;
    using typename gsl::span<T>::iterator;
    using typename gsl::span<T>::reverse_iterator;
 
    constexpr MatrixSpan() noexcept : gsl::span<T>(), m_nrows(0), m_ncols(0) {
    }
 
    constexpr MatrixSpan(const MatrixSpan& other)
        : gsl::span<T>(other), m_nrows(other.m_nrows), m_ncols(other.m_ncols) {
    }
 
    constexpr MatrixSpan& operator=(const MatrixSpan& other) {
        gsl::span<T>::operator=(other);
        m_nrows = other.m_nrows;
        m_ncols = other.m_ncols;
        return *this;
    }
 
    constexpr MatrixSpan(MatrixSpan&& other) noexcept
        : gsl::span<T>(std::forward<MatrixSpan>(other))
        , m_nrows(std::move(other.m_nrows))
        , m_ncols(std::move(other.m_ncols)) {
    }
 
    constexpr MatrixSpan& operator=(MatrixSpan&& other) noexcept {
        gsl::span<T>::operator=(std::forward<MatrixSpan>(other));
        m_nrows = std::move(other.m_nrows);
        m_ncols = std::move(other.m_ncols);
        return *this;
    }
 
    constexpr explicit MatrixSpan(size_type n, size_type m, const gsl::span<T>& data)
        : gsl::span<T>(data), m_nrows(n), m_ncols(m) {
        assert(n * m == data.size());
    }
 
    template <class I>
    constexpr explicit MatrixSpan(size_type n, size_type m, I first, size_type count)
        : gsl::span<T>(first, count), m_nrows(n), m_ncols(m) {
        assert(n * m == count);
    }
 
    template <class I>
    constexpr explicit MatrixSpan(size_type n, size_type m, I first, I last)
        : gsl::span<T>(first, last), m_nrows(n), m_ncols(m) {
        assert(n * m == static_cast<size_type>(std::distance(first, last)));
    }
 
    // We provide C-style array support in the API on purpose.
    // NOLINTBEGIN(modernize-avoid-c-arrays)
    template <std::size_t N>
    constexpr explicit MatrixSpan(size_type n, size_type m, element_type (&array)[N]) noexcept
        : gsl::span<T>(array), m_nrows(n), m_ncols(m) {
        assert(n * m == N);
    }
    // NOLINTEND(modernize-avoid-c-arrays)
 
    template <std::size_t N>
    constexpr explicit MatrixSpan(size_type n, size_type m, std::array<T, N>& array) noexcept
        : gsl::span<T>(array), m_nrows(n), m_ncols(m) {
        assert(n * m == N);
    }
 
    template <std::size_t N>
    constexpr explicit MatrixSpan(size_type n, size_type m, const std::array<T, N>& array) noexcept
        : gsl::span<T>(array), m_nrows(n), m_ncols(m) {
        assert(n * m == N);
    }
 
    template <typename R>
    constexpr explicit MatrixSpan(size_type n, size_type m, R&& range) noexcept
        : gsl::span<T>(std::forward<R>(range)), m_nrows(n), m_ncols(m) {
        assert(n * m == range.size());
    }
 
    template <typename A>
    constexpr explicit MatrixSpan(MatrixBuffer<T, A>& buffer) noexcept
        : gsl::span<T>(buffer.data(), buffer.size())
        , m_nrows(buffer.GetNrows())
        , m_ncols(buffer.GetNcols()) {
    }
 
    template <typename A>
        requires std::is_const_v<T> or std::is_volatile_v<T>
    constexpr explicit MatrixSpan(MatrixBuffer<std::remove_cv_t<T>, A>& buffer) noexcept
        : gsl::span<T>(buffer.data(), buffer.size())
        , m_nrows(buffer.GetNrows())
        , m_ncols(buffer.GetNcols()) {
    }
 
    template <typename U>
        requires std::is_same_v<std::remove_cv_t<T>, std::remove_cv_t<U>>
    bool operator==(const MatrixSpan<U>& rhs) const {
        return std::equal(this->begin(), this->end(), rhs.begin(), rhs.end());
    }
 
    constexpr reference operator()(size_type n, size_type m) {
        // cppcheck-suppress unsignedPositive
        assert(0 <= n and n < m_nrows);
        // cppcheck-suppress unsignedPositive
        assert(0 <= m and m < m_ncols);
        return gsl::span<T>::operator[](n * m_ncols + m);
    }
 
    constexpr const_reference operator()(size_type n, size_type m) const {
        // cppcheck-suppress unsignedPositive
        assert(0 <= n and n < m_nrows);
        // cppcheck-suppress unsignedPositive
        assert(0 <= m and m < m_ncols);
        return gsl::span<T>::operator[](n * m_ncols + m);
    }
 
    inline size_type GetNrows() const {
        return m_nrows;
    }
 
    inline size_type GetNcols() const {
        return m_ncols;
    }
 
    inline size_t GetElementIndex(size_t row, size_t col) {
        return row * m_ncols + col;
    }
 
private:
    size_type m_nrows;
    size_type m_ncols;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_MATRIXSPAN_HPP