dune-common 2.10
Loading...
Searching...
No Matches
Classes | Typedefs | Functions | Variables
Dune::Std Namespace Reference

Namespace for features backported from new C++ standards. More...

Classes

class  default_accessor
 A type for indexed access to elements of mdspan. More...
 
class  extents
 Multidimensional index space with dynamic and static extents. More...
 
struct  identity
 A function object type whose operator() returns its argument unchanged. More...
 
struct  layout_left
 A layout where the leftmost extent has stride 1. More...
 
struct  layout_right
 A layout where the rightmost extent has stride 1, and strides increase right-to-left as the product of extents. More...
 
struct  layout_stride
 A layout mapping where the strides are user-defined. More...
 
class  mdarray
 An owning multi-dimensional array analog of mdspan. More...
 
class  mdspan
 A multi-dimensional non-owning array view. More...
 
struct  nonesuch
 Type representing a lookup failure by std::detected_or and friends. More...
 
class  span
 A contiguous sequence of elements with static or dynamic extent. More...
 

Typedefs

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.
 

Functions

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 >
 

Variables

constexpr std::size_t dynamic_extent = std::numeric_limits<std::size_t>::max()
 A constant of type std::size_t that is used to differentiate std::span of static and dynamic extent.
 

Detailed Description

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.

Function Documentation

◆ mdspan() [1/8]

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>
Dune::Std::mdspan ( CArray &  ) -> mdspan< std::remove_all_extents_t< CArray >, Std::extents< std::size_t, std::extent_v< CArray, 0 > > >

◆ mdspan() [2/8]

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>
Dune::Std::mdspan ( const DataHandle &  ,
const Mapping &  ,
const Accessor &   
) -> mdspan< Element, Extents, Layout, Accessor >

◆ mdspan() [3/8]

template<class ElementType , class Mapping , class Extents = typename Mapping::extents_type, class Layout = typename Mapping::layout_type>
Dune::Std::mdspan ( ElementType *  ,
const Mapping &   
) -> mdspan< ElementType, Extents, Layout >

◆ mdspan() [4/8]

template<class ElementType , class SizeType , std::size_t N>
Dune::Std::mdspan ( ElementType *  ,
const std::array< SizeType, N > &   
) -> mdspan< ElementType, Std::dextents< std::size_t, N > >

◆ mdspan() [5/8]

template<class ElementType , class IndexType , std::size_t... exts>
Dune::Std::mdspan ( ElementType *  ,
const Std::extents< IndexType, exts... > &   
) -> mdspan< ElementType, Std::extents< IndexType, exts... > >

◆ mdspan() [6/8]

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>
Dune::Std::mdspan ( ElementType *  ,
II...   
) -> mdspan< ElementType, Std::dextents< std::size_t, sizeof...(II)> >

◆ mdspan() [7/8]

template<class ElementType , class SizeType , std::size_t N>
Dune::Std::mdspan ( ElementType *  ,
Std::span< SizeType, N > &   
) -> mdspan< ElementType, Std::dextents< std::size_t, N > >

◆ mdspan() [8/8]

template<class Pointer , std::enable_if_t< std::is_pointer_v< std::remove_reference_t< Pointer > >, int > = 0>
Dune::Std::mdspan ( Pointer &&  ) -> mdspan< std::remove_pointer_t< std::remove_reference_t< Pointer > >, Std::extents< std::size_t > >

◆ span() [1/7]

template<class T , size_t N>
Dune::Std::span ( const std::array< T, N > &  ) -> span< const T, N >

◆ span() [2/7]

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>
Dune::Std::span ( ElementType *  ,
 
) -> span< ElementType, Std::dynamic_extent >

◆ span() [3/7]

template<class ElementType , class I , std::size_t Extent, std::enable_if_t< std::is_convertible_v< I, std::size_t >, int > = 0>
Dune::Std::span ( ElementType *  ,
std::integral_constant< I, Extent >   
) -> span< ElementType, Extent >

◆ span() [4/7]

template<class Iter , class Element = std::remove_reference_t<decltype(*std::declval<Iter>())>>
Dune::Std::span ( Iter  ,
Iter   
) -> span< Element, Std::dynamic_extent >

◆ span() [5/7]

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>())>>
Dune::Std::span ( Range &  ) -> span< Element, Std::dynamic_extent >

◆ span() [6/7]

template<class T , size_t N>
Dune::Std::span ( std::array< T, N > &  ) -> span< T, N >

◆ span() [7/7]

template<class T , std::size_t N>
Dune::Std::span ( T(&)  [N]) -> span< T, N >

◆ to_address()

template<class T >
constexpr auto Dune::Std::to_address ( T &&  p)
constexprnoexcept

Obtain the address represented by p without forming a reference to the object pointed to by p.

Variable Documentation

◆ dynamic_extent

constexpr std::size_t Dune::Std::dynamic_extent = std::numeric_limits<std::size_t>::max()
inlineconstexpr

A constant of type std::size_t that is used to differentiate std::span of static and dynamic extent.