feedc0de/QFixedSizeMatrix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Switched to c++14 and extended API (rotating in place and mirroring)

Browse Source
This commit is contained in:
Daniel Brunner
2017-08-18 23:55:28 +02:00
parent bbbeac6061
commit 719bb8d98b
3 changed files with 151 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
QFixedSizeMatrix.pro
View File

@@ -12,6 +12,12 @@ TARGET = tst_qfixedsizematrixtest
CONFIG += console CONFIG += console
CONFIG -= app_bundle CONFIG -= app_bundle
CONFIG += c++14
win32-g++ {
QMAKE_CXXFLAGS_CXX14 = -std=c++14
QMAKE_CXXFLAGS_GNUCXX14 = -std=c++14
}
TEMPLATE = app TEMPLATE = app
# The following define makes your compiler emit warnings if you use # The following define makes your compiler emit warnings if you use

103
fixedsizematrix.h
View File

@@ -9,24 +9,29 @@ class FixedSizeMatrix
{ {
public: public:
FixedSizeMatrix(); FixedSizeMatrix();
FixedSizeMatrix(const std::array<std::array<T, width>, height> &data); FixedSizeMatrix(const std::array<std::array<T, width>, height>& data);
FixedSizeMatrix(const FixedSizeMatrix<T, width, height> &other); FixedSizeMatrix(const FixedSizeMatrix<T, width, height> &other);
FixedSizeMatrix<T, width, height>& operator=(const FixedSizeMatrix<T, width, height>& other); auto& operator=(const FixedSizeMatrix<T, width, height>& other);
FixedSizeMatrix<T, width, height>& operator=(const std::array<std::array<T, width>, height> &data); auto& operator=(const std::array<std::array<T, width>, height>& data);
bool operator==(const FixedSizeMatrix<T, width, height>& other) const; auto operator==(const FixedSizeMatrix<T, width, height>& other) const;
bool operator!=(const FixedSizeMatrix<T, width, height>& other) const; auto operator!=(const FixedSizeMatrix<T, width, height>& other) const;
T& operator()(unsigned int x, unsigned int y); auto& operator()(unsigned int x, unsigned int y);
const T& operator()(unsigned int x, unsigned int y) const; const auto& operator()(unsigned int x, unsigned int y) const;
const T& at(unsigned int x, unsigned int y); void rotateLeft();
void set(unsigned int x, unsigned int y, const T &value); void rotateRight();
void rotate180();
void mirrorHorizontally();
void mirrorVertically();
FixedSizeMatrix<T, height, width> rotatedLeft() const; auto asRotatedLeft() const;
FixedSizeMatrix<T, height, width> rotatedRight() const; auto asRotatedRight() const;
FixedSizeMatrix<T, width, height> rotated180() const; auto asRotated180() const;
auto asMirroredHorizontally() const;
auto asMirroredVertically() const;
private: private:
std::array<std::array<T, width>, height> m_data; std::array<std::array<T, width>, height> m_data;
@@ -36,13 +41,13 @@ template<typename T, unsigned int width, unsigned int height>
FixedSizeMatrix<T, width, height>::FixedSizeMatrix() {} FixedSizeMatrix<T, width, height>::FixedSizeMatrix() {}
template<typename T, unsigned int width, unsigned int height> template<typename T, unsigned int width, unsigned int height>
FixedSizeMatrix<T, width, height>::FixedSizeMatrix(const std::array<std::array<T, width>, height> &data) : m_data(data) {} FixedSizeMatrix<T, width, height>::FixedSizeMatrix(const std::array<std::array<T, width>, height>& data) : m_data(data) {}
template<typename T, unsigned int width, unsigned int height> template<typename T, unsigned int width, unsigned int height>
FixedSizeMatrix<T, width, height>::FixedSizeMatrix(const FixedSizeMatrix<T, width, height> &other) : m_data(other.m_data) {} FixedSizeMatrix<T, width, height>::FixedSizeMatrix(const FixedSizeMatrix<T, width, height>& other) : m_data(other.m_data) {}
template<typename T, unsigned int width, unsigned int height> template<typename T, unsigned int width, unsigned int height>
FixedSizeMatrix<T, width, height> &FixedSizeMatrix<T, width, height>::operator=(const FixedSizeMatrix<T, width, height> &other) auto& FixedSizeMatrix<T, width, height>::operator=(const FixedSizeMatrix<T, width, height>& other)
{ {
if(&other != this) if(&other != this)
m_data = other.m_data; m_data = other.m_data;
@@ -50,20 +55,26 @@ FixedSizeMatrix<T, width, height> &FixedSizeMatrix<T, width, height>::operator=(
} }
template<typename T, unsigned int width, unsigned int height> template<typename T, unsigned int width, unsigned int height>
FixedSizeMatrix<T, width, height> &FixedSizeMatrix<T, width, height>::operator=(const std::array<std::array<T, width>, height> &data) auto& FixedSizeMatrix<T, width, height>::operator=(const std::array<std::array<T, width>, height>& data)
{ {
m_data = data; m_data = data;
return *this; return *this;
} }
template<typename T, unsigned int width, unsigned int height> template<typename T, unsigned int width, unsigned int height>
bool FixedSizeMatrix<T, width, height>::operator==(const FixedSizeMatrix<T, width, height> &other) const { return m_data == other.m_data; } auto FixedSizeMatrix<T, width, height>::operator==(const FixedSizeMatrix<T, width, height>& other) const
{
return m_data == other.m_data;
}
template<typename T, unsigned int width, unsigned int height> template<typename T, unsigned int width, unsigned int height>
bool FixedSizeMatrix<T, width, height>::operator!=(const FixedSizeMatrix<T, width, height> &other) const { return m_data != other.m_data; } auto FixedSizeMatrix<T, width, height>::operator!=(const FixedSizeMatrix<T, width, height>& other) const
{
return m_data != other.m_data;
}
template<typename T, unsigned int width, unsigned int height> template<typename T, unsigned int width, unsigned int height>
T &FixedSizeMatrix<T, width, height>::operator()(unsigned int x, unsigned int y) auto& FixedSizeMatrix<T, width, height>::operator()(unsigned int x, unsigned int y)
{ {
assert(x < width); assert(x < width);
assert(y < height); assert(y < height);
@@ -71,7 +82,7 @@ T &FixedSizeMatrix<T, width, height>::operator()(unsigned int x, unsigned int y)
} }
template<typename T, unsigned int width, unsigned int height> template<typename T, unsigned int width, unsigned int height>
const T &FixedSizeMatrix<T, width, height>::operator()(unsigned int x, unsigned int y) const const auto& FixedSizeMatrix<T, width, height>::operator()(unsigned int x, unsigned int y) const
{ {
assert(x < width); assert(x < width);
assert(y < height); assert(y < height);
@@ -79,23 +90,41 @@ const T &FixedSizeMatrix<T, width, height>::operator()(unsigned int x, unsigned
} }
template<typename T, unsigned int width, unsigned int height> template<typename T, unsigned int width, unsigned int height>
const T &FixedSizeMatrix<T, width, height>::at(unsigned int x, unsigned int y) void FixedSizeMatrix<T, width, height>::rotateLeft()
{ {
assert(x < width); static_assert(width == height, "Rotating in place only works when width matches height");
assert(y < height);
return m_data[y][x]; //TODO
} }
template<typename T, unsigned int width, unsigned int height> template<typename T, unsigned int width, unsigned int height>
void FixedSizeMatrix<T, width, height>::set(unsigned int x, unsigned int y, const T &value) void FixedSizeMatrix<T, width, height>::rotateRight()
{ {
assert(x < width); static_assert(width == height, "Rotating in place only works when width matches height");
assert(y < height);
m_data[y][x] = value; //TODO
} }
template<typename T, unsigned int width, unsigned int height> template<typename T, unsigned int width, unsigned int height>
FixedSizeMatrix<T, height, width> FixedSizeMatrix<T, width, height>::rotatedLeft() const void FixedSizeMatrix<T, width, height>::rotate180()
{
//TODO
}
template<typename T, unsigned int width, unsigned int height>
void FixedSizeMatrix<T, width, height>::mirrorHorizontally()
{
//TODO
}
template<typename T, unsigned int width, unsigned int height>
void FixedSizeMatrix<T, width, height>::mirrorVertically()
{
//TODO
}
template<typename T, unsigned int width, unsigned int height>
auto FixedSizeMatrix<T, width, height>::asRotatedLeft() const
{ {
std::array<std::array<T, height>, width> data; std::array<std::array<T, height>, width> data;
@@ -107,7 +136,7 @@ FixedSizeMatrix<T, height, width> FixedSizeMatrix<T, width, height>::rotatedLeft
} }
template<typename T, unsigned int width, unsigned int height> template<typename T, unsigned int width, unsigned int height>
FixedSizeMatrix<T, height, width> FixedSizeMatrix<T, width, height>::rotatedRight() const auto FixedSizeMatrix<T, width, height>::asRotatedRight() const
{ {
std::array<std::array<T, height>, width> data; std::array<std::array<T, height>, width> data;
@@ -119,7 +148,7 @@ FixedSizeMatrix<T, height, width> FixedSizeMatrix<T, width, height>::rotatedRigh
} }
template<typename T, unsigned int width, unsigned int height> template<typename T, unsigned int width, unsigned int height>
FixedSizeMatrix<T, width, height> FixedSizeMatrix<T, width, height>::rotated180() const auto FixedSizeMatrix<T, width, height>::asRotated180() const
{ {
std::array<std::array<T, width>, height> data; std::array<std::array<T, width>, height> data;
@@ -130,4 +159,16 @@ FixedSizeMatrix<T, width, height> FixedSizeMatrix<T, width, height>::rotated180(
return FixedSizeMatrix<T, width, height>(data); return FixedSizeMatrix<T, width, height>(data);
} }
template<typename T, unsigned int width, unsigned int height>
auto FixedSizeMatrix<T, width, height>::asMirroredHorizontally() const
{
//TODO
}
template<typename T, unsigned int width, unsigned int height>
auto FixedSizeMatrix<T, width, height>::asMirroredVertically() const
{
//TODO
}
#endif // FIXEDSIZEMATRIX_H #endif // FIXEDSIZEMATRIX_H

113
tst_qfixedsizematrixtest.cpp
View File

@@ -21,43 +21,76 @@ private Q_SLOTS:
void rotate180Test(); void rotate180Test();
private: private:
static const std::array<std::array<TestEnum, 2>, 4> demoData; static const std::array<std::array<TestEnum, 2>, 4> demoData2x4;
static const std::array<std::array<TestEnum, 4>, 2> demoDataRotatedLeft; static const std::array<std::array<TestEnum, 4>, 2> demoData2x4RotatedLeft;
static const std::array<std::array<TestEnum, 4>, 2> demoDataRotatedRight; static const std::array<std::array<TestEnum, 4>, 2> demoData2x4RotatedRight;
static const std::array<std::array<TestEnum, 2>, 4> demoDataRotated180; static const std::array<std::array<TestEnum, 2>, 4> demoData2x4Rotated180;
static const std::array<std::array<TestEnum, 4>, 4> demoData4x4;
static const std::array<std::array<TestEnum, 4>, 4> demoData4x4RotatedLeft;
static const std::array<std::array<TestEnum, 4>, 4> demoData4x4RotatedRight;
static const std::array<std::array<TestEnum, 4>, 4> demoData4x4Rotated180;
template<unsigned int width, unsigned int height> template<unsigned int width, unsigned int height>
void verifyToDemoData(const FixedSizeMatrix<TestEnum, width, height>& matrix, void verifyData(const FixedSizeMatrix<TestEnum, width, height>& matrix,
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, width>, height> &data); const std::array<std::array<QFixedSizeMatrixTest::TestEnum, width>, height> &data);
}; };
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 2>, 4> QFixedSizeMatrixTest::demoData { const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 2>, 4> QFixedSizeMatrixTest::demoData2x4 {
std::array<TestEnum, 2> { TestEnum::ONE, TestEnum::ONE }, std::array<TestEnum, 2> { TestEnum::ONE, TestEnum::ONE },
std::array<TestEnum, 2> { TestEnum::TWO, TestEnum::TWO }, std::array<TestEnum, 2> { TestEnum::TWO, TestEnum::TWO },
std::array<TestEnum, 2> { TestEnum::THREE, TestEnum::THREE }, std::array<TestEnum, 2> { TestEnum::THREE, TestEnum::THREE },
std::array<TestEnum, 2> { TestEnum::FOUR, TestEnum::FOUR } std::array<TestEnum, 2> { TestEnum::FOUR, TestEnum::FOUR }
}; };
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 2> QFixedSizeMatrixTest::demoDataRotatedLeft { const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 2> QFixedSizeMatrixTest::demoData2x4RotatedLeft {
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::TWO, TestEnum::THREE, TestEnum::FOUR }, std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::TWO, TestEnum::THREE, TestEnum::FOUR },
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::TWO, TestEnum::THREE, TestEnum::FOUR } std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::TWO, TestEnum::THREE, TestEnum::FOUR }
}; };
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 2> QFixedSizeMatrixTest::demoDataRotatedRight { const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 2> QFixedSizeMatrixTest::demoData2x4RotatedRight {
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::THREE, TestEnum::TWO, TestEnum::ONE }, std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::THREE, TestEnum::TWO, TestEnum::ONE },
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::THREE, TestEnum::TWO, TestEnum::ONE } std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::THREE, TestEnum::TWO, TestEnum::ONE }
}; };
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 2>, 4> QFixedSizeMatrixTest::demoDataRotated180 { const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 2>, 4> QFixedSizeMatrixTest::demoData2x4Rotated180 {
std::array<TestEnum, 2> { TestEnum::FOUR, TestEnum::FOUR }, std::array<TestEnum, 2> { TestEnum::FOUR, TestEnum::FOUR },
std::array<TestEnum, 2> { TestEnum::THREE, TestEnum::THREE }, std::array<TestEnum, 2> { TestEnum::THREE, TestEnum::THREE },
std::array<TestEnum, 2> { TestEnum::TWO, TestEnum::TWO }, std::array<TestEnum, 2> { TestEnum::TWO, TestEnum::TWO },
std::array<TestEnum, 2> { TestEnum::ONE, TestEnum::ONE } std::array<TestEnum, 2> { TestEnum::ONE, TestEnum::ONE }
}; };
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 4> QFixedSizeMatrixTest::demoData4x4 {
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::ONE, TestEnum::ONE, TestEnum::ONE },
std::array<TestEnum, 4> { TestEnum::TWO, TestEnum::TWO, TestEnum::TWO, TestEnum::TWO },
std::array<TestEnum, 4> { TestEnum::THREE, TestEnum::THREE, TestEnum::THREE, TestEnum::THREE },
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::FOUR, TestEnum::FOUR, TestEnum::FOUR }
};
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 4> QFixedSizeMatrixTest::demoData4x4RotatedLeft {
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::TWO, TestEnum::THREE, TestEnum::FOUR },
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::TWO, TestEnum::THREE, TestEnum::FOUR },
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::TWO, TestEnum::THREE, TestEnum::FOUR },
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::TWO, TestEnum::THREE, TestEnum::FOUR }
};
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 4> QFixedSizeMatrixTest::demoData4x4RotatedRight {
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::THREE, TestEnum::TWO, TestEnum::ONE },
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::THREE, TestEnum::TWO, TestEnum::ONE },
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::THREE, TestEnum::TWO, TestEnum::ONE },
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::THREE, TestEnum::TWO, TestEnum::ONE }
};
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, 4>, 4> QFixedSizeMatrixTest::demoData4x4Rotated180 {
std::array<TestEnum, 4> { TestEnum::FOUR, TestEnum::FOUR, TestEnum::FOUR, TestEnum::FOUR },
std::array<TestEnum, 4> { TestEnum::THREE, TestEnum::THREE, TestEnum::THREE, TestEnum::THREE },
std::array<TestEnum, 4> { TestEnum::TWO, TestEnum::TWO, TestEnum::TWO, TestEnum::TWO },
std::array<TestEnum, 4> { TestEnum::ONE, TestEnum::ONE, TestEnum::ONE, TestEnum::ONE }
};
template<unsigned int width, unsigned int height> template<unsigned int width, unsigned int height>
void QFixedSizeMatrixTest::verifyToDemoData(const FixedSizeMatrix<QFixedSizeMatrixTest::TestEnum, width, height> &matrix, void QFixedSizeMatrixTest::verifyData(const FixedSizeMatrix<QFixedSizeMatrixTest::TestEnum, width, height> &matrix,
const std::array<std::array<QFixedSizeMatrixTest::TestEnum, width>, height> &data) const std::array<std::array<QFixedSizeMatrixTest::TestEnum, width>, height> &data)
{ {
for(unsigned int y = 0; y < height; y++) for(unsigned int y = 0; y < height; y++)
for(unsigned int x = 0; x < width; x++) for(unsigned int x = 0; x < width; x++)
@@ -66,75 +99,75 @@ void QFixedSizeMatrixTest::verifyToDemoData(const FixedSizeMatrix<QFixedSizeMatr
void QFixedSizeMatrixTest::constructorTest() void QFixedSizeMatrixTest::constructorTest()
{ {
FixedSizeMatrix<TestEnum, 2, 4> matrix(demoData); FixedSizeMatrix<TestEnum, 2, 4> matrix(demoData2x4);
verifyToDemoData(matrix, demoData); verifyData(matrix, demoData2x4);
} }
void QFixedSizeMatrixTest::assignmentTest() void QFixedSizeMatrixTest::assignmentTest()
{ {
FixedSizeMatrix<TestEnum, 2, 4> matrix(demoData); FixedSizeMatrix<TestEnum, 2, 4> matrix(demoData2x4);
FixedSizeMatrix<TestEnum, 2, 4> other; FixedSizeMatrix<TestEnum, 2, 4> other;
other = matrix; other = matrix;
verifyToDemoData(other, demoData); verifyData(other, demoData2x4);
} }
void QFixedSizeMatrixTest::comparisonTest() void QFixedSizeMatrixTest::comparisonTest()
{ {
FixedSizeMatrix<TestEnum, 2, 4> matrix0(demoData); FixedSizeMatrix<TestEnum, 2, 4> matrix0(demoData2x4);
FixedSizeMatrix<TestEnum, 2, 4> matrix1; FixedSizeMatrix<TestEnum, 2, 4> matrix1;
QVERIFY2(matrix0 != matrix1, ""); QVERIFY2(matrix0 != matrix1, "");
matrix1 = FixedSizeMatrix<TestEnum, 2, 4> { demoData }; matrix1 = FixedSizeMatrix<TestEnum, 2, 4> { demoData2x4 };
QVERIFY2(matrix0 == matrix1, ""); QVERIFY2(matrix0 == matrix1, "");
} }
void QFixedSizeMatrixTest::rotateLeftTest() void QFixedSizeMatrixTest::rotateLeftTest()
{ {
FixedSizeMatrix<TestEnum, 2, 4> matrix(demoData); FixedSizeMatrix<TestEnum, 2, 4> matrix(demoData2x4);
FixedSizeMatrix<TestEnum, 4, 2> rotatedContainer; FixedSizeMatrix<TestEnum, 4, 2> rotatedContainer;
rotatedContainer = matrix.rotatedLeft(); rotatedContainer = matrix.asRotatedLeft();
verifyToDemoData(rotatedContainer, demoDataRotatedLeft); verifyData(rotatedContainer, demoData2x4RotatedLeft);
matrix = rotatedContainer.rotatedLeft(); matrix = rotatedContainer.asRotatedLeft();
verifyToDemoData(matrix, demoDataRotated180); verifyData(matrix, demoData2x4Rotated180);
rotatedContainer = matrix.rotatedLeft(); rotatedContainer = matrix.asRotatedLeft();
verifyToDemoData(rotatedContainer, demoDataRotatedRight); verifyData(rotatedContainer, demoData2x4RotatedRight);
matrix = rotatedContainer.rotatedLeft(); matrix = rotatedContainer.asRotatedLeft();
verifyToDemoData(matrix, demoData); verifyData(matrix, demoData2x4);
} }
void QFixedSizeMatrixTest::rotateRightTest() void QFixedSizeMatrixTest::rotateRightTest()
{ {
FixedSizeMatrix<TestEnum, 2, 4> matrix(demoData); FixedSizeMatrix<TestEnum, 2, 4> matrix(demoData2x4);
FixedSizeMatrix<TestEnum, 4, 2> rotatedContainer; FixedSizeMatrix<TestEnum, 4, 2> rotatedContainer;
rotatedContainer = matrix.rotatedRight(); rotatedContainer = matrix.asRotatedRight();
verifyToDemoData(rotatedContainer, demoDataRotatedRight); verifyData(rotatedContainer, demoData2x4RotatedRight);
matrix = rotatedContainer.rotatedRight(); matrix = rotatedContainer.asRotatedRight();
verifyToDemoData(matrix, demoDataRotated180); verifyData(matrix, demoData2x4Rotated180);
rotatedContainer = matrix.rotatedRight(); rotatedContainer = matrix.asRotatedRight();
verifyToDemoData(rotatedContainer, demoDataRotatedLeft); verifyData(rotatedContainer, demoData2x4RotatedLeft);
matrix = rotatedContainer.rotatedRight(); matrix = rotatedContainer.asRotatedRight();
verifyToDemoData(matrix, demoData); verifyData(matrix, demoData2x4);
} }
void QFixedSizeMatrixTest::rotate180Test() void QFixedSizeMatrixTest::rotate180Test()
{ {
FixedSizeMatrix<TestEnum, 2, 4> matrix(demoData); FixedSizeMatrix<TestEnum, 2, 4> matrix(demoData2x4);
matrix = matrix.rotated180(); matrix = matrix.asRotated180();
verifyToDemoData(matrix, demoDataRotated180); verifyData(matrix, demoData2x4Rotated180);
matrix = matrix.rotated180(); matrix = matrix.asRotated180();
verifyToDemoData(matrix, demoData); verifyData(matrix, demoData2x4);
} }
QTEST_APPLESS_MAIN(QFixedSizeMatrixTest) QTEST_APPLESS_MAIN(QFixedSizeMatrixTest)