Reference documentation for deal.II version Git 4abc4a1666 2020-07-04 19:58:34 +0200
\(\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 
121 template <bool, typename>
123 
124 
198 template <typename T>
200 {
201  using type = T;
202 };
203 
204 
205 
263 template <typename T>
264 struct identity
265 {
266  using type = T;
267 };
268 
269 
270 
288 {
293  template <typename T>
294  static bool
295  equal(const T *p1, const T *p2)
296  {
297  return (p1 == p2);
298  }
299 
300 
307  template <typename T, typename U>
308  static bool
309  equal(const T *, const U *)
310  {
311  return false;
312  }
313 };
314 
315 
316 
337 template <typename T, typename U>
338 struct DEAL_II_DEPRECATED types_are_equal : std::is_same<T, U>
339 {};
340 
341 
342 
343 namespace internal
344 {
355  template <typename T, typename U>
357  {
358  using type = decltype(std::declval<T>() * std::declval<U>());
359  };
360 
361 } // namespace internal
362 
363 
364 
411 template <typename T, typename U>
413 {
414  using type =
416  typename std::decay<U>::type>::type;
417 };
418 
419 namespace internal
420 {
421  // Annoyingly, there is no std::complex<T>::operator*(U) for scalars U
422  // other than T (not even in C++11, or C++14). We provide our own overloads
423  // in base/complex_overloads.h, but in order for them to work, we have to
424  // manually specify all products we want to allow:
425 
426  template <typename T>
427  struct ProductTypeImpl<std::complex<T>, std::complex<T>>
428  {
429  using type = std::complex<T>;
430  };
431 
432  template <typename T, typename U>
433  struct ProductTypeImpl<std::complex<T>, std::complex<U>>
434  {
435  using type = std::complex<typename ProductType<T, U>::type>;
436  };
437 
438  template <typename U>
439  struct ProductTypeImpl<double, std::complex<U>>
440  {
441  using type = std::complex<typename ProductType<double, U>::type>;
442  };
443 
444  template <typename T>
445  struct ProductTypeImpl<std::complex<T>, double>
446  {
447  using type = std::complex<typename ProductType<T, double>::type>;
448  };
449 
450  template <typename U>
451  struct ProductTypeImpl<float, std::complex<U>>
452  {
453  using type = std::complex<typename ProductType<float, U>::type>;
454  };
455 
456  template <typename T>
457  struct ProductTypeImpl<std::complex<T>, float>
458  {
459  using type = std::complex<typename ProductType<T, float>::type>;
460  };
461 
462 } // namespace internal
463 
464 
465 
521 template <typename T>
523 
524 
525 template <>
527 {
528  using type = double;
529 };
530 
531 template <>
532 struct EnableIfScalar<float>
533 {
534  using type = float;
535 };
536 
537 template <>
538 struct EnableIfScalar<long double>
539 {
540  using type = long double;
541 };
542 
543 template <>
545 {
546  using type = int;
547 };
548 
549 template <>
550 struct EnableIfScalar<unsigned int>
551 {
552  using type = unsigned int;
553 };
554 
555 template <typename T>
556 struct EnableIfScalar<std::complex<T>>
557 {
558  using type = std::complex<T>;
559 };
560 
561 
563 
564 #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:363
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:362
VectorType::value_type * begin(VectorType &V)
decltype(std::declval< T >() *std::declval< U >()) type
std::complex< typename ProductType< double, U >::type > type
#define DEAL_II_DEPRECATED
Definition: config.h:152
static bool equal(const T *p1, const T *p2)