Merge 2022-07 LWG Motion 4

Author: tkoeppe

source/containers.tex

@@ -15692,7 +15692,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-m.is_contiguous()
+m.is_exhaustive()
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -15708,7 +15708,7 @@
 \begin{note}
 A mapping can return \tcode{false} even if the condition is met.
 For certain layouts, it is possibly not feasible to determine efficiently
-whether the layout is contiguous.
+whether the layout is exhaustive.
 \end{note}
 \end{itemdescr}
 
@@ -15779,7 +15779,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-M::is_always_contiguous()
+M::is_always_exhaustive()
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -15789,12 +15789,12 @@
 
 \pnum
 \returns
-\tcode{true} only if \tcode{m.is_contiguous()} is \tcode{true}
+\tcode{true} only if \tcode{m.is_exhaustive()} is \tcode{true}
 for all possible objects \tcode{m} of type \tcode{M}.
 \begin{note}
 A mapping can return \tcode{false} even if the above condition is met.
 For certain layout mappings, it is possibly not feasible to determine
-whether every instance is contiguous.
+whether every instance is exhaustive.
 \end{note}
 \end{itemdescr}
 
@@ -15897,11 +15897,11 @@
       constexpr index_type operator()(Indices...) const noexcept;
 
     static constexpr bool is_always_unique() noexcept { return true; }
-    static constexpr bool is_always_contiguous() noexcept { return true; }
+    static constexpr bool is_always_exhaustive() noexcept { return true; }
     static constexpr bool is_always_strided() noexcept { return true; }
 
     static constexpr bool is_unique() noexcept { return true; }
-    static constexpr bool is_contiguous() noexcept { return true; }
+    static constexpr bool is_exhaustive() noexcept { return true; }
     static constexpr bool is_strided() noexcept { return true; }
 
     constexpr index_type stride(rank_type) const noexcept;
@@ -16149,11 +16149,11 @@
       constexpr index_type operator()(Indices...) const noexcept;
 
     static constexpr bool is_always_unique() noexcept { return true; }
-    static constexpr bool is_always_contiguous() noexcept { return true; }
+    static constexpr bool is_always_exhaustive() noexcept { return true; }
     static constexpr bool is_always_strided() noexcept { return true; }
 
     static constexpr bool is_unique() noexcept { return true; }
-    static constexpr bool is_contiguous() noexcept { return true; }
+    static constexpr bool is_exhaustive() noexcept { return true; }
     static constexpr bool is_strided() noexcept { return true; }
 
     constexpr index_type stride(rank_type) const noexcept;
@@ -16402,11 +16402,11 @@
       constexpr index_type operator()(Indices...) const noexcept;
 
     static constexpr bool is_always_unique() noexcept { return true; }
-    static constexpr bool is_always_contiguous() noexcept { return false; }
+    static constexpr bool is_always_exhaustive() noexcept { return false; }
     static constexpr bool is_always_strided() noexcept { return true; }
 
     static constexpr bool is_unique() noexcept { return true; }
-    constexpr bool is_contiguous() const noexcept;
+    constexpr bool is_exhaustive() const noexcept;
     static constexpr bool is_strided() noexcept { return true; }
 
     constexpr index_type stride(rank_type i) const noexcept { return @\exposid{strides_}@[i]; }
@@ -16474,17 +16474,17 @@
 concept @\defexposconcept{layout-mapping-alike}@ = requires {                         // \expos
   requires @\exposid{is-extents}@<typename M::extents_type>;
   { M::is_always_strided() } -> same_as<bool>;
-  { M::is_always_contiguous() } -> same_as<bool>;
+  { M::is_always_exhaustive() } -> same_as<bool>;
   { M::is_always_unique() } -> same_as<bool>;
   bool_constant<M::is_always_strided()>::value;
-  bool_constant<M::is_always_contiguous()>::value;
+  bool_constant<M::is_always_exhaustive()>::value;
   bool_constant<M::is_always_unique()>::value;
 };
 \end{codeblock}
 \begin{note}
 This concept checks that the functions
 \tcode{M::is_always_strided()},
-\tcode{M::is_always_contiguous()}, and
+\tcode{M::is_always_exhaustive()}, and
 \tcode{M::is_always_unique()} exist,
 are constant expressions, and
 have a return type of \tcode{bool}.
@@ -16642,9 +16642,9 @@
 \end{codeblock}
 \end{itemdescr}
 
-\indexlibrarymember{is_contiguous}{layout_stride::mapping}%
+\indexlibrarymember{is_exhaustive}{layout_stride::mapping}%
 \begin{itemdecl}
-constexpr bool is_contiguous() const noexcept;
+constexpr bool is_exhaustive() const noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -16720,9 +16720,9 @@
 \item
 \tcode{a} denotes a value of type \tcode{A} or \tcode{const A}.
 \item
-\tcode{p} denotes a value of type \tcode{A::pointer} or \tcode{const A::pointer}.
+\tcode{p} denotes a value of type \tcode{A::data_handle_type} or \tcode{const A::data_handle_type}.
 \begin{note}
-The type \tcode{A::pointer} need not be dereferenceable.
+The type \tcode{A::data_handle_type} need not be dereferenceable.
 \end{note}
 \item
 \tcode{n}, \tcode{i}, and \tcode{j} each denote values of type \tcode{size_t}.
@@ -16757,18 +16757,18 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-typename A::pointer
+typename A::data_handle_type
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \result
 A type that models \libconcept{copyable}, and
 for which \tcode{is_nothrow_move_constructible_v<A::poin\-ter>} is \tcode{true},
-\tcode{is_nothrow_move_assignable_v<A::pointer>} is \tcode{true}, and
-\tcode{is_nothrow_swappable_v<A::pointer>} is \tcode{true}.
+\tcode{is_nothrow_move_assignable_v<A::data_handle_type>} is \tcode{true}, and
+\tcode{is_nothrow_swappable_v<A::data_handle_type>} is \tcode{true}.
 \begin{note}
-The type of \tcode{pointer} need not be \tcode{element_type*}.
+The type of \tcode{data_handle_type} need not be \tcode{element_type*}.
 \end{note}
 \end{itemdescr}
 
@@ -16836,7 +16836,7 @@
 \begin{itemdescr}
 \pnum
 \result
-\tcode{A::offset_policy::pointer}
+\tcode{A::offset_policy::data_handle_type}
 
 \pnum
 \returns
@@ -16868,13 +16868,13 @@
     using offset_policy = default_accessor;
     using element_type = ElementType;
     using reference = ElementType&;
-    using pointer = ElementType*;
+    using data_handle_type = ElementType*;
 
     constexpr default_accessor() noexcept = default;
     template<class OtherElementType>
       constexpr default_accessor(default_accessor<OtherElementType>) noexcept;
-    constexpr reference access(pointer p, size_t i) const noexcept;
-    constexpr pointer offset(pointer p, size_t i) const noexcept;
+    constexpr reference access(data_handle_type p, size_t i) const noexcept;
+    constexpr data_handle_type offset(data_handle_type p, size_t i) const noexcept;
   };
 }
 \end{codeblock}
@@ -16892,7 +16892,7 @@
 
 \pnum
 $[0, n)$ is an accessible range for
-an object \tcode{p} of type \tcode{pointer} and
+an object \tcode{p} of type \tcode{data_handle_type} and
 an object of type \tcode{default_accessor}
 if and only if \range{p}{p + $n$} is a valid range.
 
@@ -16913,7 +16913,7 @@
 
 \indexlibrarymember{access}{default_accessor}%
 \begin{itemdecl}
-constexpr reference access(pointer p, size_t i) const noexcept;
+constexpr reference access(data_handle_type p, size_t i) const noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -16924,7 +16924,7 @@
 
 \indexlibrarymember{offset}{default_accessor}%
 \begin{itemdecl}
-constexpr pointer offset(pointer p, size_t i) const noexcept;
+constexpr data_handle_type offset(data_handle_type p, size_t i) const noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -16954,7 +16954,7 @@
     using index_type = typename extents_type::index_type;
     using size_type = typename extents_type::size_type;
     using rank_type = typename extents_type::rank_type;
-    using pointer = typename accessor_type::pointer;
+    using data_handle_type = typename accessor_type::data_handle_type;
     using reference = typename accessor_type::reference;
 
     static constexpr rank_type rank() noexcept { return extents_type::rank(); }
@@ -17001,21 +17001,21 @@
     friend constexpr void swap(mdspan& x, mdspan& y) noexcept;
 
     constexpr const extents_type& extents() const noexcept { return @\exposid{map_}@.extents(); }
-    constexpr const pointer& data() const noexcept { return @\exposid{ptr_}@; }
+    constexpr const data_handle_type& data_handle() const noexcept { return @\exposid{ptr_}@; }
     constexpr const mapping_type& mapping() const noexcept { return @\exposid{map_}@; }
     constexpr const accessor_type& accessor() const noexcept { return @\exposid{acc_}@; }
 
     static constexpr bool is_always_unique()
       { return mapping_type::is_always_unique(); }
-    static constexpr bool is_always_contiguous()
-      { return mapping_type::is_always_contiguous(); }
+    static constexpr bool is_always_exhaustive()
+      { return mapping_type::is_always_exhaustive(); }
     static constexpr bool is_always_strided()
       { return mapping_type::is_always_strided(); }
 
     constexpr bool is_unique() const
       { return @\exposid{map_}@.is_unique(); }
-    constexpr bool is_contiguous() const
-      { return @\exposid{map_}@.is_contiguous(); }
+    constexpr bool is_exhaustive() const
+      { return @\exposid{map_}@.is_exhaustive(); }
     constexpr bool is_strided() const
       { return @\exposid{map_.}@is_strided(); }
     constexpr index_type stride(rank_type r) const
@@ -17024,7 +17024,7 @@
   private:
     accessor_type @\exposid{acc_}@;         // \expos
     mapping_type @\exposid{map_}@;          // \expos
-    pointer @\exposid{ptr_}@;               // \expos
+    data_handle_type @\exposid{ptr_}@;      // \expos
   };
 
   template<class CArray>
@@ -17060,7 +17060,8 @@
                 typename MappingType::layout_type>;
 
   template<class MappingType, class AccessorType>
-    mdspan(const typename AccessorType::pointer&, const MappingType&, const AccessorType&)
+    mdspan(const typename AccessorType::data_handle_type&, const MappingType&,
+           const AccessorType&)
       -> mdspan<typename AccessorType::element_type, typename MappingType::extents_type,
                 typename MappingType::layout_type, AccessorType>;
 }
@@ -17098,7 +17099,7 @@
 
 \pnum
 A specialization of \tcode{mdspan} is a trivially copyable type if
-its \tcode{accessor_type}, \tcode{mapping_type}, and \tcode{pointer}
+its \tcode{accessor_type}, \tcode{mapping_type}, and \tcode{data_handle_type}
 are trivially copyable types.
 
 \rSec3[mdspan.mdspan.ctor]{Constructors}
@@ -17115,7 +17116,7 @@
 \item
 \tcode{rank_dynamic() > 0} is \tcode{true}.
 \item
-\tcode{is_default_constructible_v<pointer>} is \tcode{true}.
+\tcode{is_default_constructible_v<data_handle_type>} is \tcode{true}.
 \item
 \tcode{is_default_constructible_v<mapping_type>} is \tcode{true}.
 \item
@@ -17226,7 +17227,7 @@
 
 \indexlibraryctor{mdspan}%
 \begin{itemdecl}
-constexpr mdspan(pointer p, const extents_type& ext);
+constexpr mdspan(data_handle_type p, const extents_type& ext);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17260,7 +17261,7 @@
 
 \indexlibraryctor{mdspan}%
 \begin{itemdecl}
-constexpr mdspan(pointer p, const mapping_type& m);
+constexpr mdspan(data_handle_type p, const mapping_type& m);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17288,7 +17289,7 @@
 
 \indexlibraryctor{mdspan}%
 \begin{itemdecl}
-constexpr mdspan(pointer p, const mapping_type& m, const accessor_type& a);
+constexpr mdspan(data_handle_type p, const mapping_type& m, const accessor_type& a);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17333,7 +17334,7 @@
 \mandates
 \begin{itemize}
 \item
-\tcode{is_constructible_v<pointer, const OtherAccessor::pointer\&>} is \tcode{true}, and
+\tcode{is_constructible_v<data_handle_type, const OtherAccessor::data_handle_type\&>} is\newline \tcode{true}, and
 \item
 \tcode{is_constructible_v<extents_type, OtherExtents>} is \tcode{true}.
 \end{itemize}