matrix.h

Go to the documentation of this file.

#ifndef LIBS_CORE_MATRIX_H_
#define LIBS_CORE_MATRIX_H_
 
#include <algorithm>
#include <ostream>
#include <vector>
 
namespace sedni::containers
{
 
template<typename T>
class Matrix
{
public:
    using matrix_t = std::vector<T>;
    using iterator = typename matrix_t::iterator;
    using const_iterator = typename matrix_t::const_iterator;
 
    Matrix() = delete;
 
    Matrix(const size_t rows, const size_t cols) : m_rows(rows), m_cols(cols), m_data(matrix_t(rows * cols))
    {
    }
 
    Matrix(const Matrix &other) : m_rows(other.m_rows), m_cols(other.m_cols), m_data(other.m_data)
    {
    }
 
    Matrix &operator=(const Matrix &other)
    {
        m_data = other.m_data;
        m_rows = other.m_rows;
        m_cols = other.m_cols;
        return *this;
    }
 
    Matrix(Matrix &&other) noexcept : m_rows(other.m_rows), m_cols(other.m_cols), m_data(std::move(other.m_data))
    {
    }
 
    Matrix &operator=(Matrix &&other) noexcept
    {
        m_data.swap(std::move(other.m_data));
        m_rows = other.m_rows;
        m_cols = other.m_cols;
        return *this;
    }
 
    ~Matrix()
    {
        m_data.clear();
    }
 
    T &operator()(const size_t row, const size_t column)
    {
        return m_data[row * m_cols + column];
    }
 
    T operator()(const size_t row, const size_t column) const
    {
        return m_data[row * m_cols + column];
    }
 
    template<typename U>
    friend std::ostream &operator<<(std::ostream &os, const Matrix<U> &rhs);
 
    iterator begin()
    {
        return m_data.begin();
    }
 
    iterator end()
    {
        return m_data.end();
    }
 
    const_iterator begin() const
    {
        return m_data.begin();
    }
 
    const_iterator end() const
    {
        return m_data.end();
    }
 
    const_iterator cbegin() const
    {
        return m_data.cbegin();
    }
 
    const_iterator cend() const
    {
        return m_data.cend();
    }
 
    T &at(const size_t row, const size_t column)
    {
        return m_data.at(row * m_cols + column);
    }
 
    const T &at(const size_t row, const size_t column) const
    {
        return m_data.at(row * m_cols + column);
    }
 
    void set(const size_t row, const size_t column, const T &item)
    {
        //        if (m_nmea2kAttribute.size() <= (row * m_cols + column))
        //            m_nmea2kAttribute.resize(row * m_cols + column + 1);
 
        m_data.at(row * m_cols + column) = item;
    }
 
    void size(uint64_t *rows, uint64_t *cols) const
    {
        if (rows != nullptr)
        {
            *rows = m_rows;
        }
        if (cols != nullptr)
        {
            *cols = m_cols;
        }
    }
 
    template<typename TypeSearch>
    bool exist(const TypeSearch itemSearch, bool (*predicate)(const TypeSearch &, const T &), size_t *ind) const
    {
        const_iterator it;
        sGenericComparator<TypeSearch> search(itemSearch, predicate);
 
        it = std::find_if(m_data.begin(), m_data.end(), search);
 
        if (ind != nullptr)
        {
            *ind = std::distance(m_data.begin(), it);
        }
 
        return it != m_data.end();
    }
 
private:
    template<typename TypeSearch>
    struct sGenericComparator
    {
        sGenericComparator(const TypeSearch data, bool (*function)(const TypeSearch &, const T &))
            : m_data(data), fptr(function)
        {
        }
 
        bool operator()(const T &arg) const
        {
            return fptr(m_data, arg);
        }
 
        const TypeSearch m_data;
        bool (*fptr)(const TypeSearch &, const T &);
    };
 
    size_t m_rows;
    size_t m_cols;
    matrix_t m_data;
};
 
template<typename U>
std::ostream &operator<<(std::ostream &os, const Matrix<U> &rhs)
{
    for (size_t i = 0; i < rhs.m_rows; i++)
    {
        for (size_t j = 0; j < rhs.m_cols; j++)
        {
            os << rhs.at(i, j) << " ";
        }
        os << "\n";
    }
 
    return os;
}
 
}// namespace sedni::containers
 
#endif /* LIBS_CORE_MATRIX_H_ */