implement and test 'from_range'

Author: mnikander

CMakeLists.txt

@@ -46,6 +46,7 @@ add_executable(unit_tests ${SOURCES}
                test/prototype/crtp_take.test.cpp
                test/duplicate.test.cpp
                test/from_vector.test.cpp
+               test/from_range.test.cpp
                test/filter.test.cpp
                test/main.test.cpp
                test/map.test.cpp

src/source/from_range.hpp

@@ -0,0 +1,63 @@
+// Copyright (c) 2025, Marco Nikander
+
+#pragma once
+#include <iterator>
+#include <utility> // forward
+#include "../datatypes.hpp"
+
+namespace seq {
+namespace {
+
+// Is there a better way to make iteration end, than using the limit in the 'yield' function?
+// A later stage could communicate when to terminate the iteration, via a return value.
+// This would complicate the design though, and make it similar to my prior design.
+// Let's try it without back-communication, and see if we get a simpler design, which actually works.
+
+template <typename I, typename S>
+struct FromRangeImpl {
+    using Input = typename std::iterator_traits<I>::value_type;
+
+    FromRangeImpl(I first, I last, S successor) : _first{first}, _current{first}, _last{last}, _successor{successor} {}
+
+    // yield runs a fixed number of times, unless it gets a HALT signal beforehand
+    // yield can be called again, and it will continue where it left off last time, even if it stopped due to a HALT
+    Status yield(uint64_t const count = 1u) {
+        Status status = OK;
+        for(uint64_t i = 0; i < count && _current != _last && status == OK; ++i) {
+            status = _successor.receive(Input{*_current}); // copy the element to get an rvalue :(
+            ++_current;
+        }
+        if (_current != _last) {
+            status = HALT;
+        }
+        return status;
+    }
+
+    Status run() {
+        Status status = OK;
+        while(_current != _last && status == OK) {
+            status = _successor.receive(Input{*_current}); // copy the element to get an rvalue :(
+            ++_current;
+        }
+        status = HALT;
+        return status;
+    }
+
+    I const _first;
+    I _current;
+    I const _last;
+    S _successor;
+};
+
+template <typename I, typename S>
+auto from_range(I first, I last, S successor) {
+    return FromRangeImpl<I, S>{first, last, successor};
+}
+
+template <typename R, typename S>
+auto from_range(R const& range, S successor) {
+    return FromRangeImpl<typename R::const_iterator, S>{range.cbegin(), range.cend(), successor};
+}
+
+}
+}

test/from_range.test.cpp

@@ -0,0 +1,64 @@
+// Copyright (c) 2025, Marco Nikander
+
+#include <functional>
+#include <vector>
+#include <gtest/gtest.h>
+#include "../src/sink/to_range.hpp"
+#include "../src/sink/to_value.hpp"
+#include "../src/source/from_range.hpp"
+#include "../src/stage/filter.hpp"
+#include "../src/stage/map.hpp"
+#include "../src/stage/reduce.hpp"
+#include "../src/stage/take.hpp"
+#include "../src/datatypes.hpp"
+
+TEST(from_range, sum)
+{
+    using namespace seq;
+    std::vector<i64> const input{0, 1, 2, 4, 8};
+    i64 result = 0;
+
+    // pipeline stages, from last to first
+    auto sink     = to_value(result);
+    auto stage    = reduce<i64>(std::plus<i64>{}, 0L, sink);
+    auto sequence = from_range(input.cbegin(), input.cend(), stage);
+
+    sequence.yield(5);
+    EXPECT_EQ(result, 15);
+}
+
+TEST(from_range, nested_pipeline)
+{
+    using namespace seq;
+    std::vector<i64> const input{0, 1, 2, 4, 8};
+    i64 result = 0;
+
+    // pipeline, nested in order
+    auto sequence =
+        from_range(input,
+            reduce<i64>(std::plus<i64>{}, 0L,
+                to_value(result)));
+
+    sequence.yield(5);
+    EXPECT_EQ(result, 15);
+}
+
+TEST(from_range, map_filter_reduce) {
+    using namespace seq;
+
+    auto plusTwo = [](i64 i){ return i + 2; };
+    auto isEven  = [](i64 i){ return i % 2 == 0; };
+    std::vector<i64> const input{0, 1, 2, 4, 8};
+    i64 result = 0;
+
+    // pipeline, nested in order
+    auto sequence =
+        from_range(input,
+            map<i64>(plusTwo,
+                filter<i64>(isEven,
+                    reduce<i64>(std::plus<i64>{}, 0L,
+                        take<i64>(4,
+                            to_value(result))))));
+    sequence.run(); // sum of (2, 4, 6, 10)
+    EXPECT_EQ(result, 22);
+}