std::layout_stride::mapping(3)

NAME
std::layout_stride::mapping - std::layout_stride::mapping

Synopsis
   Defined in header <mdspan>
   template< class Extents > (since C++23)
   class layout_stride::mapping;
   The class template layout_stride::mapping controls how multidimensional indices are
   mapped with user-defined strides to a one-dimensional value representing the offset.
   Every specialization of mapping is a LayoutMapping and a TriviallyCopyable type
   which satisfies regular.
   The program is ill-formed if the size of the multidimensional index space Extents()
   is not representable as a value of type Extents::index_type when
   Extents::rank_dynamic() is 0.

Template parameters
   Extents - specifies number of dimensions, their sizes, and which are known at
             compile time. Must be a specialization of std::extents.

Member types
   Member type Definition
   extents_type Extents
   index_type extents_type::index_type
   size_type extents_type::size_type
   rank_type extents_type::rank_type
   layout_type std::layout_stride

Member constants
   Member Definition
   constexpr rank_type rank_ (private) extents_type::rank()
   [static] (exposition-only static member constant*)

Member objects
   Member name Definition
   extents_ (private) The extents of type extents_type.
                      (exposition-only member object*)
   strides_ (private) The strides of type std::array<index_type, rank_>.
                      (exposition-only member object*)

Member functions
   constructor constructs a new mapping
                        (public member function)
   operator= assigns a mapping
                        (public member function)

Observers
   extents obtains the extents object
                        (public member function)
   strides obtains the array of strides
                        (public member function)
   required_span_size returns the required size of the mapping
                        (public member function)
   operator() maps multidimensional indices into an offset value
                        (public member function)
   is_unique determines if this mapping is unique (every combination of
   [static] indexes maps to a different underlying element)
                        (public static member function)
                        determines if this mapping is exhaustive (every underlying
   is_exhaustive element can be accessed with some combination of indexes)
                        (public member function)
   is_strided determines if this mapping is unique (every combination of
   [static] indexes maps to a different underlying element)
                        (public static member function)
   is_always_unique determines if this layout mapping is always unique
   [static] (public static member function)
   is_always_exhaustive determines if this layout mapping is always exhaustive
   [static] (public static member function)
   is_always_strided determines if this layout mapping is always strided
   [static] (public static member function)
   stride obtains the stride along the specified dimension
                        (public member function)

Non-member functions
                        compares this layout mapping with
   operator== other mapping
                        (function template)
   submdspan_mapping(std::layout_stride::mapping) calculates the mapping and data
   (C++26) handle offset used for subdmspan
                        (public member function)

See also
   mapping a layout mapping of layout_left
           (public member class template of std::layout_left)
   mapping a layout mapping of layout_right
           (public member class template of std::layout_right)