matrixBuffer.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_MATRIXBUFFER_HPP
#define RTCTK_COMPONENTFRAMEWORK_MATRIXBUFFER_HPP
 
#include <cassert>
#include <memory>
#include <vector>
 
namespace rtctk::componentFramework {

template <typename T, typename A = std::allocator<T>>
class MatrixBuffer : public std::vector<T, A> {
public:
    using typename std::vector<T, A>::size_type;
    using typename std::vector<T, A>::value_type;
    using typename std::vector<T, A>::reference;
    using typename std::vector<T, A>::const_reference;
 
    constexpr MatrixBuffer() noexcept(noexcept(A())) = default;
 
    constexpr MatrixBuffer(const MatrixBuffer& other) = default;
 
    constexpr MatrixBuffer& operator=(const MatrixBuffer& other) = default;
 
    constexpr MatrixBuffer(MatrixBuffer&& other) noexcept = default;
 
    constexpr MatrixBuffer& operator=(MatrixBuffer&& other) noexcept(
        std::allocator_traits<A>::propagate_on_container_move_assignment::value or
        std::allocator_traits<A>::is_always_equal::value) {
        m_nrows = other.m_nrows;
        m_ncols = other.m_ncols;
        std::vector<T, A>::operator=(std::move(other));
        return *this;
    }
 
    constexpr MatrixBuffer(size_type n, size_type m, const std::vector<T, A>& data)
        : std::vector<T, A>(data), m_nrows(n), m_ncols(m) {
        assert(n * m == data.size());
    }
 
    // The resize method is inherited from the base class, therefore the following warning is a
    // false positive.
    // NOLINTNEXTLINE(readability-identifier-naming)
    constexpr void resize(size_type n, size_type m) {
        std::vector<T, A>::resize(n * m);
        m_nrows = n;
        m_ncols = m;
    }
 
    // NOLINTNEXTLINE(readability-identifier-naming)
    constexpr void resize(size_type n, size_type m, const value_type& value) {
        std::vector<T, A>::resize(n * m, value);
        m_nrows = n;
        m_ncols = m;
    }
 
    constexpr reference operator()(size_type n, size_type m) {
        assert(0 <= n and n < m_nrows);
        assert(0 <= m and m < m_ncols);
        return std::vector<T, A>::operator[](n * m_ncols + m);
    }
 
    constexpr const_reference operator()(size_type n, size_type m) const {
        assert(0 <= n and n < m_nrows);
        assert(0 <= m and m < m_ncols);
        return std::vector<T, A>::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{0};
    size_type m_ncols{0};
};

template <typename T, typename A>
constexpr bool operator==(const MatrixBuffer<T, A>& lhs, const MatrixBuffer<T, A>& rhs) noexcept {
    return lhs.GetNrows() == rhs.GetNrows() and lhs.GetNcols() == rhs.GetNcols() and
           static_cast<std::vector<T, A>>(lhs) == static_cast<std::vector<T, A>>(rhs);
}

template <typename T, typename A>
constexpr bool operator!=(const MatrixBuffer<T, A>& lhs, const MatrixBuffer<T, A>& rhs) noexcept {
    return lhs.GetNrows() != rhs.GetNrows() or lhs.GetNcols() != rhs.GetNcols() or
           static_cast<std::vector<T, A>>(lhs) != static_cast<std::vector<T, A>>(rhs);
}

template <typename T, typename A>
constexpr bool operator<(const MatrixBuffer<T, A>& lhs, const MatrixBuffer<T, A>& rhs) noexcept {
    if (lhs.size() < rhs.size()) {
        return true;
    } else if (lhs.size() == rhs.size()) {
        if (lhs.GetNrows() < rhs.GetNrows()) {
            return true;
        } else if (lhs.GetNrows() > rhs.GetNrows()) {
            return false;
        }
    }
    return static_cast<std::vector<T, A>>(lhs) < static_cast<std::vector<T, A>>(rhs);
}

template <typename T, typename A>
constexpr bool operator<=(const MatrixBuffer<T, A>& lhs, const MatrixBuffer<T, A>& rhs) noexcept {
    if (lhs.size() < rhs.size()) {
        return true;
    } else if (lhs.size() == rhs.size()) {
        if (lhs.GetNrows() < rhs.GetNrows()) {
            return true;
        } else if (lhs.GetNrows() > rhs.GetNrows()) {
            return false;
        }
    }
    return static_cast<std::vector<T, A>>(lhs) <= static_cast<std::vector<T, A>>(rhs);
}

template <typename T, typename A>
constexpr bool operator>(const MatrixBuffer<T, A>& lhs, const MatrixBuffer<T, A>& rhs) noexcept {
    if (lhs.size() > rhs.size()) {
        return true;
    } else if (lhs.size() == rhs.size()) {
        if (lhs.GetNrows() > rhs.GetNrows()) {
            return true;
        } else if (lhs.GetNrows() < rhs.GetNrows()) {
            return false;
        }
    }
    return static_cast<std::vector<T, A>>(lhs) > static_cast<std::vector<T, A>>(rhs);
}

template <typename T, typename A>
constexpr bool operator>=(const MatrixBuffer<T, A>& lhs, const MatrixBuffer<T, A>& rhs) noexcept {
    if (lhs.size() > rhs.size()) {
        return true;
    } else if (lhs.size() == rhs.size()) {
        if (lhs.GetNrows() > rhs.GetNrows()) {
            return true;
        } else if (lhs.GetNrows() < rhs.GetNrows()) {
            return false;
        }
    }
    return static_cast<std::vector<T, A>>(lhs) >= static_cast<std::vector<T, A>>(rhs);
}
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_MATRIXBUFFER_HPP