Reference documentation for deal.II version Git 953c9590e9 2020-10-28 17:25:14 -0400
\(\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\}}\)
template_constraints.h
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2003 - 2020 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE.md at
12 // the top level directory of deal.II.
13 //
14 // ---------------------------------------------------------------------
15 
16 #ifndef dealii_template_constraints_h
17 #define dealii_template_constraints_h
18 
19 
20 #include <deal.II/base/config.h>
21 
23 
24 #include <complex>
25 #include <iterator>
26 #include <utility>
27 
29 
30 namespace internal
31 {
32  namespace TemplateConstraints
33  {
34  // helper struct for is_base_of_all and all_same_as
35  template <bool... Values>
36  struct BoolStorage;
37 
38 
43  template <bool... Values>
44  struct all_true
45  {
46  static constexpr bool value =
47  std::is_same<BoolStorage<Values..., true>,
48  BoolStorage<true, Values...>>::value;
49  };
50  } // namespace TemplateConstraints
51 } // namespace internal
52 
59 template <class Base, class... Derived>
61 {
63  std::is_base_of<Base, Derived>::value...>::value;
64 };
65 
66 
67 
74 template <class Type, class... Types>
76 {
78  std::is_same<Type, Types>::value...>::value;
79 };
80 
81 
82 
83 /*
84  * A generalization of `std::enable_if` that only works if
85  * <i>all</i> of the given boolean template parameters are
86  * true.
87  */
88 template <bool... Values>
90  : std::enable_if<internal::TemplateConstraints::all_true<Values...>::value>
91 {};
92 
93 
94 
100 template <typename T>
102 {
103  template <typename C>
104  static std::false_type
105  test(...);
106 
107  template <typename C>
108  static auto
109  test(int) -> decltype(std::begin(std::declval<C>()),
110  std::end(std::declval<C>()),
111  std::true_type());
112 
113 public:
114  using type = decltype(test<T>(0));
115 
116  static const bool value = type::value;
117 };
118 
119 
120 
178 template <typename T>
179 struct identity
180 {
181  using type = T;
182 };
183 
184 
185 
203 {
208  template <typename T>
209  static bool
210  equal(const T *p1, const T *p2)
211  {
212  return (p1 == p2);
213  }
214 
215 
222  template <typename T, typename U>
223  static bool
224  equal(const T *, const U *)
225  {
226  return false;
227  }
228 };
229 
230 
231 
232 namespace internal
233 {
244  template <typename T, typename U>
246  {
247  using type = decltype(std::declval<T>() * std::declval<U>());
248  };
249 
250 } // namespace internal
251 
252 
253 
300 template <typename T, typename U>
302 {
303  using type =
305  typename std::decay<U>::type>::type;
306 };
307 
308 namespace internal
309 {
310  // Annoyingly, there is no std::complex<T>::operator*(U) for scalars U
311  // other than T (not even in C++11, or C++14). We provide our own overloads
312  // in base/complex_overloads.h, but in order for them to work, we have to
313  // manually specify all products we want to allow:
314 
315  template <typename T>
316  struct ProductTypeImpl<std::complex<T>, std::complex<T>>
317  {
318  using type = std::complex<T>;
319  };
320 
321  template <typename T, typename U>
322  struct ProductTypeImpl<std::complex<T>, std::complex<U>>
323  {
324  using type = std::complex<typename ProductType<T, U>::type>;
325  };
326 
327  template <typename U>
328  struct ProductTypeImpl<double, std::complex<U>>
329  {
330  using type = std::complex<typename ProductType<double, U>::type>;
331  };
332 
333  template <typename T>
334  struct ProductTypeImpl<std::complex<T>, double>
335  {
336  using type = std::complex<typename ProductType<T, double>::type>;
337  };
338 
339  template <typename U>
340  struct ProductTypeImpl<float, std::complex<U>>
341  {
342  using type = std::complex<typename ProductType<float, U>::type>;
343  };
344 
345  template <typename T>
346  struct ProductTypeImpl<std::complex<T>, float>
347  {
348  using type = std::complex<typename ProductType<T, float>::type>;
349  };
350 
351 } // namespace internal
352 
353 
354 
410 template <typename T>
412 
413 
414 template <>
416 {
417  using type = double;
418 };
419 
420 template <>
421 struct EnableIfScalar<float>
422 {
423  using type = float;
424 };
425 
426 template <>
427 struct EnableIfScalar<long double>
428 {
429  using type = long double;
430 };
431 
432 template <>
434 {
435  using type = int;
436 };
437 
438 template <>
439 struct EnableIfScalar<unsigned int>
440 {
441  using type = unsigned int;
442 };
443 
444 template <typename T>
445 struct EnableIfScalar<std::complex<T>>
446 {
447  using type = std::complex<T>;
448 };
449 
450 
452 
453 #endif
typename internal::ProductTypeImpl< typename std::decay< T >::type, typename std::decay< U >::type >::type type
std::complex< typename ProductType< float, U >::type > type
std::complex< typename ProductType< T, double >::type > type
STL namespace.
static const char U
decltype(test< T >(0)) type
static const char T
static bool equal(const T *, const U *)
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:369
VectorType::value_type * end(VectorType &V)
std::complex< typename ProductType< T, float >::type > type
std::complex< typename ProductType< T, U >::type > type
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:368
VectorType::value_type * begin(VectorType &V)
decltype(std::declval< T >() *std::declval< U >()) type
std::complex< typename ProductType< double, U >::type > type
static bool equal(const T *p1, const T *p2)