Implement MyChunkView for libc++ (#305)

Author: nikobockerman

solvers/cpp/src/bin/y2022_d03.cpp

@@ -1,4 +1,5 @@
 #include "answer.hpp"
+#include "my_chunk_view.hpp"
 #include "my_fold_left_first.hpp"
 #include "solver.hpp"
 #include "utils.hpp"
@@ -163,7 +164,7 @@ constexpr auto solve2(auto inputStr) {
   constexpr std::size_t groupSize{3};
 
   return sumScore(
-    splitLinesUntilEmpty(inputStr) | views::chunk(groupSize) |
+    splitLinesUntilEmpty(inputStr) | MyChunk(groupSize) |
     views::transform([](auto&& group) { return getGroupBadgeItem(group); }));
 }
 

solvers/cpp/src/lib/CMakeLists.txt

@@ -1,6 +1,6 @@
 add_library(lib INTERFACE)
 target_include_directories(lib INTERFACE ${CMAKE_CURRENT_LIST_DIR})
 
-add_executable(lib-tests my_enumerate_view.test.cpp my_fold_left_first.test.cpp my_slide_view.test.cpp my_stride_view.test.cpp)
+add_executable(lib-tests my_chunk_view.test.cpp my_enumerate_view.test.cpp my_fold_left_first.test.cpp my_slide_view.test.cpp my_stride_view.test.cpp)
 target_link_libraries(lib-tests PRIVATE test_utils GTest::gtest_main)
 gtest_discover_tests(lib-tests)

solvers/cpp/src/lib/my_chunk_view.hpp

@@ -0,0 +1,119 @@
+#pragma once
+
+#include <ranges>
+
+#if !defined(TEST_MY_CHUNK_VIEW) && __cpp_lib_ranges_chunk >= 202202L
+
+inline constexpr auto MyChunk = std::views::chunk;
+
+#else
+
+namespace internal {
+
+// Only supported via MyChunk adaptor
+
+template <std::ranges::viewable_range Rng>
+class MyChunkView : public std::ranges::view_interface<MyChunkView<Rng>> {
+  using Base = Rng;
+
+  class Iterator {
+    using BaseIter = std::ranges::iterator_t<Base>;
+    using BaseSentinel = std::ranges::sentinel_t<Base>;
+
+   public:
+    using difference_type = std::ranges::range_difference_t<Base>;
+    using value_type = decltype(std::ranges::subrange<BaseIter>());
+
+    explicit Iterator(BaseIter begin, BaseSentinel end, std::size_t n) noexcept(
+      noexcept(std::ranges::advance(_curChunkEnd, _n, _end)))
+      : _curChunkBegin{std::move(begin)},
+        _curChunkEnd{_curChunkBegin},
+        _end{std::move(end)},
+        _n{n} {
+      std::ranges::advance(_curChunkEnd, _n, _end);
+    }
+
+    constexpr auto operator*() const
+      noexcept(noexcept(std::ranges::subrange(_curChunkBegin, _curChunkEnd))) {
+      return std::ranges::subrange(_curChunkBegin, _curChunkEnd);
+    }
+
+    constexpr Iterator& operator++() noexcept(
+      noexcept(std::ranges::advance(_curChunkBegin, _n, _end)) &&
+      noexcept(std::ranges::advance(_curChunkEnd, _n, _end))) {
+      std::ranges::advance(_curChunkBegin, _n, _end);
+      std::ranges::advance(_curChunkEnd, _n, _end);
+      return *this;
+    }
+    constexpr void operator++(int) noexcept(noexcept(++(*this))) { ++(*this); }
+
+    constexpr bool operator==(const Iterator& o) const
+      noexcept(noexcept(_curChunkBegin == o._curChunkBegin)) {
+      return _curChunkBegin == o._curChunkBegin;
+    }
+    constexpr bool operator==(std::default_sentinel_t /*unused*/) const
+      noexcept(noexcept(_curChunkBegin == _end)) {
+      return _curChunkBegin == _end;
+    }
+
+   private:
+    BaseIter _curChunkBegin;
+    BaseIter _curChunkEnd;
+    BaseSentinel _end;
+    std::size_t _n;
+  };
+
+ public:
+  explicit MyChunkView(Rng&& rng, std::size_t n) noexcept(
+    noexcept(Base(std::views::all(std::move(rng)))))
+    : _base{std::views::all(std::move(rng))}, _n{n} {}
+
+  [[nodiscard]] constexpr auto begin() const
+    noexcept(noexcept(Iterator(std::ranges::begin(_base),
+                               std::ranges::end(_base), _n)))
+    requires std::ranges::range<const Base>
+  {
+    return Iterator{std::ranges::begin(_base), std::ranges::end(_base), _n};
+  }
+  [[nodiscard]] constexpr auto begin() noexcept(noexcept(
+    Iterator(std::ranges::begin(_base), std::ranges::end(_base), _n))) {
+    return Iterator{std::ranges::begin(_base), std::ranges::end(_base), _n};
+  }
+
+  static constexpr auto end() noexcept { return std::default_sentinel; }
+
+ private:
+  Base _base;
+  std::size_t _n;
+};
+
+class MyChunkAdaptorClosure
+  : public std::ranges::range_adaptor_closure<MyChunkAdaptorClosure> {
+ public:
+  constexpr explicit MyChunkAdaptorClosure(std::size_t n) noexcept : _n{n} {}
+
+  template <std::ranges::viewable_range Rng>
+  constexpr auto operator()(Rng&& rng) const noexcept(
+    noexcept(MyChunkView<decltype(std::views::all(std::forward<Rng>(rng)))>(
+      std::views::all(std::forward<Rng>(rng)), _n))) {
+    auto rngAll = std::views::all(std::forward<Rng>(rng));
+    return MyChunkView<decltype(rngAll)>{std::move(rngAll), _n};
+  }
+
+ private:
+  std::size_t _n;
+};
+
+}  // namespace internal
+
+class MyChunkAdaptor {
+ public:
+  constexpr internal::MyChunkAdaptorClosure operator()(
+    std::size_t n) const noexcept {
+    return internal::MyChunkAdaptorClosure{n};
+  }
+};
+
+inline constexpr MyChunkAdaptor MyChunk{};
+
+#endif

solvers/cpp/src/lib/my_chunk_view.test.cpp

@@ -0,0 +1,48 @@
+#define TEST_MY_CHUNK_VIEW
+#include "my_chunk_view.hpp"
+
+#include <gtest/gtest.h>
+
+#include <ranges>
+#include <span>
+#include <string>
+#include <tuple>
+
+#if defined(_LIBCPP_VERSION) && __cpp_lib_ranges_chunk >= 202202L
+#error "libc++ started supporting std::views::chunk. Use it directly"
+#endif
+
+namespace ranges = std::ranges;
+namespace views = std::views;
+
+using Chunked = std::vector<std::string>;
+
+TEST(MyChunkView, BetweenPipes) {
+  const std::string data{"123456789"};
+  auto processed =
+    data | views::drop(1) | MyChunk(3) | views::take(2) | ranges::to<Chunked>();
+  ASSERT_EQ(processed.size(), 2);
+  EXPECT_EQ(processed[0], "234");
+  EXPECT_EQ(processed[1], "567");
+}
+
+TEST(MyChunkView, EmptyData) {
+  const std::string empty;
+  auto processed = empty | MyChunk(2) | ranges::to<std::vector>();
+  EXPECT_TRUE(processed.empty());
+}
+
+TEST(MyChunkView, EqualSize) {
+  const std::string one{"123"};
+  auto processed = one | MyChunk(3) | ranges::to<Chunked>();
+  ASSERT_EQ(processed.size(), 1);
+  EXPECT_EQ(processed[0], "123");
+}
+
+TEST(MyChunkView, LargerThanInput) {
+  const std::string data{"12345"};
+  auto processed = data | MyChunk(4) | ranges::to<Chunked>();
+  ASSERT_EQ(processed.size(), 2);
+  EXPECT_EQ(processed[0], "1234");
+  EXPECT_EQ(processed[1], "5");
+}