MeshTools: duplicateInto() taking also type-erased indices.

src/Magnum/MeshTools/Duplicate.cpp

@@ -61,4 +61,16 @@ void duplicateInto(const Containers::StridedArrayView1D<const UnsignedInt>& indi
     duplicateIntoImplementation(indices, data, out);
 }
 
+void duplicateInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView2D<const char>& data, const Containers::StridedArrayView2D<char>& out) {
+    CORRADE_ASSERT(indices.isContiguous<1>(), "MeshTools::duplicateInto(): second index view dimension is not contiguous", );
+    if(indices.size()[1] == 4)
+        return duplicateIntoImplementation(Containers::arrayCast<1, const UnsignedInt>(indices), data, out);
+    else if(indices.size()[1] == 2)
+        return duplicateIntoImplementation(Containers::arrayCast<1, const UnsignedShort>(indices), data, out);
+    else {
+        CORRADE_ASSERT(indices.size()[1] == 1, "MeshTools::duplicateInto(): expected index type size 1, 2 or 4 but got" << indices.size()[1], );
+        return duplicateIntoImplementation(Containers::arrayCast<1, const UnsignedByte>(indices), data, out);
+    }
+}
+
 }}

src/Magnum/MeshTools/Duplicate.h

@@ -115,6 +115,17 @@ MAGNUM_MESHTOOLS_EXPORT void duplicateInto(const Containers::StridedArrayView1D<
  */
 MAGNUM_MESHTOOLS_EXPORT void duplicateInto(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const Containers::StridedArrayView2D<const char>& data, const Containers::StridedArrayView2D<char>& out);
 
+/**
+@brief Duplicate type-erased data using a type-erased index array into given output array
+@m_since_latest
+
+Expects that the second dimension of @p indices is contiguous and represents
+the actual 1/2/4-byte index type. Based on its size then calls one of the
+@ref duplicateInto(const Containers::StridedArrayView1D<const UnsignedInt>&, const Containers::StridedArrayView2D<const char>&, const Containers::StridedArrayView2D<char>&)
+etc. overloads.
+*/
+MAGNUM_MESHTOOLS_EXPORT void duplicateInto(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView2D<const char>& data, const Containers::StridedArrayView2D<char>& out);
+
 template<class IndexType, class T> inline void duplicateInto(const Containers::StridedArrayView1D<const IndexType>& indices, const Containers::StridedArrayView1D<const T>& data, const Containers::StridedArrayView1D<T>& out) {
     duplicateInto(indices, Containers::arrayCast<2, const char>(data), Containers::arrayCast<2, char>(out));
 }

src/Magnum/MeshTools/Test/DuplicateTest.cpp

@@ -47,6 +47,10 @@ struct DuplicateTest: TestSuite::Tester {
     template<class T> void duplicateIntoErased();
     void duplicateIntoErasedWrongTypeSize();
     void duplicateIntoErasedNonContiguous();
+
+    template<class T> void duplicateErasedIndicesIntoErased();
+    void duplicateErasedIndicesIntoErasedNonContiguous();
+    void duplicateErasedIndicesIntoErasedWrongTypeSize();
 };
 
 DuplicateTest::DuplicateTest() {
@@ -61,7 +65,13 @@ DuplicateTest::DuplicateTest() {
               &DuplicateTest::duplicateIntoErased<UnsignedShort>,
               &DuplicateTest::duplicateIntoErased<UnsignedInt>,
               &DuplicateTest::duplicateIntoErasedWrongTypeSize,
-              &DuplicateTest::duplicateIntoErasedNonContiguous});
+              &DuplicateTest::duplicateIntoErasedNonContiguous,
+
+              &DuplicateTest::duplicateErasedIndicesIntoErased<UnsignedByte>,
+              &DuplicateTest::duplicateErasedIndicesIntoErased<UnsignedShort>,
+              &DuplicateTest::duplicateErasedIndicesIntoErased<UnsignedInt>,
+              &DuplicateTest::duplicateErasedIndicesIntoErasedNonContiguous,
+              &DuplicateTest::duplicateErasedIndicesIntoErasedWrongTypeSize});
 }
 
 void DuplicateTest::duplicate() {
@@ -162,6 +172,54 @@ void DuplicateTest::duplicateIntoErasedNonContiguous() {
         "MeshTools::duplicateInto(): second view dimension is not contiguous\n");
 }
 
+template<class T> void DuplicateTest::duplicateErasedIndicesIntoErased() {
+    setTestCaseTemplateName(Math::TypeTraits<T>::name());
+
+    constexpr T indices[]{1, 1, 0, 3, 2, 2};
+    constexpr Int data[]{-7, 35, 12, -18};
+    Int output[6];
+
+    MeshTools::duplicateInto(
+        Containers::arrayCast<2, const char>(Containers::stridedArrayView(indices)),
+        Containers::arrayCast<2, const char>(Containers::stridedArrayView(data)),
+        Containers::arrayCast<2, char>(Containers::stridedArrayView(output)));
+    CORRADE_COMPARE_AS(Containers::arrayView<const Int>(output),
+        Containers::arrayView({35, 35, -7, -18, 12, 12}),
+        TestSuite::Compare::Container);
+}
+
+void DuplicateTest::duplicateErasedIndicesIntoErasedWrongTypeSize() {
+    constexpr char indices[6*3]{};
+    constexpr Int data[]{-7, 35, 12, -18};
+    Short output[6];
+
+    std::ostringstream out;
+    Error redirectError{&out};
+
+    MeshTools::duplicateInto(
+        Containers::StridedArrayView2D<const char>{indices, {6, 3}}.every(2),
+        Containers::arrayCast<2, const char>(Containers::stridedArrayView(data)),
+        Containers::arrayCast<2, char>(Containers::stridedArrayView(output)));
+    CORRADE_COMPARE(out.str(),
+        "MeshTools::duplicateInto(): expected index type size 1, 2 or 4 but got 3\n");
+}
+
+void DuplicateTest::duplicateErasedIndicesIntoErasedNonContiguous() {
+    constexpr char indices[3*6]{};
+    constexpr Int data[]{-7, 35, 12, -18};
+    Short output[6];
+
+    std::ostringstream out;
+    Error redirectError{&out};
+
+    MeshTools::duplicateInto(
+        Containers::StridedArrayView2D<const char>{indices, {3, 3}, {6, 2}},
+        Containers::arrayCast<2, const char>(Containers::stridedArrayView(data)).every({1, 2}),
+        Containers::arrayCast<2, char>(Containers::stridedArrayView(output)));
+    CORRADE_COMPARE(out.str(),
+        "MeshTools::duplicateInto(): second index view dimension is not contiguous\n");
+}
+
 }}}}
 
 CORRADE_TEST_MAIN(Magnum::MeshTools::Test::DuplicateTest)