Add tests for iterators

Author: OliverRietmann

memlayout/wrapper.h

@@ -156,6 +156,33 @@ struct Wrapper<Struct, pointer, Layout::aos> {
     constexpr Wrapper<Struct, const_reference> operator->() const { return operator[](0); }
 };
 
+template <template <template <class> class> class Struct>
+struct Wrapper<Struct, const_pointer, Layout::aos> {
+    static constexpr Layout layout_type = Layout::aos;
+
+    const_pointer<Struct<value>> data;
+    using Data = const_pointer<Struct<value>>;
+
+    operator const Data&() const { return data; }
+
+    constexpr bool operator==(const Wrapper& other) const { return data == other.data; }
+    constexpr bool operator!=(const Wrapper& other) const { return data != other.data; }
+    constexpr bool operator<(const Wrapper& other) const { return data < other.data; }
+
+    constexpr Wrapper operator+(ptrdiff_t i) const { return {data + i}; }
+    constexpr Wrapper operator-(ptrdiff_t i) const { return {data - i}; }
+    constexpr ptrdiff_t operator-(const Wrapper& other) const { return {data - other.data}; }
+
+    constexpr Wrapper operator++() { return {++data}; }
+    constexpr Wrapper operator+=(ptrdiff_t i) { return {data += i}; }
+    constexpr Wrapper operator--() { return {--data}; }
+    constexpr Wrapper operator-=(ptrdiff_t i) { return {data -= i}; }
+
+    constexpr Wrapper<Struct, const_reference> operator[] (size_t i) const { return data[i]; }
+    constexpr Wrapper<Struct, const_reference> operator*() const { return *data; }
+    constexpr Wrapper<Struct, const_reference> operator->() const { return operator[](0); }
+};
+
 template <
     template <template <class> class> class Struct,
     template <class> class Container

tests/cpu/test_cpu.cpp

@@ -1,3 +1,4 @@
+#include <algorithm>
 #include <vector>
 #include <span>
 
@@ -158,3 +159,55 @@ TEST(VectorToSpan, SoA) {
     uint32_t expected_sum = 45;
     EXPECT_EQ(expected_sum, sum);
 }
+
+TEST(Iterators, AoS) {
+    memlayout::Wrapper<test::Point2D, std::vector, memlayout::Layout::aos> w{
+        {0, 5}, {1, 6}, {2, 7}, {3, 8}, {4, 9}
+    };
+    uint32_t expected = 2;
+    for (memlayout::Wrapper<test::Point2D, memlayout::reference> p : w) {
+        p.x = expected;
+        p.y = expected;
+    }
+    for (memlayout::Wrapper<test::Point2D, memlayout::const_reference> p : w) {
+        EXPECT_EQ(p.x , expected);
+        EXPECT_EQ(p.y , expected);
+    }
+}
+TEST(Iterators, SoA) {
+    memlayout::Wrapper<test::Point2D, std::vector, memlayout::Layout::soa> w{
+        {{0, 1, 2, 3, 4}, {5, 6, 7, 8, 9}}
+    };
+    uint32_t expected = 2;
+    for (memlayout::Wrapper<test::Point2D, memlayout::reference> p : w) {
+        p.x = expected;
+        p.y = expected;
+    }
+    for (memlayout::Wrapper<test::Point2D, memlayout::const_reference> p : w) {
+        EXPECT_EQ(p.x , expected);
+        EXPECT_EQ(p.y , expected);
+    }
+}
+
+TEST(Sort, AoS) {
+    memlayout::Wrapper<test::Point2D, std::vector, memlayout::Layout::aos> w{
+        {9, 5}, {1, 6}, {5, 7}, {3, 8}, {2, 9}
+    };
+    std::sort(w.begin(), w.end(), test::Comp{});
+    EXPECT_EQ(w[0].y, 6);
+    EXPECT_EQ(w[1].y, 9);
+    EXPECT_EQ(w[2].y, 8);
+    EXPECT_EQ(w[3].y, 7);
+    EXPECT_EQ(w[4].y, 5);
+}
+TEST(Sort, SoA) {
+    memlayout::Wrapper<test::Point2D, std::vector, memlayout::Layout::soa> w{
+        {{9, 1, 5, 3, 2}, {5, 6, 7, 8, 9}}
+    };
+    std::sort(w.begin(), w.end(), test::Comp{});
+    EXPECT_EQ(w[0].y, 6);
+    EXPECT_EQ(w[1].y, 9);
+    EXPECT_EQ(w[2].y, 8);
+    EXPECT_EQ(w[3].y, 7);
+    EXPECT_EQ(w[4].y, 5);
+}

tests/include/structs.h

@@ -1,6 +1,8 @@
 #ifndef STRUCTS_H
 #define STRUCTS_H
 
+#include <algorithm>
+
 #include "memlayout/wrapper.h"
 
 namespace test {
@@ -14,6 +16,16 @@ struct Point2D {
     constexpr int32_t abs2() const { return x * x + y * y; }
 };
 
+void swap(Point2D<memlayout::reference> a, Point2D<memlayout::reference> b) {
+    std::swap(a.x, b.x);
+    std::swap(a.y, b.y);
+}
+
+struct Comp {
+    using cref = const memlayout::Wrapper<Point2D, memlayout::const_reference>;
+    constexpr bool operator()(cref& p, cref& q) const { return p.x < q.x; }
+};
+
 template <template <class> class Container>
 struct Point3D {
     MEMLAYOUT_APPLY_UNARY(point2d, z)