Line data    Source code

       1             : // -*- C++ -*-
       2             : 
       3             : // Copyright (C) 2005-2021 Free Software Foundation, Inc.
       4             : //
       5             : // This file is part of the GNU ISO C++ Library.  This library is free
       6             : // software; you can redistribute it and/or modify it under the terms
       7             : // of the GNU General Public License as published by the Free Software
       8             : // Foundation; either version 3, or (at your option) any later
       9             : // version.
      10             : 
      11             : // This library is distributed in the hope that it will be useful, but
      12             : // WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             : // General Public License for more details.
      15             : 
      16             : // Under Section 7 of GPL version 3, you are granted additional
      17             : // permissions described in the GCC Runtime Library Exception, version
      18             : // 3.1, as published by the Free Software Foundation.
      19             : 
      20             : // You should have received a copy of the GNU General Public License and
      21             : // a copy of the GCC Runtime Library Exception along with this program;
      22             : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      23             : // <http://www.gnu.org/licenses/>.
      24             : 
      25             : /** @file ext/type_traits.h
      26             :  *  This file is a GNU extension to the Standard C++ Library.
      27             :  */
      28             : 
      29             : #ifndef _EXT_TYPE_TRAITS
      30             : #define _EXT_TYPE_TRAITS 1
      31             : 
      32             : #pragma GCC system_header
      33             : 
      34             : #include <bits/c++config.h>
      35             : #include <bits/cpp_type_traits.h>
      36             : 
      37             : extern "C++" {
      38             : 
      39             : namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
      40             : {
      41             : _GLIBCXX_BEGIN_NAMESPACE_VERSION
      42             : 
      43             :   // Define a nested type if some predicate holds.
      44             :   template<bool, typename>
      45             :     struct __enable_if 
      46             :     { };
      47             : 
      48             :   template<typename _Tp>
      49             :     struct __enable_if<true, _Tp>
      50             :     { typedef _Tp __type; };
      51             : 
      52             : 
      53             :   // Conditional expression for types. If true, first, if false, second.
      54             :   template<bool _Cond, typename _Iftrue, typename _Iffalse>
      55             :     struct __conditional_type
      56             :     { typedef _Iftrue __type; };
      57             : 
      58             :   template<typename _Iftrue, typename _Iffalse>
      59             :     struct __conditional_type<false, _Iftrue, _Iffalse>
      60             :     { typedef _Iffalse __type; };
      61             : 
      62             : 
      63             :   // Given an integral builtin type, return the corresponding unsigned type.
      64             :   template<typename _Tp>
      65             :     struct __add_unsigned
      66             :     { 
      67             :     private:
      68             :       typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
      69             :       
      70             :     public:
      71             :       typedef typename __if_type::__type __type; 
      72             :     };
      73             : 
      74             :   template<>
      75             :     struct __add_unsigned<char>
      76             :     { typedef unsigned char __type; };
      77             : 
      78             :   template<>
      79             :     struct __add_unsigned<signed char>
      80             :     { typedef unsigned char __type; };
      81             : 
      82             :   template<>
      83             :     struct __add_unsigned<short>
      84             :     { typedef unsigned short __type; };
      85             : 
      86             :   template<>
      87             :     struct __add_unsigned<int>
      88             :     { typedef unsigned int __type; };
      89             : 
      90             :   template<>
      91             :     struct __add_unsigned<long>
      92             :     { typedef unsigned long __type; };
      93             : 
      94             :   template<>
      95             :     struct __add_unsigned<long long>
      96             :     { typedef unsigned long long __type; };
      97             : 
      98             :   // Declare but don't define.
      99             :   template<>
     100             :     struct __add_unsigned<bool>;
     101             : 
     102             :   template<>
     103             :     struct __add_unsigned<wchar_t>;
     104             : 
     105             : 
     106             :   // Given an integral builtin type, return the corresponding signed type.
     107             :   template<typename _Tp>
     108             :     struct __remove_unsigned
     109             :     { 
     110             :     private:
     111             :       typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
     112             :       
     113             :     public:
     114             :       typedef typename __if_type::__type __type; 
     115             :     };
     116             : 
     117             :   template<>
     118             :     struct __remove_unsigned<char>
     119             :     { typedef signed char __type; };
     120             : 
     121             :   template<>
     122             :     struct __remove_unsigned<unsigned char>
     123             :     { typedef signed char __type; };
     124             : 
     125             :   template<>
     126             :     struct __remove_unsigned<unsigned short>
     127             :     { typedef short __type; };
     128             : 
     129             :   template<>
     130             :     struct __remove_unsigned<unsigned int>
     131             :     { typedef int __type; };
     132             : 
     133             :   template<>
     134             :     struct __remove_unsigned<unsigned long>
     135             :     { typedef long __type; };
     136             : 
     137             :   template<>
     138             :     struct __remove_unsigned<unsigned long long>
     139             :     { typedef long long __type; };
     140             : 
     141             :   // Declare but don't define.
     142             :   template<>
     143             :     struct __remove_unsigned<bool>;
     144             : 
     145             :   template<>
     146             :     struct __remove_unsigned<wchar_t>;
     147             : 
     148             : 
     149             :   // For use in string and vstring.
     150             :   template<typename _Type>
     151             :     inline bool
     152     4156732 :     __is_null_pointer(_Type* __ptr)
     153     4156732 :     { return __ptr == 0; }
     154             : 
     155             :   template<typename _Type>
     156             :     inline bool
     157        5547 :     __is_null_pointer(_Type)
     158        5547 :     { return false; }
     159             : 
     160             : #if __cplusplus >= 201103L
     161             :   inline bool
     162             :   __is_null_pointer(std::nullptr_t)
     163             :   { return true; }
     164             : #endif
     165             : 
     166             :   // For arithmetic promotions in <complex> and <cmath>
     167             : 
     168             :   template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
     169             :     struct __promote
     170             :     { typedef double __type; };
     171             : 
     172             :   // No nested __type member for non-integer non-floating point types,
     173             :   // allows this type to be used for SFINAE to constrain overloads in
     174             :   // <cmath> and <complex> to only the intended types.
     175             :   template<typename _Tp>
     176             :     struct __promote<_Tp, false>
     177             :     { };
     178             : 
     179             :   template<>
     180             :     struct __promote<long double>
     181             :     { typedef long double __type; };
     182             : 
     183             :   template<>
     184             :     struct __promote<double>
     185             :     { typedef double __type; };
     186             : 
     187             :   template<>
     188             :     struct __promote<float>
     189             :     { typedef float __type; };
     190             : 
     191             : #if __cpp_fold_expressions
     192             :   template<typename... _Tp>
     193             :     using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...));
     194             : #endif
     195             : 
     196             :   template<typename _Tp, typename _Up,
     197             :            typename _Tp2 = typename __promote<_Tp>::__type,
     198             :            typename _Up2 = typename __promote<_Up>::__type>
     199             :     struct __promote_2
     200             :     {
     201             :       typedef __typeof__(_Tp2() + _Up2()) __type;
     202             :     };
     203             : 
     204             :   template<typename _Tp, typename _Up, typename _Vp,
     205             :            typename _Tp2 = typename __promote<_Tp>::__type,
     206             :            typename _Up2 = typename __promote<_Up>::__type,
     207             :            typename _Vp2 = typename __promote<_Vp>::__type>
     208             :     struct __promote_3
     209             :     {
     210             :       typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
     211             :     };
     212             : 
     213             :   template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
     214             :            typename _Tp2 = typename __promote<_Tp>::__type,
     215             :            typename _Up2 = typename __promote<_Up>::__type,
     216             :            typename _Vp2 = typename __promote<_Vp>::__type,
     217             :            typename _Wp2 = typename __promote<_Wp>::__type>
     218             :     struct __promote_4
     219             :     {
     220             :       typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
     221             :     };
     222             : 
     223             : _GLIBCXX_END_NAMESPACE_VERSION
     224             : } // namespace
     225             : } // extern "C++"
     226             : 
     227             : #endif