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())) :
        std::vector<T, A>(), m_nrows(0), m_ncols(0) {
    }
 
    constexpr MatrixBuffer(const MatrixBuffer& other) :
        std::vector<T, A>(other),
        m_nrows(other.m_nrows),
        m_ncols(other.m_ncols) {
    }
 
    constexpr MatrixBuffer& operator=(const MatrixBuffer& other) {
        std::vector<T, A>::operator=(other);
        m_nrows = other.m_nrows;
        m_ncols = other.m_ncols;
        return *this;
    }
 
    constexpr MatrixBuffer(MatrixBuffer&& other) noexcept :
        std::vector<T, A>(std::forward<MatrixBuffer>(other)),
        m_nrows(std::move(other.m_nrows)),
        m_ncols(std::move(other.m_ncols)) {
    }
 
    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) {
        std::vector<T, A>::operator=(std::forward<MatrixBuffer>(other));
        m_nrows = std::move(other.m_nrows);
        m_ncols = std::move(other.m_ncols);
        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());
    }
 
    constexpr void resize(size_type n, size_type m) {
        std::vector<T, A>::resize(n*m);
        m_nrows = n;
        m_ncols = m;
    }
 
    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 get_nrows() const {
        return m_nrows;
    }
 
    inline size_type get_ncols() const {
        return m_ncols;
    }
 
private:
    size_type m_nrows;
    size_type m_ncols;
};
 
template <typename T, typename A>
constexpr bool operator==(const MatrixBuffer<T, A>& lhs, const MatrixBuffer<T, A>& rhs) noexcept {
    return lhs.get_nrows() == rhs.get_nrows() and
           lhs.get_ncols() == rhs.get_ncols() 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.get_nrows() != rhs.get_nrows() or
           lhs.get_ncols() != rhs.get_ncols() 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.get_nrows() < rhs.get_nrows()) {
            return true;
        } else if (lhs.get_nrows() > rhs.get_nrows()) {
            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.get_nrows() < rhs.get_nrows()) {
            return true;
        } else if (lhs.get_nrows() > rhs.get_nrows()) {
            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.get_nrows() > rhs.get_nrows()) {
            return true;
        } else if (lhs.get_nrows() < rhs.get_nrows()) {
            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.get_nrows() > rhs.get_nrows()) {
            return true;
        } else if (lhs.get_nrows() < rhs.get_nrows()) {
            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