Reference documentation for deal.II version 9.5.0
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Loading...
Searching...
No Matches
Classes | Namespaces | Typedefs | Variables
template_constraints.h File Reference
#include <deal.II/base/config.h>
#include <deal.II/base/complex_overloads.h>
#include <deal.II/base/std_cxx20/type_traits.h>
#include <complex>
#include <type_traits>
#include <utility>

Go to the source code of this file.

Classes

struct  internal::SupportsOperation::detector< Default, AlwaysVoid, Op, Args >
 
struct  internal::SupportsOperation::detector< Default, void_t< Op< Args... > >, Op, Args... >
 
struct  internal::SupportsOperation::nonesuch_base
 
struct  internal::SupportsOperation::nonesuch
 
struct  internal::TemplateConstraints::all_true< Values >
 
struct  internal::TemplateConstraints::any_true< V1, Values... >
 
struct  internal::TemplateConstraints::any_true<>
 
struct  is_base_of_all< Base, Derived >
 
struct  all_same_as< Type, Types >
 
struct  is_same_as_any_of< Type, Types >
 
struct  enable_if_all< Values >
 
struct  always_return< ArgType, ValueType >
 
struct  PointerComparison
 
struct  internal::ProductTypeImpl< T, U >
 
struct  ProductType< T, U >
 
struct  internal::ProductTypeImpl< std::complex< T >, std::complex< T > >
 
struct  internal::ProductTypeImpl< std::complex< T >, std::complex< U > >
 
struct  internal::ProductTypeImpl< double, std::complex< U > >
 
struct  internal::ProductTypeImpl< std::complex< T >, double >
 
struct  internal::ProductTypeImpl< float, std::complex< U > >
 
struct  internal::ProductTypeImpl< std::complex< T >, float >
 
struct  EnableIfScalar< double >
 
struct  EnableIfScalar< float >
 
struct  EnableIfScalar< long double >
 
struct  EnableIfScalar< int >
 
struct  EnableIfScalar< unsigned int >
 
struct  EnableIfScalar< std::complex< T > >
 

Namespaces

namespace  internal
 
namespace  internal::SupportsOperation
 
namespace  internal::TemplateConstraints
 
namespace  LinearAlgebra
 
namespace  LinearAlgebra::distributed
 
namespace  PETScWrappers
 
namespace  PETScWrappers::MPI
 
namespace  TrilinosWrappers
 
namespace  TrilinosWrappers::MPI
 
namespace  LinearAlgebra::EpetraWrappers
 
namespace  LinearAlgebra::TpetraWrappers
 
namespace  concepts
 
namespace  concepts::internal
 
namespace  parallel
 
namespace  parallel::distributed
 
namespace  parallel::shared
 
namespace  parallel::fullydistributed
 

Typedefs

template<class... >
using internal::SupportsOperation::void_t = void
 
template<class Default , template< class... > class Op, class... Args>
using internal::SupportsOperation::detected_or = detector< Default, void, Op, Args... >
 
template<template< class... > class Op, class... Args>
using internal::SupportsOperation::is_detected = typename detected_or< nonesuch, Op, Args... >::value_t
 
template<template< class... > class Op, class... Args>
using internal::SupportsOperation::detected_t = typename detected_or< nonesuch, Op, Args... >::type
 
template<class Default , template< class... > class Op, class... Args>
using internal::SupportsOperation::detected_or_t = typename detected_or< Default, Op, Args... >::type
 
template<class Expected , template< class... > class Op, class... Args>
using internal::SupportsOperation::is_detected_exact = std::is_same< Expected, detected_t< Op, Args... > >
 
template<class To , template< class... > class Op, class... Args>
using internal::SupportsOperation::is_detected_convertible = std::is_convertible< detected_t< Op, Args... >, To >
 
template<bool... Values>
using enable_if_all_t = typename enable_if_all< Values... >::type
 
template<typename T >
using begin_and_end_t = decltype(std::begin(std::declval< T >()), std::end(std::declval< T >()))
 
template<typename T >
using identity = std_cxx20::type_identity< T >
 

Variables

template<template< class... > class Op, class... Args>
constexpr bool internal::is_supported_operation
 
template<typename T >
constexpr bool has_begin_and_end
 
template<typename T >
constexpr bool concepts::internal::is_dealii_vector_type = false
 
template<typename T >
constexpr bool concepts::internal::is_dealii_petsc_vector_type = false
 
template<typename T >
constexpr bool concepts::internal::is_dealii_petsc_matrix_type = false
 
template<typename T >
constexpr bool concepts::internal::is_triangulation_or_dof_handler = false
 
template<int dim, int spacedim>
constexpr bool concepts::internal::is_triangulation_or_dof_handler< Triangulation< dim, spacedim > > = true
 
template<int dim, int spacedim>
constexpr bool concepts::internal::is_triangulation_or_dof_handler< DoFHandler< dim, spacedim > > = true
 

Typedef Documentation

◆ enable_if_all_t

template<bool... Values>
using enable_if_all_t = typename enable_if_all<Values...>::type

Definition at line 320 of file template_constraints.h.

◆ begin_and_end_t

template<typename T >
using begin_and_end_t = decltype(std::begin(std::declval<T>()), std::end(std::declval<T>()))

A type trait that checks to see if a class behaves as an iterable container that has a beginning and an end. This implies that the class either defines the begin() and end() functions, or is a C-style array.

Definition at line 329 of file template_constraints.h.

◆ identity

template<typename T >
using identity = std_cxx20::type_identity<T>

A using declaration to make the std::identity_type class available under the name that deal.II has used for a long time.

Deprecated:
Use std_cxx20::identity_type instead.

Definition at line 345 of file template_constraints.h.

Variable Documentation

◆ has_begin_and_end

template<typename T >
constexpr bool has_begin_and_end
constexpr
Initial value:
=
internal::is_supported_operation<begin_and_end_t, T>

Definition at line 333 of file template_constraints.h.