Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <complex>
       7              : #include <type_traits>
       8              : 
       9              : #include "Utilities/NoSuchType.hpp"
      10              : #include "Utilities/TMPL.hpp"
      11              : #include "Utilities/TypeTraits/CreateHasTypeAlias.hpp"
      12              : #include "Utilities/TypeTraits/IsComplexOfFundamental.hpp"
      13              : 
      14              : namespace tt {
      15              : namespace detail {
      16              : // NOLINTBEGIN(clang-diagnostic-unused-const-variable)
      17              : CREATE_HAS_TYPE_ALIAS(ElementType)
      18              : CREATE_HAS_TYPE_ALIAS_V(ElementType)
      19              : CREATE_HAS_TYPE_ALIAS(value_type)
      20              : CREATE_HAS_TYPE_ALIAS_V(value_type)
      21              : // NOLINTEND(clang-diagnostic-unused-const-variable)
      22              : }  // namespace detail
      23              : /// @{
      24              : /// \ingroup TypeTraitsGroup
      25              : /// \brief Extracts the fundamental type for a container
      26              : ///
      27              : /// \details  Designates a type alias `get_fundamental_type::type`
      28              : ///  as `T` when `T` itself is an appropriate fundamental type, and the
      29              : /// contained type of a container which specifies a `value_type`.
      30              : ///
      31              : /// `get_fundamental_type_t<T>` is provided as a type alias to
      32              : /// `type` from `get_fundamental_type<T>`
      33              : ///
      34              : /// \snippet Test_GetFundamentalType.cpp get_fundamental_type
      35              : template <typename T, typename = std::nullptr_t>
      36            1 : struct get_fundamental_type {
      37            0 :   using type = tmpl::conditional_t<std::is_fundamental_v<T>, T, NoSuchType>;
      38              : };
      39              : 
      40              : /// \cond
      41              : // Specialization for Blaze expressions
      42              : template <typename T>
      43              : struct get_fundamental_type<T, Requires<detail::has_ElementType_v<T>>> {
      44              :   using type = typename get_fundamental_type<typename T::ElementType>::type;
      45              : };
      46              : // Specialization for containers
      47              : template <typename T>
      48              : struct get_fundamental_type<T, Requires<detail::has_value_type_v<T> and
      49              :                                         not detail::has_ElementType_v<T>>> {
      50              :   using type = typename get_fundamental_type<typename T::value_type>::type;
      51              : };
      52              : /// \endcond
      53              : 
      54              : template <typename T>
      55            0 : using get_fundamental_type_t = typename get_fundamental_type<T>::type;
      56              : /// @}
      57              : 
      58              : template <typename T, typename = std::nullptr_t>
      59            0 : struct get_complex_or_fundamental_type {
      60            0 :   using type =
      61              :       std::conditional_t<tt::is_complex_or_fundamental_v<T>, T, NoSuchType>;
      62              : };
      63              : 
      64              : /// \cond
      65              : // Specialization for Blaze expressions
      66              : template <typename T>
      67              : struct get_complex_or_fundamental_type<T,
      68              :                                        Requires<detail::has_ElementType_v<T>>> {
      69              :   using type =
      70              :       typename get_complex_or_fundamental_type<typename T::ElementType>::type;
      71              : };
      72              : // Specialization for containers
      73              : template <typename T>
      74              : struct get_complex_or_fundamental_type<
      75              :     T, Requires<detail::has_value_type_v<T> and
      76              :                 not detail::has_ElementType_v<T> and
      77              :                 not tt::is_complex_or_fundamental_v<T>>> {
      78              :   using type =
      79              :       typename get_complex_or_fundamental_type<typename T::value_type>::type;
      80              : };
      81              : /// \endcond
      82              : 
      83              : template <typename T>
      84            0 : using get_complex_or_fundamental_type_t =
      85              :     typename get_complex_or_fundamental_type<T>::type;
      86              : 
      87              : }  // namespace tt