test view::begin() WIP

Author: PaulXiCao

libcxx/include/__ranges/cartesian_product_view.h

@@ -132,24 +132,27 @@ class cartesian_product_view : public view_interface<cartesian_product_view<Firs
   constexpr iterator<is_const> end_impl() const {
     bool is_empty                  = end_is_empty();
     const auto ranges_to_iterators = [is_empty, &b = bases_]<std::size_t... I>(std::index_sequence<I...>) {
-      const auto begin_or_first_end = [is_empty]<bool is_first>(const auto& rng) {
-        if constexpr (is_first)
+      const auto begin_or_first_end = [is_empty]<class is_first>(is_first, const auto& rng) {
+        if constexpr (is_first::value)
           return is_empty ? ranges::begin(rng) : cartesian_common_arg_end(rng);
         return ranges::begin(rng);
       };
-      return std::make_tuple(begin_or_first_end<I == 0>(std::get<I>(b))...);
+
+      return std::make_tuple(begin_or_first_end(std::bool_constant<I == 0>{}, std::get<I>(b))...);
     };
     iterator<is_const> it(*this, ranges_to_iterators(std::make_index_sequence<1 + sizeof...(Vs)>{}));
     return it;
   }
 
-  template <auto N = 1>
+  template <std::size_t N = 1>
   constexpr bool end_is_empty() const {
     if constexpr (N == 1 + sizeof...(Vs))
       return false;
-    if (const auto& v = std::get<N>(bases_); ranges::empty(v))
-      return true;
-    return end_is_empty<N + 1>();
+    else {
+      if (const auto& v = std::get<N>(bases_); ranges::empty(v))
+        return true;
+      return end_is_empty<N + 1>();
+    }
   }
 
   constexpr auto size_impl() const {
@@ -180,6 +183,8 @@ class cartesian_product_view<First, Vs...>::iterator {
       return input_iterator_tag{};
   }
 
+  friend cartesian_product_view;
+
 public:
   using iterator_category = input_iterator_tag;
   using iterator_concept  = decltype(get_iterator_tag());

libcxx/test/std/ranges/range.adaptors/range.cartesian.product.view/begin.pass.cpp

@@ -0,0 +1,120 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr iterator<false> begin()       requires (!simple-view<First> || ... || !simple-view <Vs>);
+// constexpr iterator<true > begin() const requires (range<const First> && ... && range<const Vs>);
+
+#include <ranges>
+
+// #include <cassert>
+// #include <concepts>
+// #include <tuple>
+// #include <utility>
+
+#include "types.h"
+
+template <class T>
+concept HasConstBegin = requires(const T& ct) { ct.begin(); };
+
+template <class T>
+concept HasNonConstBegin = requires(T& t) { t.begin(); };
+
+template <class T>
+concept HasConstAndNonConstBegin =
+    HasConstBegin<T> && HasNonConstBegin<T> && 
+    requires(T& t, const T& ct) { requires !std::same_as<decltype(t.begin()), decltype(ct.begin())>; };
+
+template <class T>
+concept HasOnlyNonConstBegin = HasNonConstBegin<T> && !HasConstBegin<T>;
+
+template <class T>
+concept HasOnlyConstBegin = HasConstBegin<T> && !HasConstAndNonConstBegin<T>;
+
+struct OnlyNonConstBeginView : std::ranges::view_base {
+  int* begin();
+  int* end();
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {   // all underlying iterators should be at the begin position
+    { // non-const
+      std::ranges::cartesian_product_view v(
+          SizedRandomAccessView{buffer}, std::views::iota(0), std::ranges::single_view(2.0));
+      std::same_as<std::tuple<int&, int, double&>> decltype(auto) val = *v.begin();
+      assert(val == std::make_tuple(1, 0, 2.0));
+      assert(&(std::get<0>(val)) == &buffer[0]);
+    }
+    { // const
+      const std::ranges::cartesian_product_view v(
+          SizedRandomAccessView{buffer}, std::views::iota(0), std::ranges::single_view(2.0));
+      std::same_as<std::tuple<int&, int, const double&>> decltype(auto) val = *v.begin();
+      assert(val == std::make_tuple(1, 0, 2.0));
+      assert(&(std::get<0>(val)) == &buffer[0]);
+    }
+  }
+
+  {   // with empty range
+    { // non-const
+      std::ranges::cartesian_product_view v(SizedRandomAccessView{buffer}, std::ranges::empty_view<int>());
+      assert(v.begin() == v.end());
+    }
+    { // const
+      const std::ranges::cartesian_product_view v(SizedRandomAccessView{buffer}, std::ranges::empty_view<int>());
+      assert(v.begin() == v.end());
+    }
+  }
+
+  {
+    // underlying ranges all model simple-view
+    std::ranges::cartesian_product_view v(SimpleCommon{buffer}, SimpleCommon{buffer});
+    static_assert(std::is_same_v<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+    assert(v.begin() == std::as_const(v).begin());
+    auto [x, y] = *std::as_const(v).begin();
+    assert(&x == &buffer[0]);
+    assert(&y == &buffer[0]);
+
+    using View = decltype(v);
+    static_assert(std::ranges::__simple_view<SimpleCommon>);
+    static_assert(HasOnlyConstBegin<View>);
+    static_assert(!HasOnlyNonConstBegin<View>);
+    static_assert(!HasConstAndNonConstBegin<View>);
+  }
+
+  // {
+  //   // not all underlying ranges model simple-view
+  //   std::ranges::zip_view v(SimpleCommon{buffer}, NonSimpleNonCommon{buffer});
+  //   static_assert(!std::is_same_v<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+  //   assert(v.begin() == std::as_const(v).begin());
+  //   auto [x, y] = *std::as_const(v).begin();
+  //   assert(&x == &buffer[0]);
+  //   assert(&y == &buffer[0]);
+
+  //   using View = decltype(v);
+  //   static_assert(!HasOnlyConstBegin<View>);
+  //   static_assert(!HasOnlyNonConstBegin<View>);
+  //   static_assert(HasConstAndNonConstBegin<View>);
+  // }
+
+  // {
+  //   // underlying const R is not a range
+  //   using View = std::ranges::zip_view<SimpleCommon, NoConstBeginView>;
+  //   static_assert(!HasOnlyConstBegin<View>);
+  //   static_assert(HasOnlyNonConstBegin<View>);
+  //   static_assert(!HasConstAndNonConstBegin<View>);
+  // }
+  return true;
+}
+
+int main() {
+  test();
+  static_assert(test());
+}