Implement MyEnumerateView for libc++ (#304)

Author: nikobockerman

solvers/cpp/src/bin/y2024_d07.cpp

@@ -1,5 +1,6 @@
 #include "answer.hpp"
 #include "convert.hpp"
+#include "my_enumerate_view.hpp"
 #include "my_fold_left_first.hpp"
 #include "solver.hpp"
 #include "utils.hpp"
@@ -130,7 +131,7 @@ class PossibleEquation {
 template <bool allowConcatenationOperator>
 auto solve(std::string_view input) {
   auto result = MyFoldLeftFirst(
-    splitLinesUntilEmpty(input) | views::enumerate |
+    splitLinesUntilEmpty(input) | MyEnumerate |
       views::transform([](auto&& args) -> std::optional<uint64_t> {
         auto [index, line] = args;
         auto parts = line | views::split(':') | ranges::to<std::vector>();

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_fold_left_first.test.cpp my_slide_view.test.cpp my_stride_view.test.cpp)
+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)
 target_link_libraries(lib-tests PRIVATE test_utils GTest::gtest_main)
 gtest_discover_tests(lib-tests)

solvers/cpp/src/lib/my_enumerate_view.hpp

@@ -0,0 +1,101 @@
+#pragma once
+
+#include <ranges>
+
+#if !defined(TEST_MY_ENUMERATE_VIEW) && __cpp_lib_ranges_enumerate >= 202302L
+
+inline constexpr auto MyEnumerate = std::views::enumerate;
+
+#else
+
+namespace internal {
+
+// Only supported via MyEnumerate adaptor
+
+template <std::ranges::viewable_range Rng>
+class MyEnumerateView
+  : public std::ranges::view_interface<MyEnumerateView<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 =
+      std::tuple<difference_type, std::ranges::range_value_t<Base>>;
+
+    explicit Iterator(BaseIter begin, BaseSentinel end) noexcept
+      : _cur{std::move(begin)}, _end{std::move(end)} {}
+
+    constexpr auto operator*() const noexcept(noexcept(
+      std::tuple<difference_type, std::ranges::range_reference_t<Base>>(
+        _count, *_cur))) {
+      return std::tuple<difference_type, std::ranges::range_reference_t<Base>>(
+        _count, *_cur);
+    }
+
+    constexpr Iterator& operator++() noexcept(
+      noexcept(std::ranges::advance(_cur, 1)) && noexcept(++_count)) {
+      std::ranges::advance(_cur, 1);
+      ++_count;
+      return *this;
+    }
+    constexpr void operator++(int) noexcept(noexcept(++(*this))) { ++(*this); }
+
+    constexpr bool operator==(const Iterator& o) const
+      noexcept(noexcept(_cur == o._cur)) {
+      return _cur == o._cur;
+    }
+    constexpr bool operator==(std::default_sentinel_t /*unused*/) const
+      noexcept(noexcept(_cur == _end)) {
+      return _cur == _end;
+    }
+
+   private:
+    BaseIter _cur;
+    BaseSentinel _end;
+    difference_type _count{0};
+  };
+
+ public:
+  explicit MyEnumerateView(Rng&& rng) noexcept(
+    noexcept(Base(std::views::all(std::move(rng)))))
+    : _base{std::views::all(std::move(rng))} {}
+
+  [[nodiscard]] constexpr auto begin() const
+    noexcept(noexcept(Iterator(std::ranges::begin(_base),
+                               std::ranges::end(_base))))
+    requires std::ranges::range<const Base>
+  {
+    return Iterator{std::ranges::begin(_base), std::ranges::end(_base)};
+  }
+  [[nodiscard]] constexpr auto begin() noexcept(
+    noexcept(Iterator(std::ranges::begin(_base), std::ranges::end(_base)))) {
+    return Iterator{std::ranges::begin(_base), std::ranges::end(_base)};
+  }
+
+  static constexpr auto end() noexcept { return std::default_sentinel; }
+
+ private:
+  Base _base;
+};
+
+class MyEnumerateAdaptorClosure
+  : public std::ranges::range_adaptor_closure<MyEnumerateAdaptorClosure> {
+ public:
+  template <std::ranges::viewable_range Rng>
+  constexpr auto operator()(Rng&& rng) const noexcept(
+    noexcept(MyEnumerateView<decltype(std::views::all(std::forward<Rng>(rng)))>(
+      std::views::all(std::forward<Rng>(rng))))) {
+    auto rngAll = std::views::all(std::forward<Rng>(rng));
+    return MyEnumerateView<decltype(rngAll)>{std::move(rngAll)};
+  }
+};
+
+}  // namespace internal
+
+inline constexpr internal::MyEnumerateAdaptorClosure MyEnumerate{};
+
+#endif

solvers/cpp/src/lib/my_enumerate_view.test.cpp

@@ -0,0 +1,63 @@
+#define TEST_MY_ENUMERATE_VIEW
+#include "my_enumerate_view.hpp"
+
+#include <gtest/gtest.h>
+
+#include <ranges>
+#include <span>
+#include <string>
+#include <tuple>
+
+#if defined(_LIBCPP_VERSION) && __cpp_lib_ranges_enumerate >= 202302L
+#error "libc++ started supporting std::views::enumerate. Use it directly"
+#endif
+
+namespace ranges = std::ranges;
+namespace views = std::views;
+
+using EnumeratedChar = std::tuple<size_t, char>;
+using Enumerated = std::vector<EnumeratedChar>;
+
+namespace {
+
+template <typename T>
+auto makeEnumeratedChar(size_t i, T&& v) {
+  return std::make_tuple<size_t, T>(std::move(i), std::forward<T>(v));
+}
+
+}  // namespace
+
+TEST(MyEnumerateView, BetweenPipes) {
+  const std::string data{"123456789"};
+  auto processed = data | views::drop(1) | MyEnumerate | views::take(4) |
+                   ranges::to<Enumerated>();
+  ASSERT_EQ(processed.size(), 4);
+  EXPECT_EQ(processed[0], makeEnumeratedChar(0, '2'));
+  EXPECT_EQ(processed[1], makeEnumeratedChar(1, '3'));
+  EXPECT_EQ(processed[2], makeEnumeratedChar(2, '4'));
+  EXPECT_EQ(processed[3], makeEnumeratedChar(3, '5'));
+}
+
+TEST(MyEnumerateView, NoElements) {
+  const std::string empty;
+  auto processed = empty | MyEnumerate | ranges::to<Enumerated>();
+  EXPECT_TRUE(processed.empty());
+}
+
+TEST(MyEnumerateView, SingleElement) {
+  const std::string one{"1"};
+  auto processed = one | MyEnumerate | ranges::to<Enumerated>();
+  ASSERT_EQ(processed.size(), 1);
+  EXPECT_EQ(processed[0], makeEnumeratedChar(0, '1'));
+}
+
+TEST(MyEnumerateView, ManyElements) {
+  const std::string data{"12345"};
+  auto processed = data | MyEnumerate | ranges::to<Enumerated>();
+  ASSERT_EQ(processed.size(), 5);
+  EXPECT_EQ(processed[0], makeEnumeratedChar(0, '1'));
+  EXPECT_EQ(processed[1], makeEnumeratedChar(1, '2'));
+  EXPECT_EQ(processed[2], makeEnumeratedChar(2, '3'));
+  EXPECT_EQ(processed[3], makeEnumeratedChar(3, '4'));
+  EXPECT_EQ(processed[4], makeEnumeratedChar(4, '5'));
+}