#include <__ranges/all.h>
#include <__ranges/concepts.h>
#include <__ranges/enable_borrowed_range.h>
+#include <__ranges/range_adaptor.h>
#include <__ranges/size.h>
#include <__ranges/view_interface.h>
+#include <__utility/forward.h>
#include <__utility/move.h>
#include <concepts>
#include <type_traits>
template<class _View>
inline constexpr bool enable_borrowed_range<common_view<_View>> = enable_borrowed_range<_View>;
+namespace views {
+namespace __common {
+ struct __fn : __range_adaptor_closure<__fn> {
+ template<class _Range>
+ requires common_range<_Range>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+ constexpr auto operator()(_Range&& __range) const
+ noexcept(noexcept(views::all(_VSTD::forward<_Range>(__range))))
+ -> decltype( views::all(_VSTD::forward<_Range>(__range)))
+ { return views::all(_VSTD::forward<_Range>(__range)); }
+
+ template<class _Range>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+ constexpr auto operator()(_Range&& __range) const
+ noexcept(noexcept(common_view{_VSTD::forward<_Range>(__range)}))
+ -> decltype( common_view{_VSTD::forward<_Range>(__range)})
+ { return common_view{_VSTD::forward<_Range>(__range)}; }
+ };
+}
+
+inline namespace __cpo {
+ inline constexpr auto common = __common::__fn{};
+}
+} // namespace views
} // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_RANGES)
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// Test the libc++ extension that std::views::common is marked as [[nodiscard]] to avoid
+// the potential for user mistakenly thinking they're calling an algorithm.
+
+#include <ranges>
+
+void test() {
+ int range[] = {1, 2, 3};
+
+ std::views::common(range); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+ range | std::views::common; // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::views::common
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <utility>
+
+#include "test_iterators.h"
+#include "types.h"
+
+template <class View, class T>
+concept CanBePiped = requires (View&& view, T&& t) {
+ { std::forward<View>(view) | std::forward<T>(t) };
+};
+
+constexpr bool test() {
+ int buf[] = {1, 2, 3};
+
+ // views::common(r) is equivalent to views::all(r) if r is a common_range
+ {
+ {
+ CommonView view(buf, buf + 3);
+ std::same_as<CommonView> auto result = std::views::common(view);
+ assert(result.begin_ == buf);
+ assert(result.end_ == buf + 3);
+ }
+ {
+ using NotAView = std::array<int, 3>;
+ NotAView arr = {1, 2, 3};
+ std::same_as<std::ranges::ref_view<NotAView>> auto result = std::views::common(arr);
+ assert(result.begin() == arr.begin());
+ assert(result.end() == arr.end());
+ }
+ }
+
+ // Otherwise, views::common(r) is equivalent to ranges::common_view{r}
+ {
+ NonCommonView view(buf, buf + 3);
+ std::same_as<std::ranges::common_view<NonCommonView>> auto result = std::views::common(view);
+ assert(result.base().begin_ == buf);
+ assert(result.base().end_ == buf + 3);
+ }
+
+ // Test that std::views::common is a range adaptor
+ {
+ using SomeView = NonCommonView;
+
+ // Test `v | views::common`
+ {
+ SomeView view(buf, buf + 3);
+ std::same_as<std::ranges::common_view<SomeView>> auto result = view | std::views::common;
+ assert(result.base().begin_ == buf);
+ assert(result.base().end_ == buf + 3);
+ }
+
+ // Test `adaptor | views::common`
+ {
+ SomeView view(buf, buf + 3);
+ auto f = [](int i) { return i; };
+ auto const partial = std::views::transform(f) | std::views::common;
+ using Result = std::ranges::common_view<std::ranges::transform_view<SomeView, decltype(f)>>;
+ std::same_as<Result> auto result = partial(view);
+ assert(result.base().base().begin_ == buf);
+ assert(result.base().base().end_ == buf + 3);
+ }
+
+ // Test `views::common | adaptor`
+ {
+ SomeView view(buf, buf + 3);
+ auto f = [](int i) { return i; };
+ auto const partial = std::views::common | std::views::transform(f);
+ using Result = std::ranges::transform_view<std::ranges::common_view<SomeView>, decltype(f)>;
+ std::same_as<Result> auto result = partial(view);
+ assert(result.base().base().begin_ == buf);
+ assert(result.base().base().end_ == buf + 3);
+ }
+
+ // Check SFINAE friendliness
+ {
+ struct NotAView { };
+ static_assert(!std::is_invocable_v<decltype(std::views::common)>);
+ static_assert(!std::is_invocable_v<decltype(std::views::common), NotAView>);
+ static_assert( CanBePiped<SomeView&, decltype(std::views::common)>);
+ static_assert( CanBePiped<int(&)[10], decltype(std::views::common)>);
+ static_assert(!CanBePiped<int(&&)[10], decltype(std::views::common)>);
+ static_assert(!CanBePiped<NotAView, decltype(std::views::common)>);
+ }
+ }
+
+ {
+ static_assert(std::same_as<decltype(std::views::common), decltype(std::ranges::views::common)>);
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
#ifndef TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_COMMON_VIEW_TYPES_H
#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_COMMON_VIEW_TYPES_H
+#include <ranges>
+
#include "test_iterators.h"
struct DefaultConstructibleView : std::ranges::view_base {
return iter.base() - sent.base().base();
}
+struct CommonView : std::ranges::view_base {
+ int* begin_;
+ int* end_;
+ constexpr explicit CommonView(int* b, int* e) : begin_(b), end_(e) { }
+ friend constexpr int* begin(CommonView& view) { return view.begin_; }
+ friend constexpr int* begin(CommonView const& view) { return view.begin_; }
+ friend constexpr int* end(CommonView& view) { return view.end_; }
+ friend constexpr int* end(CommonView const& view) { return view.end_; }
+};
+static_assert(std::ranges::range<CommonView>);
+static_assert(std::ranges::common_range<CommonView>);
+
+struct NonCommonView : std::ranges::view_base {
+ int* begin_;
+ int* end_;
+ constexpr explicit NonCommonView(int* b, int* e) : begin_(b), end_(e) { }
+ friend constexpr int* begin(NonCommonView& view) { return view.begin_; }
+ friend constexpr int* begin(NonCommonView const& view) { return view.begin_; }
+ friend constexpr sentinel_wrapper<int*> end(NonCommonView& view) { return sentinel_wrapper<int*>(view.end_); }
+ friend constexpr sentinel_wrapper<int*> end(NonCommonView const& view) { return sentinel_wrapper<int*>(view.end_); }
+};
+static_assert( std::ranges::range<NonCommonView>);
+static_assert(!std::ranges::common_range<NonCommonView>);
+
#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_COMMON_VIEW_TYPES_H