|
template<bool value> |
using | bool_constant = std::integral_constant< bool, value > |
| A template alias for std::integral_constant<bool, value> More...
|
|
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. More...
|
|
template<template< typename... > class Op, typename... Args> |
using | is_detected = typename detected_or< nonesuch, Op, Args... >::value_t |
| Detects whether Op<Args...> is valid. More...
|
|
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. More...
|
|
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 . More...
|
|
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. More...
|
|
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. More...
|
|
template<typename... T> |
using | index_sequence_for = make_index_sequence< typename Dune::SizeOf< T... >{}> |
| Create index_sequence from 0 to sizeof...(T)-1. More...
|
|
template<typename ... T> |
using | variant = Impl::variant_< T... > |
| Incomplete re-implementation of C++17's std::variant. More...
|
|
|
template<class F , class ArgTuple > |
decltype(auto) | apply (F &&f, ArgTuple &&args) |
| Apply function with arguments given as tuple. More...
|
|
template<typename... Args> |
std::array< typename std::common_type< Args... >::type, sizeof...(Args)> | make_array (const Args &... args) |
| Create and initialize an array. More...
|
|
template<class T > |
static constexpr bool | operator== (const optional< T > &lhs, const optional< T > &rhs) |
|
template<class T > |
static constexpr bool | operator< (const optional< T > &lhs, const optional< T > &rhs) |
|
template<class T > |
static constexpr bool | operator== (const optional< T > &lhs, nullopt_t) noexcept |
|
template<class T > |
static constexpr bool | operator== (nullopt_t, const optional< T > &rhs) noexcept |
|
template<class T > |
static constexpr bool | operator< (const optional< T > &lhs, nullopt_t) noexcept |
|
template<class T > |
static constexpr bool | operator< (nullopt_t, const optional< T > &rhs) noexcept |
|
template<class T > |
static constexpr bool | operator== (const optional< T > &lhs, const T &rhs) |
|
template<class T > |
static constexpr bool | operator== (const T &lhs, const optional< T > &rhs) |
|
template<class T > |
static constexpr bool | operator< (const optional< T > &lhs, const T &rhs) |
|
template<class T > |
static constexpr bool | operator< (const T &lhs, const optional< T > &rhs) |
|
template<class T > |
static constexpr optional< typename std::decay< T >::type > | make_optional (T &&value) |
|
template<size_t N, typename... T> |
auto & | get (variant< T... > &var) |
|
template<size_t N, typename... T> |
const auto & | get (const variant< T... > &var) |
|
template<typename F , typename... T> |
decltype(auto) | visit (F &&visitor, variant< T... > &var) |
|
template<typename F , typename... T> |
decltype(auto) | visit (F &&visitor, const variant< T... > &var) |
|
template<typename Tp , typename ... T> |
const auto * | get_if (const variant< T... > *var) |
|
template<typename Tp , typename ... T> |
auto * | get_if (variant< T... > *var) |
|
template<typename Tp , typename ... T> |
constexpr bool | holds_alternative (const variant< T... > &var) |
|
constexpr bool | operator< (monostate, monostate) noexcept |
|
constexpr bool | operator> (monostate, monostate) noexcept |
|
constexpr bool | operator<= (monostate, monostate) noexcept |
|
constexpr bool | operator>= (monostate, monostate) noexcept |
|
constexpr bool | operator== (monostate, monostate) noexcept |
|
constexpr bool | operator!= (monostate, monostate) noexcept |
|
|
template<template< typename... > class Op, typename... Args> |
constexpr bool | is_detected_v = is_detected<Op,Args...>::value |
| Detects whether Op<Args...> is valid and makes the result available as a value. More...
|
|
template<typename Expected , template< typename... > class Op, typename... Args> |
constexpr bool | is_detected_exact_v = is_detected_exact<Expected,Op,Args...>::value |
| Convenient access to the result value of is_detected_exact. More...
|
|
template<typename Target , template< typename... > class Op, typename... Args> |
constexpr bool | is_detected_convertible_v = is_detected_convertible<Target,Op,Args...>::value |
| Convenient access to the result value of is_detected_convertible. More...
|
|
template<typename T > |
constexpr std::size_t | variant_size_v = variant_size<T>::value |
|
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.
Create index_sequence from 0 to sizeof...(T)-1.
This should do the same as std::index_sequence_for. But due to a bug in the sizeof... operator this may produce wrong results with clang<3.8.
As a workaround we provide our own implementation that avoids this bug even if the std:: version exists.
This implemenation can be dropped, once we require a minimum clang version that has this bug fixed (i.e. >=3.8).