[libcxx] adds `std::indirectly_writable` to <iterator>

[cjdb]

Summary

Implements parts of:

• P0896R4 The One Ranges Proposal`

Depends on D100073

[cjdb]

updates synopsis, rebases to activate CI

[zoecarver]

LGTM. Thanks.

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.writable/indirectly_writable.compile.pass.cpp

220

Only one template param.

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

[cjdb]

D100073 absorbed this patch.

libcxx/include/iterator

 using iter_rvalue_reference_t
   = decltype(ranges::iter_move(declval<T&>()));
 
 // [iterator.concepts], iterator concepts
 // [iterator.concept.readable], concept indirectly_­readable
 template<class In>
   concept indirectly_readable = see below;                // since C++20
 
+// [iterator.concept.writable], concept indirectly_­writable
+template<class Out, class T>
+  concept indirectly_writable = see below;                // since C++20
+
 template<class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
 struct iterator
 {
     typedef T         value_type;
     typedef Distance  difference_type;
     typedef Pointer   pointer;
     typedef Reference reference;
concept __indirectly_readable_impl =
   } &&
   common_reference_with<iter_reference_t<_In>&&, iter_value_t<_In>&> &&
   common_reference_with<iter_reference_t<_In>&&, iter_rvalue_reference_t<_In>&&> &&
   common_reference_with<iter_rvalue_reference_t<_In>&&, const iter_value_t<_In>&>;
 
 template<class _In>
 concept indirectly_readable = __indirectly_readable_impl<remove_cvref_t<_In>>;
 
+// [iterator.concept.writable]
+template<class _Out, class _Tp>
+concept indirectly_writable =
+  requires(_Out&& __o, _Tp&& __t) {
+    *__o = _VSTD::forward<_Tp>(__t);                        // not required to be equality-preserving
+    *_VSTD::forward<_Out>(__o) = _VSTD::forward<_Tp>(__t);  // not required to be equality-preserving
+    const_cast<const iter_reference_t<_Out>&&>(*__o) = _VSTD::forward<_Tp>(__t);                       // not required to be equality-preserving
+    const_cast<const iter_reference_t<_Out>&&>(*_VSTD::forward<_Out>(__o)) = _VSTD::forward<_Tp>(__t); // not required to be equality-preserving
+  };
+
 #undef _LIBCPP_NOEXCEPT_RETURN
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_ITERATOR

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.writable/indirectly_writable.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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: gcc-10
+
+// template<class In>
+// concept indirectly_writable;
+
+#include <iterator>
+
+#include <array>
+#include <concepts>
+#include <deque>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#include <filesystem>
+#endif
+#include <forward_list>
+#include <istream>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <string_view>
+#include <optional>
+#include <ostream>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "../read_write.h"
+
+template <class Out, class T>
+[[nodiscard]] constexpr bool check_indirectly_writable() {
+  constexpr bool result = std::indirectly_writable<Out, T>;
+  static_assert(std::indirectly_writable<Out const, T> == result);
+  return result;
+}
+
+static_assert(check_indirectly_writable<traditional_indirection, int>());
+static_assert(check_indirectly_writable<traditional_indirection, double>());
+static_assert(!check_indirectly_writable<traditional_indirection, double*>());
+
+static_assert(!check_indirectly_writable<read_only_indirection, int>());
+static_assert(!check_indirectly_writable<proxy_indirection, int>());
+
+static_assert(!check_indirectly_writable<int, int>());
+static_assert(!check_indirectly_writable<missing_dereference,
+                                         missing_dereference::value_type>());
+
+namespace standard_types {
+static_assert(check_indirectly_writable<int*, int>());
+static_assert(!check_indirectly_writable<int const*, int>());
+static_assert(check_indirectly_writable<int volatile*, int>());
+static_assert(!check_indirectly_writable<int const volatile*, int>());
+static_assert(check_indirectly_writable<int*, double>());
+static_assert(check_indirectly_writable<int**, int*>());
+static_assert(!check_indirectly_writable<int**, int>());
+
+static_assert(!check_indirectly_writable<int&, int>());
+static_assert(!check_indirectly_writable<int const&, int>());
+static_assert(!check_indirectly_writable<int volatile&, int>());
+static_assert(!check_indirectly_writable<int const volatile&, int>());
+
+static_assert(!check_indirectly_writable<int&&, int>());
+static_assert(!check_indirectly_writable<int const&&, int>());
+static_assert(!check_indirectly_writable<int volatile&&, int>());
+static_assert(!check_indirectly_writable<int const volatile&&, int>());
+// <array>
+static_assert(check_indirectly_writable<std::array<int, 10>::iterator, int>());
+static_assert(
+    !check_indirectly_writable<std::array<int, 10>::const_iterator, int>());
+static_assert(
+    check_indirectly_writable<std::array<int, 10>::reverse_iterator, int>());
+static_assert(!check_indirectly_writable<
+              std::array<int, 10>::const_reverse_iterator, int>());
+
+// <deque>
+static_assert(check_indirectly_writable<std::deque<int>::iterator, int>());
+static_assert(
+    !check_indirectly_writable<std::deque<int>::const_iterator, int>());
+static_assert(
+    check_indirectly_writable<std::deque<int>::reverse_iterator, int>());
+static_assert(
+    !check_indirectly_writable<std::deque<int>::const_reverse_iterator, int>());
+
+// <forward_list>
+static_assert(
+    check_indirectly_writable<std::forward_list<int>::iterator, int>());
+static_assert(
+    !check_indirectly_writable<std::forward_list<int>::const_iterator, int>());
+
+// <iterator>
+static_assert(std::indirectly_writable<
+              std::back_insert_iterator<std::vector<int> >, int>);
+static_assert(!std::indirectly_writable<
+              std::back_insert_iterator<std::vector<int> > const, int>);
+static_assert(std::indirectly_writable<
+              std::front_insert_iterator<std::deque<int> >, int>);
+static_assert(!std::indirectly_writable<
+              std::front_insert_iterator<std::deque<int> > const, int>);
+static_assert(
+    std::indirectly_writable<std::insert_iterator<std::deque<int> >, int>);
+static_assert(!std::indirectly_writable<
+              std::insert_iterator<std::deque<int> > const, int>);
+static_assert(
+    !check_indirectly_writable<std::istream_iterator<int, char>, int>());
+static_assert(
+    !check_indirectly_writable<std::istreambuf_iterator<char>, int>());
+static_assert(!check_indirectly_writable<
+              std::move_iterator<std::vector<int>::iterator>, int>());
+static_assert(std::indirectly_writable<std::ostream_iterator<int, char>, int>);
+static_assert(
+    !std::indirectly_writable<std::ostream_iterator<int, char> const, int>);
+static_assert(
+    std::indirectly_writable<std::ostreambuf_iterator<int, char>, int>);
+static_assert(
+    !std::indirectly_writable<std::ostreambuf_iterator<int, char> const, int>);
+
+// <list>
+static_assert(check_indirectly_writable<std::list<int>::iterator, int>());
+static_assert(
+    !check_indirectly_writable<std::list<int>::const_iterator, int>());
+static_assert(
+    check_indirectly_writable<std::list<int>::reverse_iterator, int>());
+static_assert(
+    !check_indirectly_writable<std::list<int>::const_reverse_iterator, int>());
+
+// <map>
+static_assert(!check_indirectly_writable<std::map<int, int>::iterator,
+                                         std::pair<int, int> >());
+static_assert(!check_indirectly_writable<std::map<int, int>::const_iterator,
+                                         std::pair<int, int> >());
+static_assert(!check_indirectly_writable<std::map<int, int>::reverse_iterator,
+                                         std::pair<int, int> >());
+static_assert(
+    !check_indirectly_writable<std::map<int, int>::const_reverse_iterator,
+                               std::pair<int, int> >());
+
+static_assert(!check_indirectly_writable<std::multimap<int, int>::iterator,
+                                         std::pair<int, int> >());
+static_assert(!check_indirectly_writable<
+              std::multimap<int, int>::const_iterator, std::pair<int, int> >());
+static_assert(
+    !check_indirectly_writable<std::multimap<int, int>::reverse_iterator,
+                               std::pair<int, int> >());
+static_assert(
+    !check_indirectly_writable<std::multimap<int, int>::const_reverse_iterator,
+                               std::pair<int, int> >());
+
+// <memory>
+static_assert(check_indirectly_writable<std::shared_ptr<int>, int>());
+static_assert(!check_indirectly_writable<std::shared_ptr<void>, int>());
+static_assert(check_indirectly_writable<std::unique_ptr<int>, int>());
+static_assert(!check_indirectly_writable<std::unique_ptr<void>, int>());
+
+// <optional>
+static_assert(!check_indirectly_writable<std::optional<int>, int>());
+
+// <set>
+static_assert(!check_indirectly_writable<std::set<int>::iterator, int>());
+static_assert(!check_indirectly_writable<std::set<int>::const_iterator, int>());
+static_assert(
+    !check_indirectly_writable<std::set<int>::reverse_iterator, int>());
+static_assert(
+    !check_indirectly_writable<std::set<int>::const_reverse_iterator, int>());
+
+static_assert(!check_indirectly_writable<std::multiset<int>::iterator, int>());
+static_assert(
+    !check_indirectly_writable<std::multiset<int>::const_iterator, int>());
+static_assert(
+    !check_indirectly_writable<std::multiset<int>::reverse_iterator, int>());
+static_assert(!check_indirectly_writable<
+              std::multiset<int>::const_reverse_iterator, int>());
+
+// <string>
+static_assert(check_indirectly_writable<std::string::iterator, char>());
+static_assert(!check_indirectly_writable<std::string::const_iterator, char>());
+static_assert(check_indirectly_writable<std::string::reverse_iterator, char>());
+static_assert(
+    !check_indirectly_writable<std::string::const_reverse_iterator, char>());
+
+// // <string_view>
+static_assert(!check_indirectly_writable<std::string_view::iterator, char>());
+static_assert(
+    !check_indirectly_writable<std::string_view::const_iterator, char>());
+static_assert(
+    !check_indirectly_writable<std::string_view::reverse_iterator, char>());
+static_assert(!check_indirectly_writable<
+              std::string_view::const_reverse_iterator, char>());
+
+// <unordered_map>
+static_assert(!check_indirectly_writable<std::unordered_map<int, int>::iterator,
+                                         std::pair<int, int> >());
+static_assert(
+    !check_indirectly_writable<std::unordered_map<int, int>::const_iterator,
+                               std::pair<int, int> >());
+
+static_assert(
+    !check_indirectly_writable<std::unordered_multimap<int, int>::iterator,
+                               std::pair<int, int> >());
+static_assert(!check_indirectly_writable<
+              std::unordered_multimap<int, int>::const_iterator,
+              std::pair<int, int> >());
+
+// <unordered_set>
+static_assert(
+    !check_indirectly_writable<std::unordered_set<int>::iterator, int>());
+static_assert(
+    !check_indirectly_writable<std::unordered_set<int>::const_iterator, int>());
+
+static_assert(!check_indirectly_writable<
+              std::unordered_multiset<int, int>::iterator, int>());
+static_assert(!check_indirectly_writable<
+              std::unordered_multiset<int, int>::const_iterator, int>());
+
+// <vector>
+static_assert(check_indirectly_writable<std::vector<int>::iterator, int>());
+static_assert(
+    !check_indirectly_writable<std::vector<int>::const_iterator, int>());
+static_assert(
+    check_indirectly_writable<std::vector<int>::reverse_iterator, int>());
+static_assert(!check_indirectly_writable<
+              std::vector<int>::const_reverse_iterator, int>());
+static_assert(!check_indirectly_writable<std::vector<int>, int>());
+} // namespace standard_types