]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Prefer std::is_*_v over std::is_*::value. 15766/head
authorWolfgang Bangerth <bangerth@colostate.edu>
Wed, 19 Jul 2023 17:34:26 +0000 (11:34 -0600)
committerWolfgang Bangerth <bangerth@colostate.edu>
Fri, 21 Jul 2023 01:33:53 +0000 (19:33 -0600)
34 files changed:
include/deal.II/base/aligned_vector.h
include/deal.II/base/array_view.h
include/deal.II/base/linear_index_iterator.h
include/deal.II/base/memory_consumption.h
include/deal.II/base/mpi.h
include/deal.II/base/mpi.templates.h
include/deal.II/base/numbers.h
include/deal.II/base/parameter_handler.h
include/deal.II/base/partitioner.templates.h
include/deal.II/base/patterns.h
include/deal.II/base/table_indices.h
include/deal.II/base/thread_local_storage.h
include/deal.II/base/utilities.h
include/deal.II/cgal/triangulation.h
include/deal.II/differentiation/sd/symengine_number_types.h
include/deal.II/differentiation/sd/symengine_optimizer.h
include/deal.II/differentiation/sd/symengine_product_types.h
include/deal.II/differentiation/sd/symengine_scalar_operations.h
include/deal.II/grid/tria_iterator.h
include/deal.II/grid/tria_iterator.templates.h
include/deal.II/lac/linear_operator.h
include/deal.II/lac/sparse_matrix.templates.h
include/deal.II/lac/vector_operations_internal.h
include/deal.II/matrix_free/fe_evaluation.h
include/deal.II/numerics/adaptation_strategies.h
include/deal.II/numerics/history.h
include/deal.II/optimization/rol/vector_adaptor.h
include/deal.II/particles/particle_handler.h
source/base/utilities.cc
source/base/vectorization.cc
source/dofs/dof_accessor_set.cc
tests/base/array_view_08.cc
tests/base/array_view_09.cc
tests/tensors/symmetric_tensor_36.cc

index 04067ff708467541044f496d3216ba068eaa7838..76f11f8960d7567dbab02fb2d77e101484fbbbcd 100644 (file)
@@ -762,7 +762,7 @@ namespace internal
       // (void*) to silence compiler warning for virtual classes (they will
       // never arrive here because they are non-trivial).
 
-      if (std::is_trivial<T>::value == true)
+      if (std::is_trivial_v<T> == true)
         std::memcpy(static_cast<void *>(destination_ + begin),
                     static_cast<const void *>(source_ + begin),
                     (end - begin) * sizeof(T));
@@ -830,7 +830,7 @@ namespace internal
       // Classes with trivial assignment can use memcpy. cast element to
       // (void*) to silence compiler warning for virtual classes (they will
       // never arrive here because they are non-trivial).
-      if (std::is_trivial<T>::value == true)
+      if (std::is_trivial_v<T> == true)
         std::memcpy(static_cast<void *>(destination_ + begin),
                     static_cast<void *>(source_ + begin),
                     (end - begin) * sizeof(T));
@@ -889,7 +889,7 @@ namespace internal
       // do not use memcmp for long double because on some systems it does not
       // completely fill its memory and may lead to false positives in
       // e.g. valgrind
-      if (std::is_trivial<T>::value == true &&
+      if (std::is_trivial_v<T> == true &&
           std::is_same_v<T, long double> == false)
         {
           const unsigned char zero[sizeof(T)] = {};
@@ -918,7 +918,7 @@ namespace internal
       // element to (void*) to silence compiler warning for virtual
       // classes (they will never arrive here because they are
       // non-trivial).
-      if (std::is_trivial<T>::value == true && trivial_element)
+      if (std::is_trivial_v<T> == true && trivial_element)
         std::memset(static_cast<void *>(destination_ + begin),
                     0,
                     (end - begin) * sizeof(T));
@@ -1003,7 +1003,7 @@ namespace internal
       // element to (void*) to silence compiler warning for virtual
       // classes (they will never arrive here because they are
       // non-trivial).
-      if (std::is_trivial<T>::value == true)
+      if (std::is_trivial_v<T> == true)
         std::memset(static_cast<void *>(destination_ + begin),
                     0,
                     (end - begin) * sizeof(T));
@@ -1081,7 +1081,7 @@ AlignedVector<T>::Deleter::operator()(T *ptr)
           Assert(owning_aligned_vector->used_elements_end != nullptr,
                  ExcInternalError());
 
-          if (std::is_trivial<T>::value == false)
+          if (std::is_trivial_v<T> == false)
             for (T *p = owning_aligned_vector->used_elements_end - 1; p >= ptr;
                  --p)
               p->~T();
@@ -1138,7 +1138,7 @@ AlignedVector<T>::Deleter::MPISharedMemDeleterAction::delete_array(
   // it, not unique_ptr) so it is still set to its correct value.
 
   if (is_shmem_root)
-    if (std::is_trivial<T>::value == false)
+    if (std::is_trivial_v<T> == false)
       for (T *p = aligned_vector->used_elements_end - 1; p >= ptr; --p)
         p->~T();
 
@@ -1266,7 +1266,7 @@ AlignedVector<T>::resize_fast(const size_type new_size)
       // call destructor on fields that are released, if the type requires it.
       // doing it backward releases the elements in reverse order as compared to
       // how they were created
-      if (std::is_trivial<T>::value == false)
+      if (std::is_trivial_v<T> == false)
         for (T *p = used_elements_end - 1; p >= elements.get() + new_size; --p)
           p->~T();
       used_elements_end = elements.get() + new_size;
@@ -1279,7 +1279,7 @@ AlignedVector<T>::resize_fast(const size_type new_size)
 
       // need to still set the values in case the class is non-trivial because
       // virtual classes etc. need to run their (default) constructor
-      if (std::is_trivial<T>::value == false)
+      if (std::is_trivial_v<T> == false)
         dealii::internal::AlignedVectorDefaultInitialize<T, true>(
           new_size - old_size, elements.get() + old_size);
     }
@@ -1302,7 +1302,7 @@ AlignedVector<T>::resize(const size_type new_size)
       // call destructor on fields that are released, if the type requires it.
       // doing it backward releases the elements in reverse order as compared to
       // how they were created
-      if (std::is_trivial<T>::value == false)
+      if (std::is_trivial_v<T> == false)
         for (T *p = used_elements_end - 1; p >= elements.get() + new_size; --p)
           p->~T();
       used_elements_end = elements.get() + new_size;
@@ -1336,7 +1336,7 @@ AlignedVector<T>::resize(const size_type new_size, const T &init)
       // call destructor on fields that are released, if the type requires it.
       // doing it backward releases the elements in reverse order as compared to
       // how they were created
-      if (std::is_trivial<T>::value == false)
+      if (std::is_trivial_v<T> == false)
         for (T *p = used_elements_end - 1; p >= elements.get() + new_size; --p)
           p->~T();
       used_elements_end = elements.get() + new_size;
@@ -1433,7 +1433,7 @@ AlignedVector<T>::push_back(const T in_data)
   Assert(used_elements_end <= allocated_elements_end, ExcInternalError());
   if (used_elements_end == allocated_elements_end)
     reserve(std::max(2 * capacity(), static_cast<size_type>(16)));
-  if (std::is_trivial<T>::value == false)
+  if (std::is_trivial_v<T> == false)
     new (used_elements_end++) T(in_data);
   else
     *used_elements_end++ = in_data;
@@ -1472,7 +1472,7 @@ AlignedVector<T>::insert_back(ForwardIterator begin, ForwardIterator end)
   reserve(old_size + (end - begin));
   for (; begin != end; ++begin, ++used_elements_end)
     {
-      if (std::is_trivial<T>::value == false)
+      if (std::is_trivial_v<T> == false)
         new (used_elements_end) T;
       *used_elements_end = *begin;
     }
@@ -1633,7 +1633,7 @@ AlignedVector<T>::replicate_across_communicator(const MPI_Comm     communicator,
   // has all of the data.
   if (is_shmem_root)
     {
-      if (std::is_trivial<T>::value)
+      if (std::is_trivial_v<T>)
         {
           // The data is "trivial", i.e., we can copy things directly without
           // having to go through the serialization/deserialization machinery of
@@ -1826,7 +1826,7 @@ AlignedVector<T>::replicate_across_communicator(const MPI_Comm     communicator,
   // shared memory space.
   if (is_shmem_root)
     {
-      if (std::is_trivial<T>::value == true)
+      if (std::is_trivial_v<T> == true)
         std::memcpy(aligned_shmem_pointer, elements.get(), sizeof(T) * size());
       else
         for (std::size_t i = 0; i < size(); ++i)
index 6f4d8922c1097a32b1a3b49dd2dcfe000bd5eb6c..6728fefeec0515b42aff6d8f4ed14c4662157f8a 100644 (file)
@@ -452,7 +452,7 @@ inline ArrayView<ElementType, MemorySpaceType>::ArrayView(
   // nevertheless, leave the static_assert in since it provides a
   // more descriptive error message that will simply come after the first
   // error produced above
-  static_assert(std::is_const<value_type>::value == true,
+  static_assert(std::is_const_v<value_type> == true,
                 "This constructor may only be called if the ArrayView "
                 "object has a const value_type. In other words, you can "
                 "only create an ArrayView to const values from a const "
@@ -486,7 +486,7 @@ inline ArrayView<ElementType, MemorySpaceType>::ArrayView(
   // nevertheless, leave the static_assert in since it provides a
   // more descriptive error message that will simply come after the first
   // error produced above
-  static_assert(std::is_const<value_type>::value == true,
+  static_assert(std::is_const_v<value_type> == true,
                 "This constructor may only be called if the ArrayView "
                 "object has a const value_type. In other words, you can "
                 "only create an ArrayView to const values from a const "
index 98947746805494ace1f33df96472e375c1759fb7..e9d0d2cb6bd9ce4d6346f8666f0a513493447f9f 100644 (file)
@@ -254,8 +254,7 @@ public:
    * the same entry in the same container.
    */
   template <typename OtherIterator>
-  std::enable_if_t<std::is_convertible<OtherIterator, DerivedIterator>::value,
-                   bool>
+  std::enable_if_t<std::is_convertible_v<OtherIterator, DerivedIterator>, bool>
   operator==(const OtherIterator &right) const
   {
     const auto &right_2 = static_cast<const DerivedIterator &>(right);
@@ -266,8 +265,7 @@ public:
    * Opposite of operator==().
    */
   template <typename OtherIterator>
-  std::enable_if_t<std::is_convertible<OtherIterator, DerivedIterator>::value,
-                   bool>
+  std::enable_if_t<std::is_convertible_v<OtherIterator, DerivedIterator>, bool>
   operator!=(const OtherIterator &right) const
   {
     return !(*this == right);
index d55b6348e404ce33bdb8f66ead93f11a8ce00f29..e37784d155bd833bf4f813fcdfaab387982bc894 100644 (file)
@@ -89,7 +89,7 @@ namespace MemoryConsumption
    * implemented.
    */
   template <typename T>
-  inline std::enable_if_t<std::is_fundamental<T>::value, std::size_t>
+  inline std::enable_if_t<std::is_fundamental_v<T>, std::size_t>
   memory_consumption(const T &t);
 
   /**
@@ -99,8 +99,7 @@ namespace MemoryConsumption
    * <tt>t.memory_consumption()</tt>'s value.
    */
   template <typename T>
-  inline std::enable_if_t<!(std::is_fundamental<T>::value ||
-                            std::is_pointer<T>::value),
+  inline std::enable_if_t<!(std::is_fundamental_v<T> || std::is_pointer_v<T>),
                           std::size_t>
   memory_consumption(const T &t);
 
@@ -260,7 +259,7 @@ namespace MemoryConsumption
 namespace MemoryConsumption
 {
   template <typename T>
-  inline std::enable_if_t<std::is_fundamental<T>::value, std::size_t>
+  inline std::enable_if_t<std::is_fundamental_v<T>, std::size_t>
   memory_consumption(const T &)
   {
     return sizeof(T);
@@ -314,7 +313,7 @@ namespace MemoryConsumption
   memory_consumption(const std::vector<T> &v)
   {
     // shortcut for types that do not allocate memory themselves
-    if (std::is_fundamental<T>::value || std::is_pointer<T>::value)
+    if (std::is_fundamental_v<T> || std::is_pointer_v<T>)
       {
         return v.capacity() * sizeof(T) + sizeof(v);
       }
@@ -337,7 +336,7 @@ namespace MemoryConsumption
   memory_consumption(const std::array<T, N> &v)
   {
     // shortcut for types that do not allocate memory themselves
-    if (std::is_fundamental<T>::value || std::is_pointer<T>::value)
+    if (std::is_fundamental_v<T> || std::is_pointer_v<T>)
       {
         return sizeof(v);
       }
@@ -409,8 +408,7 @@ namespace MemoryConsumption
 
 
   template <typename T>
-  inline std::enable_if_t<!(std::is_fundamental<T>::value ||
-                            std::is_pointer<T>::value),
+  inline std::enable_if_t<!(std::is_fundamental_v<T> || std::is_pointer_v<T>),
                           std::size_t>
   memory_consumption(const T &t)
   {
index 5322eb144c4ba841968cd12d449867e5ca891e81..8212fb54921f99fbe03c5512bc03f3cc2f26e92c 100644 (file)
@@ -1844,7 +1844,7 @@ namespace Utilities
                const MPI_Comm mpi_communicator,
                T (&results)[N])
     {
-      static_assert(std::is_integral<T>::value,
+      static_assert(std::is_integral_v<T>,
                     "The MPI_LOR operation only allows integral data types.");
 
       internal::all_reduce(MPI_LOR,
index 3f6b8815d575ba8b5292128e6c16bd78b575035c..1f260f49600bf9e7a1d7cf942cf57444d6eb0a80 100644 (file)
@@ -339,7 +339,7 @@ namespace Utilities
     T
     logical_or(const T &t, const MPI_Comm mpi_communicator)
     {
-      static_assert(std::is_integral<T>::value,
+      static_assert(std::is_integral_v<T>,
                     "The MPI_LOR operation only allows integral data types.");
 
       T return_value{};
@@ -359,7 +359,7 @@ namespace Utilities
       static_assert(std::is_same_v<std::decay_t<T>, std::decay_t<U>>,
                     "Input and output arguments must have the same type!");
 
-      static_assert(std::is_integral<typename T::value_type>::value,
+      static_assert(std::is_integral_v<typename T::value_type>,
                     "The MPI_LOR operation only allows integral data types.");
 
       // Specializations of std containers for the data type bool do not
@@ -386,7 +386,7 @@ namespace Utilities
                const MPI_Comm            mpi_communicator,
                const ArrayView<T> &      results)
     {
-      static_assert(std::is_integral<T>::value,
+      static_assert(std::is_integral_v<T>,
                     "The MPI_LOR operation only allows integral data types.");
 
       internal::all_reduce(MPI_LOR, values, mpi_communicator, results);
index 1c9dd9606dd323b1bb783b84ab8ee81f75e2f5af..12b79735929d46fe7bf4dd17f7d0b009a0329ad5 100644 (file)
@@ -716,7 +716,7 @@ namespace internal
     static constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE T
     value(const F &f,
           std::enable_if_t<!std::is_same_v<std::decay_t<T>, std::decay_t<F>> &&
-                           std::is_constructible<T, F>::value> * = nullptr)
+                           std::is_constructible_v<T, F>> * = nullptr)
     {
       return T(f);
     }
@@ -726,7 +726,7 @@ namespace internal
     static constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE T
     value(const F &f,
           std::enable_if_t<!std::is_same_v<std::decay_t<T>, std::decay_t<F>> &&
-                           !std::is_constructible<T, F>::value &&
+                           !std::is_constructible_v<T, F> &&
                            is_explicitly_convertible<const F, T>::value> * =
             nullptr)
     {
@@ -742,7 +742,7 @@ namespace internal
     value(
       const F &f,
       std::enable_if_t<!std::is_same_v<std::decay_t<T>, std::decay_t<F>> &&
-                       !std::is_constructible<T, F>::value &&
+                       !std::is_constructible_v<T, F> &&
                        !is_explicitly_convertible<const F, T>::value &&
                        Differentiation::AD::is_ad_number<F>::value> * = nullptr)
     {
index fa4cf1c05b2ae47d19ed188a3ea3d732ea09d254..6121527c45a805fd987d6734e7fc9b604a501176 100644 (file)
@@ -2339,7 +2339,7 @@ ParameterHandler::add_parameter(const std::string &          entry,
                                 const Patterns::PatternBase &pattern,
                                 const bool                   has_to_be_set)
 {
-  static_assert(std::is_const<ParameterType>::value == false,
+  static_assert(std::is_const_v<ParameterType> == false,
                 "You tried to add a parameter using a type "
                 "that is const. Use a non-const type.");
 
index 8f6b4086d1a80a273ae7de995a5de708fadecd2f..978a6c408974e8f2ca8330afdc6d581e8f8c3629 100644 (file)
@@ -473,7 +473,7 @@ namespace Utilities
       // standards. To avoid this, we use std::abs on default types but
       // simply return the number on unsigned types
       template <typename Number>
-      std::enable_if_t<!std::is_unsigned<Number>::value,
+      std::enable_if_t<!std::is_unsigned_v<Number>,
                        typename numbers::NumberTraits<Number>::real_type>
       get_abs(const Number a)
       {
@@ -481,7 +481,7 @@ namespace Utilities
       }
 
       template <typename Number>
-      std::enable_if_t<std::is_unsigned<Number>::value, Number>
+      std::enable_if_t<std::is_unsigned_v<Number>, Number>
       get_abs(const Number a)
       {
         return a;
@@ -783,7 +783,7 @@ namespace Utilities
           else
 #    endif
             {
-              if constexpr (std::is_trivial<Number>::value)
+              if constexpr (std::is_trivial_v<Number>)
                 {
                   std::memset(ghost_array.data(),
                               0,
index e0d71fad932a4cbce51abad681aae5f8cec05167..96daf28834c23f4741bf2513bf8bd914b473ad43 100644 (file)
@@ -1481,7 +1481,7 @@ namespace Patterns
 
     // Arithmetic types
     template <class T>
-    struct Convert<T, std::enable_if_t<std::is_arithmetic<T>::value>>
+    struct Convert<T, std::enable_if_t<std::is_arithmetic_v<T>>>
     {
       template <typename Dummy = T>
       static std::enable_if_t<std::is_same_v<Dummy, T> &&
@@ -1495,7 +1495,7 @@ namespace Patterns
       template <typename Dummy = T>
       static std::enable_if_t<std::is_same_v<Dummy, T> &&
                                 !std::is_same_v<T, bool> &&
-                                std::is_integral<T>::value,
+                                std::is_integral_v<T>,
                               std::unique_ptr<Patterns::PatternBase>>
       to_pattern()
       {
@@ -1506,7 +1506,7 @@ namespace Patterns
       template <typename Dummy = T>
       static std::enable_if_t<std::is_same_v<Dummy, T> &&
                                 !std::is_same_v<T, bool> &&
-                                std::is_floating_point<T>::value,
+                                std::is_floating_point_v<T>,
                               std::unique_ptr<Patterns::PatternBase>>
       to_pattern()
       {
index a686002ad1a29f3345d72602bfa149fd8d131f50..9fedf17c6bd1f21644e57e8f372f5939ad20ea61 100644 (file)
@@ -122,9 +122,9 @@ template <typename... T>
 constexpr TableIndices<N>::TableIndices(const T... args)
   : indices{static_cast<std::size_t>(args)...}
 {
-  static_assert(internal::TemplateConstraints::all_true<
-                  std::is_integral<T>::value...>::value,
-                "Not all of the parameters have integral type!");
+  static_assert(
+    internal::TemplateConstraints::all_true<std::is_integral_v<T>...>::value,
+    "Not all of the parameters have integral type!");
   static_assert(sizeof...(T) == N, "Wrong number of constructor arguments!");
 }
 
index 05f637ee56ec007e86ca484f7a82b84f7b54028a..909aa7441e471c939f5a85bccd1b350066ec8bbd 100644 (file)
@@ -106,7 +106,7 @@ namespace Threads
     static_assert(
       std::is_copy_constructible<
         typename internal::unpack_container<T>::type>::value ||
-        std::is_default_constructible<T>::value,
+        std::is_default_constructible_v<T>,
       "The stored type must be either copyable, or default constructible");
 
   public:
@@ -373,7 +373,7 @@ namespace Threads
      */
     template <typename T>
     std::enable_if_t<
-      std::is_copy_constructible<typename unpack_container<T>::type>::value,
+      std::is_copy_constructible_v<typename unpack_container<T>::type>,
       T &>
     construct_element(std::map<std::thread::id, T> &  data,
                       const std::thread::id &         id,
@@ -389,7 +389,7 @@ namespace Threads
 
     template <typename T>
     std::enable_if_t<
-      !std::is_copy_constructible<typename unpack_container<T>::type>::value,
+      !std::is_copy_constructible_v<typename unpack_container<T>::type>,
       T &>
     construct_element(std::map<std::thread::id, T> &data,
                       const std::thread::id &       id,
index b0f0317d51fd5c24d518013dc970c40441309a75..348599d9eb410d3323d09a65765eb5a42b729001 100644 (file)
@@ -498,7 +498,7 @@ namespace Utilities
     // return prefactor * dealii::Utilities::pow(base*base, iexp/2);
     // </code>
 
-    static_assert(std::is_integral<T>::value, "Only integral types supported");
+    static_assert(std::is_integral_v<T>, "Only integral types supported");
 
     return iexp <= 0 ?
              1 :
@@ -982,8 +982,8 @@ namespace Utilities
   inline T
   fixed_power(const T x)
   {
-    Assert(((std::is_integral<T>::value == true) && (N >= 0)) ||
-             (std::is_integral<T>::value == false),
+    Assert(((std::is_integral_v<T> == true) && (N >= 0)) ||
+             (std::is_integral_v<T> == false),
            ExcMessage("If the type of the argument, T, is an integer type, "
                       "then the exponent N must be a non-negative integer "
                       "because the result would otherwise not be an integer."));
@@ -1123,7 +1123,7 @@ namespace Utilities
     /**
      * A structure that is used to identify whether a template argument is a
      * std::vector<T> or std::vector<std::vector<T>> where T is a type that
-     * satisfies std::is_trivially_copyable<T>::value == true.
+     * satisfies std::is_trivially_copyable_v<T> == true.
      */
     template <typename T>
     struct IsVectorOfTriviallyCopyable
@@ -1137,7 +1137,7 @@ namespace Utilities
     struct IsVectorOfTriviallyCopyable<std::vector<T>>
     {
       static constexpr bool value =
-        std::is_trivially_copyable<T>::value && !std::is_same_v<T, bool>;
+        std::is_trivially_copyable_v<T> && !std::is_same_v<T, bool>;
     };
 
 
@@ -1146,14 +1146,14 @@ namespace Utilities
     struct IsVectorOfTriviallyCopyable<std::vector<std::vector<T>>>
     {
       static constexpr bool value =
-        std::is_trivially_copyable<T>::value && !std::is_same_v<T, bool>;
+        std::is_trivially_copyable_v<T> && !std::is_same_v<T, bool>;
     };
 
 
 
     /**
      * A function that is used to append the contents of a std::vector<T>
-     * (where T is a type that satisfies std::is_trivially_copyable<T>::value
+     * (where T is a type that satisfies std::is_trivially_copyable_v<T>
      * == true but not T==bool) bit for bit to a character array.
      *
      * If the type is not such a vector of T, then the function
@@ -1172,7 +1172,7 @@ namespace Utilities
 
     template <typename T,
               typename = std::enable_if_t<!std::is_same_v<T, bool> &&
-                                          std::is_trivially_copyable<T>::value>>
+                                          std::is_trivially_copyable_v<T>>>
     inline void
     append_vector_of_trivially_copyable_to_buffer(
       const std::vector<T> &object,
@@ -1202,7 +1202,7 @@ namespace Utilities
 
     template <typename T,
               typename = std::enable_if_t<!std::is_same_v<T, bool> &&
-                                          std::is_trivially_copyable<T>::value>>
+                                          std::is_trivially_copyable_v<T>>>
     inline void
     append_vector_of_trivially_copyable_to_buffer(
       const std::vector<std::vector<T>> &object,
@@ -1262,7 +1262,7 @@ namespace Utilities
 
     template <typename T,
               typename = std::enable_if_t<!std::is_same_v<T, bool> &&
-                                          std::is_trivially_copyable<T>::value>>
+                                          std::is_trivially_copyable_v<T>>>
     inline void
     create_vector_of_trivially_copyable_from_buffer(
       const std::vector<char>::const_iterator &cbegin,
@@ -1297,7 +1297,7 @@ namespace Utilities
 
     template <typename T,
               typename = std::enable_if_t<!std::is_same_v<T, bool> &&
-                                          std::is_trivially_copyable<T>::value>>
+                                          std::is_trivially_copyable_v<T>>>
     inline void
     create_vector_of_trivially_copyable_from_buffer(
       const std::vector<char>::const_iterator &cbegin,
index 4a21a41489b40c77c7fe86609feffdbebeda7e71..b68799c7ea759f5281609d3cdddff4e312385a8d 100644 (file)
@@ -260,7 +260,7 @@ namespace CGALWrappers
 
     // Do the same with surface patches, if possible
     SubCellData subcell_data;
-    if constexpr (std::is_integral<typename C3T3::Surface_patch_index>::value)
+    if constexpr (std::is_integral_v<typename C3T3::Surface_patch_index>)
       {
         for (auto face = cgal_triangulation.facets_in_complex_begin();
              face != cgal_triangulation.facets_in_complex_end();
@@ -283,7 +283,7 @@ namespace CGALWrappers
           }
       }
     // and curves
-    if constexpr (std::is_integral<typename C3T3::Curve_index>::value)
+    if constexpr (std::is_integral_v<typename C3T3::Curve_index>)
       {
         for (auto edge = cgal_triangulation.edges_in_complex_begin();
              edge != cgal_triangulation.edges_in_complex_end();
index 3d57659e2025b6b5ec97f4b29d127349e3a9c299..3e536fb5bf1f59cdee377ff3680f676c44cc77a5 100644 (file)
@@ -203,9 +203,8 @@ namespace Differentiation
        * potential ambiguities related to implicit conversions in either user
        * code or math functions that are loaded into the standard namespace.
        */
-      template <
-        typename NumberType,
-        typename = std::enable_if_t<std::is_arithmetic<NumberType>::value>>
+      template <typename NumberType,
+                typename = std::enable_if_t<std::is_arithmetic_v<NumberType>>>
       explicit Expression(const NumberType &value);
 
       /**
@@ -215,9 +214,8 @@ namespace Differentiation
        * potential ambiguities related to implicit conversions in either user
        * code or math functions that are loaded into the standard namespace.
        */
-      template <
-        typename NumberType,
-        typename = std::enable_if_t<std::is_arithmetic<NumberType>::value>>
+      template <typename NumberType,
+                typename = std::enable_if_t<std::is_arithmetic_v<NumberType>>>
       explicit Expression(const std::complex<NumberType> &value);
 
       /**
@@ -231,9 +229,8 @@ namespace Differentiation
        * It is expected that both the @p numerator and @p denominator
        * be integral types.
        */
-      template <
-        typename NumberType,
-        typename = std::enable_if_t<std::is_integral<NumberType>::value>>
+      template <typename NumberType,
+                typename = std::enable_if_t<std::is_integral_v<NumberType>>>
       Expression(const NumberType &numerator, const NumberType &denominator);
 
       /**
@@ -1085,7 +1082,7 @@ namespace Differentiation
      */
     template <typename NumberType,
               typename = std::enable_if_t<
-                std::is_constructible<Expression, NumberType>::value>>
+                std::is_constructible_v<Expression, NumberType>>>
     inline Expression
     operator+(const NumberType &lhs, const Expression &rhs)
     {
@@ -1102,7 +1099,7 @@ namespace Differentiation
      */
     template <typename NumberType,
               typename = std::enable_if_t<
-                std::is_constructible<Expression, NumberType>::value>>
+                std::is_constructible_v<Expression, NumberType>>>
     inline Expression
     operator+(const Expression &lhs, const NumberType &rhs)
     {
@@ -1119,7 +1116,7 @@ namespace Differentiation
      */
     template <typename NumberType,
               typename = std::enable_if_t<
-                std::is_constructible<Expression, NumberType>::value>>
+                std::is_constructible_v<Expression, NumberType>>>
     inline Expression
     operator-(const NumberType &lhs, const Expression &rhs)
     {
@@ -1136,7 +1133,7 @@ namespace Differentiation
      */
     template <typename NumberType,
               typename = std::enable_if_t<
-                std::is_constructible<Expression, NumberType>::value>>
+                std::is_constructible_v<Expression, NumberType>>>
     inline Expression
     operator-(const Expression &lhs, const NumberType &rhs)
     {
@@ -1153,7 +1150,7 @@ namespace Differentiation
      */
     template <typename NumberType,
               typename = std::enable_if_t<
-                std::is_constructible<Expression, NumberType>::value>>
+                std::is_constructible_v<Expression, NumberType>>>
     inline Expression
     operator*(const NumberType &lhs, const Expression &rhs)
     {
@@ -1170,7 +1167,7 @@ namespace Differentiation
      */
     template <typename NumberType,
               typename = std::enable_if_t<
-                std::is_constructible<Expression, NumberType>::value>>
+                std::is_constructible_v<Expression, NumberType>>>
     inline Expression
     operator*(const Expression &lhs, const NumberType &rhs)
     {
@@ -1187,7 +1184,7 @@ namespace Differentiation
      */
     template <typename NumberType,
               typename = std::enable_if_t<
-                std::is_constructible<Expression, NumberType>::value>>
+                std::is_constructible_v<Expression, NumberType>>>
     inline Expression
     operator/(const NumberType &lhs, const Expression &rhs)
     {
@@ -1204,7 +1201,7 @@ namespace Differentiation
      */
     template <typename NumberType,
               typename = std::enable_if_t<
-                std::is_constructible<Expression, NumberType>::value>>
+                std::is_constructible_v<Expression, NumberType>>>
     inline Expression
     operator/(const Expression &lhs, const NumberType &rhs)
     {
@@ -1376,24 +1373,21 @@ namespace internal
       return t;
     }
 
-    template <typename T,
-              typename = std::enable_if_t<std::is_arithmetic<T>::value>>
+    template <typename T, typename = std::enable_if_t<std::is_arithmetic_v<T>>>
     static Differentiation::SD::Expression
     value(const T &t)
     {
       return Differentiation::SD::Expression(t);
     }
 
-    template <typename T,
-              typename = std::enable_if_t<std::is_arithmetic<T>::value>>
+    template <typename T, typename = std::enable_if_t<std::is_arithmetic_v<T>>>
     static Differentiation::SD::Expression
     value(T &&t)
     {
       return Differentiation::SD::Expression(t);
     }
 
-    template <typename T,
-              typename = std::enable_if_t<std::is_arithmetic<T>::value>>
+    template <typename T, typename = std::enable_if_t<std::is_arithmetic_v<T>>>
     static Differentiation::SD::Expression
     value(const std::complex<T> &t)
     {
index 20b2040a708288e79c82e21891f1f8668004a6a9..bbd8ff31ef168749510640c487c6d0f5bc34a59b 100644 (file)
@@ -368,7 +368,7 @@ namespace Differentiation
       template <typename ReturnType_>
       struct SupportedOptimizerTypeTraits<
         ReturnType_,
-        std::enable_if_t<std::is_arithmetic<ReturnType_>::value>>
+        std::enable_if_t<std::is_arithmetic_v<ReturnType_>>>
       {
         static const bool is_supported = true;
 
@@ -384,7 +384,7 @@ namespace Differentiation
         ReturnType_,
         std::enable_if_t<
           boost::is_complex<ReturnType_>::value &&
-          std::is_arithmetic<typename ReturnType_::value_type>::value>>
+          std::is_arithmetic_v<typename ReturnType_::value_type>>>
       {
         static const bool is_supported = true;
 
@@ -595,9 +595,8 @@ namespace Differentiation
 
 #    ifdef HAVE_SYMENGINE_LLVM
       template <typename ReturnType_>
-      struct LLVMOptimizer<
-        ReturnType_,
-        std::enable_if_t<std::is_arithmetic<ReturnType_>::value>>
+      struct LLVMOptimizer<ReturnType_,
+                           std::enable_if_t<std::is_arithmetic_v<ReturnType_>>>
       {
         using ReturnType = typename std::
           conditional<std::is_same_v<ReturnType_, float>, float, double>::type;
@@ -711,7 +710,7 @@ namespace Differentiation
         ReturnType_,
         std::enable_if_t<
           boost::is_complex<ReturnType_>::value &&
-          std::is_arithmetic<typename ReturnType_::value_type>::value>>
+          std::is_arithmetic_v<typename ReturnType_::value_type>>>
       {
         // Since there is no working implementation, these are dummy types
         // that help with templating in the calling function.
index f12fa19622285165818be15286859012627e2b6a..5161fd41f0d94abb058fb9179d2205c91882b86c 100644 (file)
@@ -64,10 +64,9 @@ namespace internal
     struct GeneralProductTypeImpl;
 
     template <typename T>
-    struct GeneralProductTypeImpl<
-      T,
-      Differentiation::SD::Expression,
-      std::enable_if_t<std::is_arithmetic<T>::value>>
+    struct GeneralProductTypeImpl<T,
+                                  Differentiation::SD::Expression,
+                                  std::enable_if_t<std::is_arithmetic_v<T>>>
     {
       using type = Differentiation::SD::Expression;
     };
@@ -77,7 +76,7 @@ namespace internal
       T,
       Differentiation::SD::Expression,
       std::enable_if_t<boost::is_complex<T>::value &&
-                       std::is_arithmetic<typename T::value_type>::value>>
+                       std::is_arithmetic_v<typename T::value_type>>>
     {
       using type = Differentiation::SD::Expression;
     };
index d4edade89fe35493e925707da38ec4cd8887249f..4c114021cb4596976ee546144536a0fee112acf0 100644 (file)
@@ -464,7 +464,7 @@ namespace Differentiation
                 dealii::internal::is_explicitly_convertible<
                   SymbolicType,
                   const SymEngine::RCP<const SymEngine::Basic> &>::value &&
-                std::is_constructible<SymbolicType, ValueType>::value>>
+                std::is_constructible_v<SymbolicType, ValueType>>>
     void
     set_value_in_symbol_map(types::substitution_map &substitution_map,
                             const SymbolicType &     symbol,
@@ -653,7 +653,7 @@ namespace Differentiation
                 dealii::internal::is_explicitly_convertible<
                   ExpressionType,
                   const SymEngine::RCP<const SymEngine::Basic> &>::value &&
-                std::is_constructible<ExpressionType, ValueType>::value>>
+                std::is_constructible_v<ExpressionType, ValueType>>>
     types::substitution_map
     make_substitution_map(const ExpressionType &symbol, const ValueType &value);
 
@@ -896,7 +896,7 @@ namespace Differentiation
                 dealii::internal::is_explicitly_convertible<
                   ExpressionType,
                   const SymEngine::RCP<const SymEngine::Basic> &>::value &&
-                std::is_constructible<ExpressionType, ValueType>::value>>
+                std::is_constructible_v<ExpressionType, ValueType>>>
     void
     add_to_substitution_map(types::substitution_map &substitution_map,
                             const ExpressionType &   symbol,
@@ -942,7 +942,7 @@ namespace Differentiation
                 dealii::internal::is_explicitly_convertible<
                   ExpressionType,
                   const SymEngine::RCP<const SymEngine::Basic> &>::value &&
-                std::is_constructible<ExpressionType, ValueType>::value>>
+                std::is_constructible_v<ExpressionType, ValueType>>>
     void
     add_to_substitution_map(types::substitution_map &          substitution_map,
                             const std::vector<ExpressionType> &symbols,
index f5bff7a6f07154f46a587fd26b89e9e0e60e7e8d..2474df0e8bc46ac2a68199e07f8d288191279b26 100644 (file)
@@ -375,7 +375,7 @@ public:
    * Compare for equality.
    */
   template <typename OtherAccessor = Accessor>
-  std::enable_if_t<std::is_convertible<OtherAccessor, Accessor>::value, bool>
+  std::enable_if_t<std::is_convertible_v<OtherAccessor, Accessor>, bool>
   operator==(const TriaRawIterator<OtherAccessor> &) const;
 
   /**
index 9a40d4f5436a21cf1b30d11f60c0bdac0c30769b..6ac6f47f93027100341bd1e622feb2ebae5b39b7 100644 (file)
@@ -83,8 +83,7 @@ TriaRawIterator<Accessor>::operator=(const TriaRawIterator<Accessor> &i)
 
 template <typename Accessor>
 template <typename OtherAccessor>
-inline std::enable_if_t<std::is_convertible<OtherAccessor, Accessor>::value,
-                        bool>
+inline std::enable_if_t<std::is_convertible_v<OtherAccessor, Accessor>, bool>
 TriaRawIterator<Accessor>::operator==(
   const TriaRawIterator<OtherAccessor> &other) const
 {
index 1b15cdab58901ab53068988f491f903ecd6d17a3..dad59d7d269632a8544e498f532a22d6a73c173b 100644 (file)
@@ -1490,7 +1490,7 @@ template <
   typename Payload = internal::LinearOperatorImplementation::EmptyPayload,
   typename OperatorExemplar,
   typename Matrix,
-  typename = std::enable_if_t<!std::is_lvalue_reference<Matrix>::value>>
+  typename = std::enable_if_t<!std::is_lvalue_reference_v<Matrix>>>
 LinearOperator<Range, Domain, Payload>
 linear_operator(const OperatorExemplar &, Matrix &&) = delete;
 
@@ -1500,8 +1500,7 @@ template <
   typename Payload = internal::LinearOperatorImplementation::EmptyPayload,
   typename OperatorExemplar,
   typename Matrix,
-  typename =
-    std::enable_if_t<!std::is_lvalue_reference<OperatorExemplar>::value>,
+  typename = std::enable_if_t<!std::is_lvalue_reference_v<OperatorExemplar>>,
   typename = std::enable_if_t<
     !std::is_same_v<OperatorExemplar, LinearOperator<Range, Domain, Payload>>>>
 LinearOperator<Range, Domain, Payload>
@@ -1513,9 +1512,8 @@ template <
   typename Payload = internal::LinearOperatorImplementation::EmptyPayload,
   typename OperatorExemplar,
   typename Matrix,
-  typename = std::enable_if_t<!std::is_lvalue_reference<Matrix>::value>,
-  typename =
-    std::enable_if_t<!std::is_lvalue_reference<OperatorExemplar>::value>,
+  typename = std::enable_if_t<!std::is_lvalue_reference_v<Matrix>>,
+  typename = std::enable_if_t<!std::is_lvalue_reference_v<OperatorExemplar>>,
   typename = std::enable_if_t<
     !std::is_same_v<OperatorExemplar, LinearOperator<Range, Domain, Payload>>>>
 LinearOperator<Range, Domain, Payload>
@@ -1526,7 +1524,7 @@ template <
   typename Domain  = Range,
   typename Payload = internal::LinearOperatorImplementation::EmptyPayload,
   typename Matrix,
-  typename = std::enable_if_t<!std::is_lvalue_reference<Matrix>::value>>
+  typename = std::enable_if_t<!std::is_lvalue_reference_v<Matrix>>>
 LinearOperator<Range, Domain, Payload>
 linear_operator(const LinearOperator<Range, Domain, Payload> &,
                 Matrix &&) = delete;
@@ -1536,7 +1534,7 @@ template <
   typename Domain  = Range,
   typename Payload = internal::LinearOperatorImplementation::EmptyPayload,
   typename Matrix,
-  typename = std::enable_if_t<!std::is_lvalue_reference<Matrix>::value>>
+  typename = std::enable_if_t<!std::is_lvalue_reference_v<Matrix>>>
 LinearOperator<Range, Domain, Payload>
 linear_operator(Matrix &&) = delete;
 
@@ -1546,7 +1544,7 @@ template <
   typename Preconditioner,
   typename Range  = typename Solver::vector_type,
   typename Domain = Range,
-  typename = std::enable_if_t<!std::is_lvalue_reference<Preconditioner>::value>,
+  typename = std::enable_if_t<!std::is_lvalue_reference_v<Preconditioner>>,
   typename =
     std::enable_if_t<!std::is_same_v<Preconditioner, PreconditionIdentity>>,
   typename = std::enable_if_t<
index 60662d2b59c1a925b27f12653b506054491125b7..d1dcc6257eea9eb04345c8eddd8b54af60217cb1 100644 (file)
@@ -168,14 +168,14 @@ namespace internal
     using size_type = types::global_dof_index;
 
     template <typename T>
-    std::enable_if_t<std::is_trivial<T>::value>
+    std::enable_if_t<std::is_trivial_v<T>>
     zero_subrange(const size_type begin, const size_type end, T *dst)
     {
       std::memset(dst + begin, 0, (end - begin) * sizeof(T));
     }
 
     template <typename T>
-    std::enable_if_t<!std::is_trivial<T>::value>
+    std::enable_if_t<!std::is_trivial_v<T>>
     zero_subrange(const size_type begin, const size_type end, T *dst)
     {
       std::fill(dst + begin, dst + end, 0);
@@ -219,7 +219,7 @@ SparseMatrix<number>::operator=(const double d)
       grain_size);
   else if (matrix_size > 0)
     {
-      if constexpr (std::is_trivial<number>::value)
+      if constexpr (std::is_trivial_v<number>)
         std::memset(val.get(), 0, matrix_size * sizeof(number));
       else
         std::fill(val.get(), val.get() + matrix_size, 0);
index 79b93d50d19ce90c005e88afff08f801229b4700..4cc7349507fc9808d1b17a7bcc6fc0b4a1074037 100644 (file)
@@ -212,7 +212,7 @@ namespace internal
 
         if (value == Number())
           {
-            if constexpr (std::is_trivial<Number>::value)
+            if constexpr (std::is_trivial_v<Number>)
               {
                 std::memset(dst + begin, 0, sizeof(Number) * (end - begin));
                 return;
index ee5b7ea18a4a8397a17ca22ded4fb09ac546ccaa..617670e34750802fb77f4b1455c29d9a1cc5263a 100644 (file)
@@ -3153,7 +3153,7 @@ namespace internal
   {
     using BaseVectorType = typename ConstBlockVectorSelector<
       VectorType,
-      std::is_const<VectorType>::value>::BaseVectorType;
+      std::is_const_v<VectorType>>::BaseVectorType;
 
     static BaseVectorType *
     get_vector_component(VectorType &vec, const unsigned int component)
index 3e05d8345283498a98d0f4479adf467b1709081f..8147b25a29de1786d1f47ef7004d248f547f97bf 100644 (file)
@@ -229,7 +229,7 @@ namespace AdaptationStrategies
             &              parent,
           const value_type parent_value)
     {
-      static_assert(std::is_arithmetic<value_type>::value &&
+      static_assert(std::is_arithmetic_v<value_type> &&
                       !std::is_same_v<value_type, bool>,
                     "The provided value_type may not meet the requirements "
                     "of this function.");
@@ -247,7 +247,7 @@ namespace AdaptationStrategies
               &              parent,
             const value_type parent_value)
     {
-      static_assert(std::is_arithmetic<value_type>::value &&
+      static_assert(std::is_arithmetic_v<value_type> &&
                       !std::is_same_v<value_type, bool>,
                     "The provided value_type may not meet the requirements "
                     "of this function.");
@@ -289,7 +289,7 @@ namespace AdaptationStrategies
     sum(const typename dealii::Triangulation<dim, spacedim>::cell_iterator &,
         const std::vector<value_type> &children_values)
     {
-      static_assert(std::is_arithmetic<value_type>::value &&
+      static_assert(std::is_arithmetic_v<value_type> &&
                       !std::is_same_v<value_type, bool>,
                     "The provided value_type may not meet the requirements "
                     "of this function.");
@@ -308,7 +308,7 @@ namespace AdaptationStrategies
       const typename dealii::Triangulation<dim, spacedim>::cell_iterator &,
       const std::vector<value_type> &children_values)
     {
-      static_assert(std::is_arithmetic<value_type>::value &&
+      static_assert(std::is_arithmetic_v<value_type> &&
                       !std::is_same_v<value_type, bool>,
                     "The provided value_type may not meet the requirements "
                     "of this function.");
index cbc5574b0ef7987216d8d45bcc3bf64cc2a99e51..ceb6c941136b05a2c070b1fded68cb6e04b995dd 100644 (file)
@@ -50,7 +50,7 @@ class FiniteSizeHistory
 {
 public:
   static_assert(
-    std::is_default_constructible<T>::value,
+    std::is_default_constructible_v<T>,
     "This class requires that the elements of type T are default constructible.");
 
   /**
index f4a7a7b7dd82734e895c551349ae28ca14569a65..26f667570f70265f9e6b7e981df2c8183f55926d 100644 (file)
@@ -56,7 +56,7 @@ namespace Rol
    * VectorAdaptor::value_type itself is a type for real-valued numbers.
    * Therefore, VectorAdaptor supports vectors whose real_type is
    * convertible to value_type in the sense that
-   * <code>std::is_convertible<real_type, value_type>::value</code> yields
+   * <code>std::is_convertible_v<real_type, value_type></code> yields
    * <code>true</code>.
    *
    * The <tt>VectorType</tt> should contain the following methods.
@@ -125,7 +125,7 @@ namespace Rol
      */
     using real_type = typename VectorType::real_type;
 
-    static_assert(std::is_convertible<real_type, value_type>::value,
+    static_assert(std::is_convertible_v<real_type, value_type>,
                   "The real_type of the current VectorType is not "
                   "convertible to the value_type.");
 
index b29eadd3f6ac46e44bc668f775e2233aa182d3f7..46672d6bd7b7a372aafcf0044c8f8f9d2d7a3c34 100644 (file)
@@ -482,7 +482,7 @@ namespace Particles
      */
     template <typename VectorType>
     std::enable_if_t<
-      std::is_convertible<VectorType *, Function<spacedim> *>::value == false>
+      std::is_convertible_v<VectorType *, Function<spacedim> *> == false>
     set_particle_positions(const VectorType &input_vector,
                            const bool        displace_particles = true);
 
@@ -1332,7 +1332,7 @@ namespace Particles
   template <int dim, int spacedim>
   template <typename VectorType>
   inline std::enable_if_t<
-    std::is_convertible<VectorType *, Function<spacedim> *>::value == false>
+    std::is_convertible_v<VectorType *, Function<spacedim> *> == false>
   ParticleHandler<dim, spacedim>::set_particle_positions(
     const VectorType &input_vector,
     const bool        displace_particles)
index c1a36d057378ecebb886b87d7fbd89e997b69756..32f11547149ac61aac8e5df0697ad5b4fa00a762 100644 (file)
@@ -487,9 +487,9 @@ namespace Utilities
     // https://en.cppreference.com/w/cpp/string/basic_string/to_string). So
     // resort to boost::lexical_cast for all other types (in
     // particular for floating point types.
-    std::string lc_string = (std::is_integral<number>::value ?
-                               std::to_string(value) :
-                               boost::lexical_cast<std::string>(value));
+    std::string lc_string =
+      (std::is_integral_v<number> ? std::to_string(value) :
+                                    boost::lexical_cast<std::string>(value));
 
     if ((digits != numbers::invalid_unsigned_int) &&
         (lc_string.size() < digits))
index 7f161a66e91301e45362ebd969e5a9b0e3f379c4..a81179a3cbcb1cb2037170bb39c9fb7e31588940 100644 (file)
@@ -23,11 +23,11 @@ DEAL_II_NAMESPACE_OPEN
 // and it is trivial (can be statically default initialized)
 // Here, the trait std::is_pod cannot be used because it is deprecated
 // in C++20.
-static_assert(std::is_standard_layout<VectorizedArray<double>>::value &&
-                std::is_trivial<VectorizedArray<double>>::value,
+static_assert(std::is_standard_layout_v<VectorizedArray<double>> &&
+                std::is_trivial_v<VectorizedArray<double>>,
               "VectorizedArray<double> must be a POD type");
-static_assert(std::is_standard_layout<VectorizedArray<float>>::value &&
-                std::is_trivial<VectorizedArray<float>>::value,
+static_assert(std::is_standard_layout_v<VectorizedArray<float>> &&
+                std::is_trivial_v<VectorizedArray<float>>,
               "VectorizedArray<float> must be a POD type");
 
 DEAL_II_NAMESPACE_CLOSE
index e4b80d21af28f31c2486f26baf3cee792d275f82..457f72a6ff9dc7779a007989796c47680c109927 100644 (file)
@@ -57,7 +57,7 @@ namespace internal
    * std::abs on default types, but simply return the number on unsigned types.
    */
   template <typename Number>
-  std::enable_if_t<!std::is_unsigned<Number>::value,
+  std::enable_if_t<!std::is_unsigned_v<Number>,
                    typename numbers::NumberTraits<Number>::real_type>
   get_abs(const Number a)
   {
@@ -65,7 +65,7 @@ namespace internal
   }
 
   template <typename Number>
-  std::enable_if_t<std::is_unsigned<Number>::value, Number>
+  std::enable_if_t<std::is_unsigned_v<Number>, Number>
   get_abs(const Number a)
   {
     return a;
index 378b26608bf4bc1168469284450448978bacaf02..15d5f72a44092f356ceb6e50df511402294faaa5 100644 (file)
@@ -26,8 +26,8 @@ template <typename T>
 constexpr bool
 is_const_reference()
 {
-  return std::is_reference<T>::value &&
-         std::is_const<typename std::remove_reference<T>::type>::value;
+  return std::is_reference_v<T> &&
+         std::is_const_v<typename std::remove_reference<T>::type>;
 }
 
 void
@@ -40,9 +40,9 @@ test()
     AssertThrow(a.begin() == &v[4], ExcInternalError());
     AssertThrow(a.end() == &v[7], ExcInternalError());
 
-    static_assert(std::is_reference<decltype(*a.begin())>::value,
+    static_assert(std::is_reference_v<decltype(*a.begin())>,
                   "type should be a reference");
-    static_assert(std::is_reference<decltype(*a.end())>::value,
+    static_assert(std::is_reference_v<decltype(*a.end())>,
                   "type should be a reference");
     static_assert(!is_const_reference<decltype(*a.begin())>(),
                   "type should not be const");
index b1445b265f3a16d8ce406615dca4819c0e9355ee..a1daab5d20371c1e1261facc96bae243f71e3f54 100644 (file)
@@ -28,8 +28,8 @@ template <typename T>
 constexpr bool
 is_const_reference()
 {
-  return std::is_reference<T>::value &&
-         std::is_const<typename std::remove_reference<T>::type>::value;
+  return std::is_reference_v<T> &&
+         std::is_const_v<typename std::remove_reference<T>::type>;
 }
 
 void
@@ -77,9 +77,9 @@ test()
     std::fill(v.begin(), v.end(), 42.0);
     auto a = make_array_view(v.cbegin() + 2, v.cend());
     // a needs to be ArrayView<const double>
-    static_assert(!std::is_const<decltype(a)>::value,
+    static_assert(!std::is_const_v<decltype(a)>,
                   "a should not be const (but has const value)");
-    static_assert(std::is_const<decltype(a)::value_type>::value,
+    static_assert(std::is_const_v<decltype(a)::value_type>,
                   "a::value_type needs to be const");
     static_assert(is_const_reference<decltype(*a.begin())>(),
                   "type needs to be const");
@@ -101,9 +101,9 @@ test()
     // the type checking in that case
 #if BOOST_VERSION >= 106200
     // a needs to be const ArrayView<const double>
-    static_assert(std::is_const<decltype(a)>::value,
+    static_assert(std::is_const_v<decltype(a)>,
                   "a should not be const (but has const value)");
-    static_assert(std::is_const<decltype(a)::value_type>::value,
+    static_assert(std::is_const_v<decltype(a)::value_type>,
                   "a::value_type needs to be const");
     static_assert(is_const_reference<decltype(*a.begin())>(),
                   "type needs to be const");
index 6c4b821ebbb2ac9391769adecde9d1233314db1c..5736dd9ec313e16c76e0dab0cb1c3d73b41a8fb6 100644 (file)
@@ -34,7 +34,7 @@ template <int rank,
           class TensorType,
           typename NumberType1,
           typename NumberType2>
-std::enable_if_t<!std::is_constructible<NumberType1, NumberType2>::value, void>
+std::enable_if_t<!std::is_constructible_v<NumberType1, NumberType2>, void>
 test_tensor_constructor(const std::string &, const std::string &)
 {}
 
@@ -44,7 +44,7 @@ template <int rank,
           class TensorType,
           typename NumberType1,
           typename NumberType2>
-std::enable_if_t<std::is_constructible<NumberType1, NumberType2>::value, void>
+std::enable_if_t<std::is_constructible_v<NumberType1, NumberType2>, void>
 test_tensor_constructor(const std::string &type1, const std::string &type2)
 {
   deallog << "Rank " << rank << ", "

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.