|
template<class IndexType , std::size_t R> |
using | dextents = typename Impl::DExtentsImpl< IndexType, std::make_integer_sequence< std::size_t, R > >::type |
| Alias of extents of given rank R and purely dynamic extents. See [mdspan.extents.dextents].
|
|
template<typename Default , template< typename... > class Op, typename... Args> |
using | detected_or = Impl::detector< Default, void, Op, Args... > |
| Detects whether Op<Args...> is valid and makes the result available.
|
|
template<template< typename... > class Op, typename... Args> |
using | is_detected = typename detected_or< nonesuch, Op, Args... >::value_t |
| Detects whether Op<Args...> is valid.
|
|
template<template< typename... > class Op, typename... Args> |
using | detected_t = typename detected_or< nonesuch, Op, Args... >::type |
| Returns Op<Args...> if that is valid; otherwise returns nonesuch.
|
|
template<typename Default , template< typename... > class Op, typename... Args> |
using | detected_or_t = typename detected_or< Default, Op, Args... >::type |
| Returns Op<Args...> if that is valid; otherwise returns the fallback type Default .
|
|
template<typename Expected , template< typename... > class Op, typename... Args> |
using | is_detected_exact = std::is_same< Expected, detected_t< Op, Args... > > |
| Checks whether Op<Args...> is Expected without causing an error if Op<Args...> is invalid.
|
|
template<typename Target , template< typename... > class Op, typename... Args> |
using | is_detected_convertible = std::is_convertible< Target, detected_t< Op, Args... > > |
| Checks whether Op<Args...> is convertible to Target without causing an error if Op<Args...> is invalid.
|
|
|
template<class CArray , std::enable_if_t< std::is_array_v< CArray >, int > = 0, std::enable_if_t<(std::rank_v< CArray >==1), int > = 0> |
| mdspan (CArray &) -> mdspan< std::remove_all_extents_t< CArray >, Std::extents< std::size_t, std::extent_v< CArray, 0 > > > |
|
template<class Pointer , std::enable_if_t< std::is_pointer_v< std::remove_reference_t< Pointer > >, int > = 0> |
| mdspan (Pointer &&) -> mdspan< std::remove_pointer_t< std::remove_reference_t< Pointer > >, Std::extents< std::size_t > > |
|
template<class ElementType , class... II, std::enable_if_t<(... &&std::is_convertible_v< II, std::size_t >), int > = 0, std::enable_if_t<(sizeof...(II) > 0), int > = 0> |
| mdspan (ElementType *, II...) -> mdspan< ElementType, Std::dextents< std::size_t, sizeof...(II)> > |
|
template<class ElementType , class SizeType , std::size_t N> |
| mdspan (ElementType *, Std::span< SizeType, N > &) -> mdspan< ElementType, Std::dextents< std::size_t, N > > |
|
template<class ElementType , class SizeType , std::size_t N> |
| mdspan (ElementType *, const std::array< SizeType, N > &) -> mdspan< ElementType, Std::dextents< std::size_t, N > > |
|
template<class ElementType , class IndexType , std::size_t... exts> |
| mdspan (ElementType *, const Std::extents< IndexType, exts... > &) -> mdspan< ElementType, Std::extents< IndexType, exts... > > |
|
template<class ElementType , class Mapping , class Extents = typename Mapping::extents_type, class Layout = typename Mapping::layout_type> |
| mdspan (ElementType *, const Mapping &) -> mdspan< ElementType, Extents, Layout > |
|
template<class Mapping , class Accessor , class DataHandle = typename Accessor::data_handle_type, class Element = typename Accessor::element_type, class Extents = typename Mapping::extents_type, class Layout = typename Mapping::layout_type> |
| mdspan (const DataHandle &, const Mapping &, const Accessor &) -> mdspan< Element, Extents, Layout, Accessor > |
|
template<class T > |
constexpr auto | to_address (T &&p) noexcept |
| Obtain the address represented by p without forming a reference to the object pointed to by p .
|
|
template<class T , std::size_t N> |
| span (T(&)[N]) -> span< T, N > |
|
template<class ElementType , class I , std::size_t Extent, std::enable_if_t< std::is_convertible_v< I, std::size_t >, int > = 0> |
| span (ElementType *, std::integral_constant< I, Extent >) -> span< ElementType, Extent > |
|
template<class ElementType , class I , std::enable_if_t< std::is_integral_v< I >, int > = 0, std::enable_if_t< std::is_convertible_v< I, std::size_t >, int > = 0> |
| span (ElementType *, I) -> span< ElementType, Std::dynamic_extent > |
|
template<class Iter , class Element = std::remove_reference_t<decltype(*std::declval<Iter>())>> |
| span (Iter, Iter) -> span< Element, Std::dynamic_extent > |
|
template<class Range , class First = decltype(std::begin(std::declval<Range>())), class Last = decltype(std::end(std::declval<Range>())), class Element = std::remove_reference_t<decltype(*std::declval<First>())>> |
| span (Range &) -> span< Element, Std::dynamic_extent > |
|
template<class T , size_t N> |
| span (std::array< T, N > &) -> span< T, N > |
|
template<class T , size_t N> |
| span (const std::array< T, N > &) -> span< const T, N > |
|
Namespace for features backported from new C++ standards.
The namespace Dune::Std contains library features of new C++ standards and technical specifications backported to older compilers. Most features are detected and pulled into this namespace from the standard library if your compiler has native support. If it doesn't, we provide a fallback implementation on a best-effort basis.