Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. // C++11 <type_traits> -*- C++ -*-
  2.  
  3. // Copyright (C) 2007-2013 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
  7. // terms of the GNU General Public License as published by the
  8. // Free Software Foundation; either version 3, or (at your option)
  9. // any later version.
  10.  
  11. // This library is distributed in the hope that it will be useful,
  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. // GNU 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 include/type_traits
  26.  *  This is a Standard C++ Library header.
  27.  */
  28.  
  29. #ifndef _GLIBCXX_TYPE_TRAITS
  30. #define _GLIBCXX_TYPE_TRAITS 1
  31.  
  32. #pragma GCC system_header
  33.  
  34. #if __cplusplus < 201103L
  35. # include <bits/c++0x_warning.h>
  36. #else
  37.  
  38. #include <bits/c++config.h>
  39.  
  40. namespace std _GLIBCXX_VISIBILITY(default)
  41. {
  42. _GLIBCXX_BEGIN_NAMESPACE_VERSION
  43.  
  44.   /**
  45.    * @defgroup metaprogramming Metaprogramming
  46.    * @ingroup utilities
  47.    *
  48.    * Template utilities for compile-time introspection and modification,
  49.    * including type classification traits, type property inspection traits
  50.    * and type transformation traits.
  51.    *
  52.    * @{
  53.    */
  54.  
  55.   /// integral_constant
  56.   template<typename _Tp, _Tp __v>
  57.     struct integral_constant
  58.     {
  59.       static constexpr _Tp                  value = __v;
  60.       typedef _Tp                           value_type;
  61.       typedef integral_constant<_Tp, __v>   type;
  62.       constexpr operator value_type() { return value; }
  63.     };
  64.  
  65.   template<typename _Tp, _Tp __v>
  66.     constexpr _Tp integral_constant<_Tp, __v>::value;
  67.  
  68.   /// The type used as a compile-time boolean with true value.
  69.   typedef integral_constant<bool, true>     true_type;
  70.  
  71.   /// The type used as a compile-time boolean with false value.
  72.   typedef integral_constant<bool, false>    false_type;
  73.  
  74.   // Meta programming helper types.
  75.  
  76.   template<bool, typename, typename>
  77.     struct conditional;
  78.  
  79.   template<typename...>
  80.     struct __or_;
  81.  
  82.   template<>
  83.     struct __or_<>
  84.     : public false_type
  85.     { };
  86.  
  87.   template<typename _B1>
  88.     struct __or_<_B1>
  89.     : public _B1
  90.     { };
  91.  
  92.   template<typename _B1, typename _B2>
  93.     struct __or_<_B1, _B2>
  94.     : public conditional<_B1::value, _B1, _B2>::type
  95.     { };
  96.  
  97.   template<typename _B1, typename _B2, typename _B3, typename... _Bn>
  98.     struct __or_<_B1, _B2, _B3, _Bn...>
  99.     : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
  100.     { };
  101.  
  102.   template<typename...>
  103.     struct __and_;
  104.  
  105.   template<>
  106.     struct __and_<>
  107.     : public true_type
  108.     { };
  109.  
  110.   template<typename _B1>
  111.     struct __and_<_B1>
  112.     : public _B1
  113.     { };
  114.  
  115.   template<typename _B1, typename _B2>
  116.     struct __and_<_B1, _B2>
  117.     : public conditional<_B1::value, _B2, _B1>::type
  118.     { };
  119.  
  120.   template<typename _B1, typename _B2, typename _B3, typename... _Bn>
  121.     struct __and_<_B1, _B2, _B3, _Bn...>
  122.     : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
  123.     { };
  124.  
  125.   template<typename _Pp>
  126.     struct __not_
  127.     : public integral_constant<bool, !_Pp::value>
  128.     { };
  129.  
  130.   struct __sfinae_types
  131.   {
  132.     typedef char __one;
  133.     typedef struct { char __arr[2]; } __two;
  134.   };
  135.  
  136.   // For several sfinae-friendly trait implementations we transport both the
  137.   // result information (as the member type) and the failure information (no
  138.   // member type). This is very similar to std::enable_if, but we cannot use
  139.   // them, because we need to derive from them as an implementation detail.
  140.  
  141.   template<typename _Tp>
  142.     struct __success_type
  143.     { typedef _Tp type; };
  144.  
  145.   struct __failure_type
  146.   { };
  147.  
  148.   // Primary type categories.
  149.  
  150.   template<typename>
  151.     struct remove_cv;
  152.  
  153.   template<typename>
  154.     struct __is_void_helper
  155.     : public false_type { };
  156.  
  157.   template<>
  158.     struct __is_void_helper<void>
  159.     : public true_type { };
  160.  
  161.   /// is_void
  162.   template<typename _Tp>
  163.     struct is_void
  164.     : public integral_constant<bool, (__is_void_helper<typename
  165.                                       remove_cv<_Tp>::type>::value)>
  166.     { };
  167.  
  168.   template<typename>
  169.     struct __is_integral_helper
  170.     : public false_type { };
  171.  
  172.   template<>
  173.     struct __is_integral_helper<bool>
  174.     : public true_type { };
  175.  
  176.   template<>
  177.     struct __is_integral_helper<char>
  178.     : public true_type { };
  179.  
  180.   template<>
  181.     struct __is_integral_helper<signed char>
  182.     : public true_type { };
  183.  
  184.   template<>
  185.     struct __is_integral_helper<unsigned char>
  186.     : public true_type { };
  187.  
  188. #ifdef _GLIBCXX_USE_WCHAR_T
  189.   template<>
  190.     struct __is_integral_helper<wchar_t>
  191.     : public true_type { };
  192. #endif
  193.  
  194.   template<>
  195.     struct __is_integral_helper<char16_t>
  196.     : public true_type { };
  197.  
  198.   template<>
  199.     struct __is_integral_helper<char32_t>
  200.     : public true_type { };
  201.  
  202.   template<>
  203.     struct __is_integral_helper<short>
  204.     : public true_type { };
  205.  
  206.   template<>
  207.     struct __is_integral_helper<unsigned short>
  208.     : public true_type { };
  209.  
  210.   template<>
  211.     struct __is_integral_helper<int>
  212.     : public true_type { };
  213.  
  214.   template<>
  215.     struct __is_integral_helper<unsigned int>
  216.     : public true_type { };
  217.  
  218.   template<>
  219.     struct __is_integral_helper<long>
  220.     : public true_type { };
  221.  
  222.   template<>
  223.     struct __is_integral_helper<unsigned long>
  224.     : public true_type { };
  225.  
  226.   template<>
  227.     struct __is_integral_helper<long long>
  228.     : public true_type { };
  229.  
  230.   template<>
  231.     struct __is_integral_helper<unsigned long long>
  232.     : public true_type { };
  233.  
  234. #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
  235.   template<>
  236.     struct __is_integral_helper<__int128>
  237.     : public true_type { };
  238.  
  239.   template<>
  240.     struct __is_integral_helper<unsigned __int128>
  241.     : public true_type { };
  242. #endif
  243.  
  244.   /// is_integral
  245.   template<typename _Tp>
  246.     struct is_integral
  247.     : public integral_constant<bool, (__is_integral_helper<typename
  248.                                       remove_cv<_Tp>::type>::value)>
  249.     { };
  250.  
  251.   template<typename>
  252.     struct __is_floating_point_helper
  253.     : public false_type { };
  254.  
  255.   template<>
  256.     struct __is_floating_point_helper<float>
  257.     : public true_type { };
  258.  
  259.   template<>
  260.     struct __is_floating_point_helper<double>
  261.     : public true_type { };
  262.  
  263.   template<>
  264.     struct __is_floating_point_helper<long double>
  265.     : public true_type { };
  266.  
  267. #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128)
  268.   template<>
  269.     struct __is_floating_point_helper<__float128>
  270.     : public true_type { };
  271. #endif
  272.  
  273.   /// is_floating_point
  274.   template<typename _Tp>
  275.     struct is_floating_point
  276.     : public integral_constant<bool, (__is_floating_point_helper<typename
  277.                                       remove_cv<_Tp>::type>::value)>
  278.     { };
  279.  
  280.   /// is_array
  281.   template<typename>
  282.     struct is_array
  283.     : public false_type { };
  284.  
  285.   template<typename _Tp, std::size_t _Size>
  286.     struct is_array<_Tp[_Size]>
  287.     : public true_type { };
  288.  
  289.   template<typename _Tp>
  290.     struct is_array<_Tp[]>
  291.     : public true_type { };
  292.  
  293.   template<typename>
  294.     struct __is_pointer_helper
  295.     : public false_type { };
  296.  
  297.   template<typename _Tp>
  298.     struct __is_pointer_helper<_Tp*>
  299.     : public true_type { };
  300.  
  301.   /// is_pointer
  302.   template<typename _Tp>
  303.     struct is_pointer
  304.     : public integral_constant<bool, (__is_pointer_helper<typename
  305.                                       remove_cv<_Tp>::type>::value)>
  306.     { };
  307.  
  308.   /// is_lvalue_reference
  309.   template<typename>
  310.     struct is_lvalue_reference
  311.     : public false_type { };
  312.  
  313.   template<typename _Tp>
  314.     struct is_lvalue_reference<_Tp&>
  315.     : public true_type { };
  316.  
  317.   /// is_rvalue_reference
  318.   template<typename>
  319.     struct is_rvalue_reference
  320.     : public false_type { };
  321.  
  322.   template<typename _Tp>
  323.     struct is_rvalue_reference<_Tp&&>
  324.     : public true_type { };
  325.  
  326.   template<typename>
  327.     struct is_function;
  328.  
  329.   template<typename>
  330.     struct __is_member_object_pointer_helper
  331.     : public false_type { };
  332.  
  333.   template<typename _Tp, typename _Cp>
  334.     struct __is_member_object_pointer_helper<_Tp _Cp::*>
  335.     : public integral_constant<bool, !is_function<_Tp>::value> { };
  336.  
  337.   /// is_member_object_pointer
  338.   template<typename _Tp>
  339.     struct is_member_object_pointer
  340.     : public integral_constant<bool, (__is_member_object_pointer_helper<
  341.                                       typename remove_cv<_Tp>::type>::value)>
  342.     { };
  343.  
  344.   template<typename>
  345.     struct __is_member_function_pointer_helper
  346.     : public false_type { };
  347.  
  348.   template<typename _Tp, typename _Cp>
  349.     struct __is_member_function_pointer_helper<_Tp _Cp::*>
  350.     : public integral_constant<bool, is_function<_Tp>::value> { };
  351.  
  352.   /// is_member_function_pointer
  353.   template<typename _Tp>
  354.     struct is_member_function_pointer
  355.     : public integral_constant<bool, (__is_member_function_pointer_helper<
  356.                                       typename remove_cv<_Tp>::type>::value)>
  357.     { };
  358.  
  359.   /// is_enum
  360.   template<typename _Tp>
  361.     struct is_enum
  362.     : public integral_constant<bool, __is_enum(_Tp)>
  363.     { };
  364.  
  365.   /// is_union
  366.   template<typename _Tp>
  367.     struct is_union
  368.     : public integral_constant<bool, __is_union(_Tp)>
  369.     { };
  370.  
  371.   /// is_class
  372.   template<typename _Tp>
  373.     struct is_class
  374.     : public integral_constant<bool, __is_class(_Tp)>
  375.     { };
  376.  
  377.   /// is_function
  378.   template<typename>
  379.     struct is_function
  380.     : public false_type { };
  381.  
  382.   template<typename _Res, typename... _ArgTypes>
  383.     struct is_function<_Res(_ArgTypes...)>
  384.     : public true_type { };
  385.  
  386.   template<typename _Res, typename... _ArgTypes>
  387.     struct is_function<_Res(_ArgTypes......)>
  388.     : public true_type { };
  389.  
  390.   template<typename _Res, typename... _ArgTypes>
  391.     struct is_function<_Res(_ArgTypes...) const>
  392.     : public true_type { };
  393.  
  394.   template<typename _Res, typename... _ArgTypes>
  395.     struct is_function<_Res(_ArgTypes......) const>
  396.     : public true_type { };
  397.  
  398.   template<typename _Res, typename... _ArgTypes>
  399.     struct is_function<_Res(_ArgTypes...) volatile>
  400.     : public true_type { };
  401.  
  402.   template<typename _Res, typename... _ArgTypes>
  403.     struct is_function<_Res(_ArgTypes......) volatile>
  404.     : public true_type { };
  405.  
  406.   template<typename _Res, typename... _ArgTypes>
  407.     struct is_function<_Res(_ArgTypes...) const volatile>
  408.     : public true_type { };
  409.  
  410.   template<typename _Res, typename... _ArgTypes>
  411.     struct is_function<_Res(_ArgTypes......) const volatile>
  412.     : public true_type { };
  413.  
  414.   template<typename>
  415.     struct __is_nullptr_t_helper
  416.     : public false_type { };
  417.  
  418.   template<>
  419.     struct __is_nullptr_t_helper<std::nullptr_t>
  420.     : public true_type { };
  421.  
  422.   // __is_nullptr_t (extension).
  423.   template<typename _Tp>
  424.     struct __is_nullptr_t
  425.     : public integral_constant<bool, (__is_nullptr_t_helper<typename
  426.                                       remove_cv<_Tp>::type>::value)>
  427.     { };
  428.  
  429.   // Composite type categories.
  430.  
  431.   /// is_reference
  432.   template<typename _Tp>
  433.     struct is_reference
  434.     : public __or_<is_lvalue_reference<_Tp>,
  435.                    is_rvalue_reference<_Tp>>::type
  436.     { };
  437.  
  438.   /// is_arithmetic
  439.   template<typename _Tp>
  440.     struct is_arithmetic
  441.     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  442.     { };
  443.  
  444.   /// is_fundamental
  445.   template<typename _Tp>
  446.     struct is_fundamental
  447.     : public __or_<is_arithmetic<_Tp>, is_void<_Tp>, __is_nullptr_t<_Tp>>::type
  448.     { };
  449.  
  450.   /// is_object
  451.   template<typename _Tp>
  452.     struct is_object
  453.     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  454.                           is_void<_Tp>>>::type
  455.     { };
  456.  
  457.   template<typename>
  458.     struct is_member_pointer;
  459.  
  460.   /// is_scalar
  461.   template<typename _Tp>
  462.     struct is_scalar
  463.     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  464.                    is_member_pointer<_Tp>, __is_nullptr_t<_Tp>>::type
  465.     { };
  466.  
  467.   /// is_compound
  468.   template<typename _Tp>
  469.     struct is_compound
  470.     : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
  471.  
  472.   template<typename _Tp>
  473.     struct __is_member_pointer_helper
  474.     : public false_type { };
  475.  
  476.   template<typename _Tp, typename _Cp>
  477.     struct __is_member_pointer_helper<_Tp _Cp::*>
  478.     : public true_type { };
  479.  
  480.   /// is_member_pointer
  481.   template<typename _Tp>
  482.     struct is_member_pointer
  483.     : public integral_constant<bool, (__is_member_pointer_helper<
  484.                                       typename remove_cv<_Tp>::type>::value)>
  485.     { };
  486.  
  487.   // Type properties.
  488.  
  489.   /// is_const
  490.   template<typename>
  491.     struct is_const
  492.     : public false_type { };
  493.  
  494.   template<typename _Tp>
  495.     struct is_const<_Tp const>
  496.     : public true_type { };
  497.  
  498.   /// is_volatile
  499.   template<typename>
  500.     struct is_volatile
  501.     : public false_type { };
  502.  
  503.   template<typename _Tp>
  504.     struct is_volatile<_Tp volatile>
  505.     : public true_type { };
  506.  
  507.   /// is_trivial
  508.   template<typename _Tp>
  509.     struct is_trivial
  510.     : public integral_constant<bool, __is_trivial(_Tp)>
  511.     { };
  512.  
  513.   // is_trivially_copyable (still unimplemented)
  514.  
  515.   /// is_standard_layout
  516.   template<typename _Tp>
  517.     struct is_standard_layout
  518.     : public integral_constant<bool, __is_standard_layout(_Tp)>
  519.     { };
  520.  
  521.   /// is_pod
  522.   // Could use is_standard_layout && is_trivial instead of the builtin.
  523.   template<typename _Tp>
  524.     struct is_pod
  525.     : public integral_constant<bool, __is_pod(_Tp)>
  526.     { };
  527.  
  528.   /// is_literal_type
  529.   template<typename _Tp>
  530.     struct is_literal_type
  531.     : public integral_constant<bool, __is_literal_type(_Tp)>
  532.     { };
  533.  
  534.   /// is_empty
  535.   template<typename _Tp>
  536.     struct is_empty
  537.     : public integral_constant<bool, __is_empty(_Tp)>
  538.     { };
  539.  
  540.   /// is_polymorphic
  541.   template<typename _Tp>
  542.     struct is_polymorphic
  543.     : public integral_constant<bool, __is_polymorphic(_Tp)>
  544.     { };
  545.  
  546.   /// is_abstract
  547.   template<typename _Tp>
  548.     struct is_abstract
  549.     : public integral_constant<bool, __is_abstract(_Tp)>
  550.     { };
  551.  
  552.   template<typename _Tp,
  553.            bool = is_integral<_Tp>::value,
  554.            bool = is_floating_point<_Tp>::value>
  555.     struct __is_signed_helper
  556.     : public false_type { };
  557.  
  558.   template<typename _Tp>
  559.     struct __is_signed_helper<_Tp, false, true>
  560.     : public true_type { };
  561.  
  562.   template<typename _Tp>
  563.     struct __is_signed_helper<_Tp, true, false>
  564.     : public integral_constant<bool, static_cast<bool>(_Tp(-1) < _Tp(0))>
  565.     { };
  566.  
  567.   /// is_signed
  568.   template<typename _Tp>
  569.     struct is_signed
  570.     : public integral_constant<bool, __is_signed_helper<_Tp>::value>
  571.     { };
  572.  
  573.   /// is_unsigned
  574.   template<typename _Tp>
  575.     struct is_unsigned
  576.     : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>::type
  577.     { };
  578.  
  579.  
  580.   // Destructible and constructible type properties.
  581.  
  582.   template<typename>
  583.     struct add_rvalue_reference;
  584.  
  585.   /**
  586.    *  @brief  Utility to simplify expressions used in unevaluated operands
  587.    *  @ingroup utilities
  588.    */
  589.   template<typename _Tp>
  590.     typename add_rvalue_reference<_Tp>::type declval() noexcept;
  591.  
  592.   template<typename, unsigned = 0>
  593.     struct extent;
  594.  
  595.   template<typename>
  596.     struct remove_all_extents;
  597.  
  598.   template<typename _Tp>
  599.     struct __is_array_known_bounds
  600.     : public integral_constant<bool, (extent<_Tp>::value > 0)>
  601.     { };
  602.  
  603.   template<typename _Tp>
  604.     struct __is_array_unknown_bounds
  605.     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>::type
  606.     { };
  607.    
  608.   // In N3290 is_destructible does not say anything about function
  609.   // types and abstract types, see LWG 2049. This implementation
  610.   // describes function types as non-destructible and all complete
  611.   // object types as destructible, iff the explicit destructor
  612.   // call expression is wellformed.
  613.   struct __do_is_destructible_impl
  614.   {
  615.     template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
  616.       static true_type __test(int);
  617.  
  618.     template<typename>
  619.       static false_type __test(...);
  620.   };
  621.  
  622.   template<typename _Tp>
  623.     struct __is_destructible_impl
  624.     : public __do_is_destructible_impl
  625.     {
  626.       typedef decltype(__test<_Tp>(0)) type;
  627.     };
  628.  
  629.   template<typename _Tp,
  630.            bool = __or_<is_void<_Tp>,
  631.                         __is_array_unknown_bounds<_Tp>,
  632.                         is_function<_Tp>>::value,
  633.            bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
  634.     struct __is_destructible_safe;
  635.  
  636.   template<typename _Tp>
  637.     struct __is_destructible_safe<_Tp, false, false>
  638.     : public __is_destructible_impl<typename
  639.                remove_all_extents<_Tp>::type>::type
  640.     { };
  641.  
  642.   template<typename _Tp>
  643.     struct __is_destructible_safe<_Tp, true, false>
  644.     : public false_type { };
  645.  
  646.   template<typename _Tp>
  647.     struct __is_destructible_safe<_Tp, false, true>
  648.     : public true_type { };
  649.  
  650.   /// is_destructible
  651.   template<typename _Tp>
  652.     struct is_destructible
  653.     : public integral_constant<bool, (__is_destructible_safe<_Tp>::value)>
  654.     { };
  655.  
  656.   // is_nothrow_destructible requires that is_destructible is
  657.   // satisfied as well.  We realize that by mimicing the
  658.   // implementation of is_destructible but refer to noexcept(expr)
  659.   // instead of decltype(expr).
  660.   struct __do_is_nt_destructible_impl
  661.   {
  662.     template<typename _Tp>
  663.       static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())>
  664.         __test(int);
  665.  
  666.     template<typename>
  667.       static false_type __test(...);
  668.   };
  669.  
  670.   template<typename _Tp>
  671.     struct __is_nt_destructible_impl
  672.     : public __do_is_nt_destructible_impl
  673.     {
  674.       typedef decltype(__test<_Tp>(0)) type;
  675.     };
  676.  
  677.   template<typename _Tp,
  678.            bool = __or_<is_void<_Tp>,
  679.                         __is_array_unknown_bounds<_Tp>,
  680.                         is_function<_Tp>>::value,
  681.            bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
  682.     struct __is_nt_destructible_safe;
  683.  
  684.   template<typename _Tp>
  685.     struct __is_nt_destructible_safe<_Tp, false, false>
  686.     : public __is_nt_destructible_impl<typename
  687.                remove_all_extents<_Tp>::type>::type
  688.     { };
  689.  
  690.   template<typename _Tp>
  691.     struct __is_nt_destructible_safe<_Tp, true, false>
  692.     : public false_type { };
  693.  
  694.   template<typename _Tp>
  695.     struct __is_nt_destructible_safe<_Tp, false, true>
  696.     : public true_type { };
  697.  
  698.   /// is_nothrow_destructible
  699.   template<typename _Tp>
  700.     struct is_nothrow_destructible
  701.     : public integral_constant<bool, (__is_nt_destructible_safe<_Tp>::value)>
  702.     { };
  703.  
  704.   struct __do_is_default_constructible_impl
  705.   {
  706.     template<typename _Tp, typename = decltype(_Tp())>
  707.       static true_type __test(int);
  708.  
  709.     template<typename>
  710.       static false_type __test(...);
  711.   };
  712.  
  713.   template<typename _Tp>
  714.     struct __is_default_constructible_impl
  715.     : public __do_is_default_constructible_impl
  716.     {
  717.       typedef decltype(__test<_Tp>(0)) type;
  718.     };
  719.  
  720.   template<typename _Tp>
  721.     struct __is_default_constructible_atom
  722.     : public __and_<__not_<is_void<_Tp>>,
  723.                     __is_default_constructible_impl<_Tp>>::type
  724.     { };
  725.  
  726.   template<typename _Tp, bool = is_array<_Tp>::value>
  727.     struct __is_default_constructible_safe;
  728.  
  729.   // The following technique is a workaround for a current core language
  730.   // restriction, which does not allow for array types to occur in
  731.   // functional casts of the form T().  Complete arrays can be default-
  732.   // constructed, if the element type is default-constructible, but
  733.   // arrays with unknown bounds are not.
  734.   template<typename _Tp>
  735.     struct __is_default_constructible_safe<_Tp, true>
  736.     : public __and_<__is_array_known_bounds<_Tp>,
  737.                     __is_default_constructible_atom<typename
  738.                       remove_all_extents<_Tp>::type>>::type
  739.     { };
  740.  
  741.   template<typename _Tp>
  742.     struct __is_default_constructible_safe<_Tp, false>
  743.     : public __is_default_constructible_atom<_Tp>::type
  744.     { };
  745.  
  746.   /// is_default_constructible
  747.   template<typename _Tp>
  748.     struct is_default_constructible
  749.     : public integral_constant<bool, (__is_default_constructible_safe<
  750.                                       _Tp>::value)>
  751.     { };
  752.  
  753.  
  754.   // Implementation of is_constructible.
  755.  
  756.   // The hardest part of this trait is the binary direct-initialization
  757.   // case, because we hit into a functional cast of the form T(arg).
  758.   // This implementation uses different strategies depending on the
  759.   // target type to reduce the test overhead as much as possible:
  760.   //
  761.   // a) For a reference target type, we use a static_cast expression
  762.   //    modulo its extra cases.
  763.   //
  764.   // b) For a non-reference target type we use a ::new expression.
  765.   struct __do_is_static_castable_impl
  766.   {
  767.     template<typename _From, typename _To, typename
  768.              = decltype(static_cast<_To>(declval<_From>()))>
  769.       static true_type __test(int);
  770.  
  771.     template<typename, typename>
  772.       static false_type __test(...);
  773.   };
  774.  
  775.   template<typename _From, typename _To>
  776.     struct __is_static_castable_impl
  777.     : public __do_is_static_castable_impl
  778.     {
  779.       typedef decltype(__test<_From, _To>(0)) type;
  780.     };
  781.  
  782.   template<typename _From, typename _To>
  783.     struct __is_static_castable_safe
  784.     : public __is_static_castable_impl<_From, _To>::type
  785.     { };
  786.  
  787.   // __is_static_castable
  788.   template<typename _From, typename _To>
  789.     struct __is_static_castable
  790.     : public integral_constant<bool, (__is_static_castable_safe<
  791.                                       _From, _To>::value)>
  792.     { };
  793.  
  794.   // Implementation for non-reference types. To meet the proper
  795.   // variable definition semantics, we also need to test for
  796.   // is_destructible in this case.
  797.   // This form should be simplified by a single expression:
  798.   // ::delete ::new _Tp(declval<_Arg>()), see c++/51222.
  799.   struct __do_is_direct_constructible_impl
  800.   {
  801.     template<typename _Tp, typename _Arg, typename
  802.              = decltype(::new _Tp(declval<_Arg>()))>
  803.       static true_type __test(int);
  804.  
  805.     template<typename, typename>
  806.       static false_type __test(...);
  807.   };
  808.  
  809.   template<typename _Tp, typename _Arg>
  810.     struct __is_direct_constructible_impl
  811.     : public __do_is_direct_constructible_impl
  812.     {
  813.       typedef decltype(__test<_Tp, _Arg>(0)) type;
  814.     };
  815.  
  816.   template<typename _Tp, typename _Arg>
  817.     struct __is_direct_constructible_new_safe
  818.     : public __and_<is_destructible<_Tp>,
  819.                     __is_direct_constructible_impl<_Tp, _Arg>>::type
  820.     { };
  821.  
  822.   template<typename, typename>
  823.     struct is_same;
  824.  
  825.   template<typename, typename>
  826.     struct is_base_of;
  827.  
  828.   template<typename>
  829.     struct remove_reference;
  830.  
  831.   template<typename _From, typename _To, bool
  832.            = __not_<__or_<is_void<_From>,
  833.                           is_function<_From>>>::value>
  834.     struct __is_base_to_derived_ref;
  835.  
  836.   // Detect whether we have a downcast situation during
  837.   // reference binding.
  838.   template<typename _From, typename _To>
  839.     struct __is_base_to_derived_ref<_From, _To, true>
  840.     {
  841.       typedef typename remove_cv<typename remove_reference<_From
  842.         >::type>::type __src_t;
  843.       typedef typename remove_cv<typename remove_reference<_To
  844.         >::type>::type __dst_t;
  845.       typedef __and_<__not_<is_same<__src_t, __dst_t>>,
  846.                      is_base_of<__src_t, __dst_t>> type;
  847.       static constexpr bool value = type::value;
  848.     };
  849.  
  850.   template<typename _From, typename _To>
  851.     struct __is_base_to_derived_ref<_From, _To, false>
  852.     : public false_type
  853.     { };
  854.  
  855.   template<typename _From, typename _To, bool
  856.            = __and_<is_lvalue_reference<_From>,
  857.                     is_rvalue_reference<_To>>::value>
  858.     struct __is_lvalue_to_rvalue_ref;
  859.  
  860.   // Detect whether we have an lvalue of non-function type
  861.   // bound to a reference-compatible rvalue-reference.
  862.   template<typename _From, typename _To>
  863.     struct __is_lvalue_to_rvalue_ref<_From, _To, true>
  864.     {
  865.       typedef typename remove_cv<typename remove_reference<
  866.         _From>::type>::type __src_t;
  867.       typedef typename remove_cv<typename remove_reference<
  868.         _To>::type>::type __dst_t;
  869.       typedef __and_<__not_<is_function<__src_t>>,
  870.         __or_<is_same<__src_t, __dst_t>,
  871.                     is_base_of<__dst_t, __src_t>>> type;
  872.       static constexpr bool value = type::value;
  873.     };
  874.  
  875.   template<typename _From, typename _To>
  876.     struct __is_lvalue_to_rvalue_ref<_From, _To, false>
  877.     : public false_type
  878.     { };
  879.  
  880.   // Here we handle direct-initialization to a reference type as
  881.   // equivalent to a static_cast modulo overshooting conversions.
  882.   // These are restricted to the following conversions:
  883.   //    a) A base class value to a derived class reference
  884.   //    b) An lvalue to an rvalue-reference of reference-compatible
  885.   //       types that are not functions
  886.   template<typename _Tp, typename _Arg>
  887.     struct __is_direct_constructible_ref_cast
  888.     : public __and_<__is_static_castable<_Arg, _Tp>,
  889.                     __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
  890.                                  __is_lvalue_to_rvalue_ref<_Arg, _Tp>
  891.                    >>>::type
  892.     { };
  893.  
  894.   template<typename _Tp, typename _Arg>
  895.     struct __is_direct_constructible_new
  896.     : public conditional<is_reference<_Tp>::value,
  897.                          __is_direct_constructible_ref_cast<_Tp, _Arg>,
  898.                          __is_direct_constructible_new_safe<_Tp, _Arg>
  899.                          >::type
  900.     { };
  901.  
  902.   template<typename _Tp, typename _Arg>
  903.     struct __is_direct_constructible
  904.     : public integral_constant<bool, (__is_direct_constructible_new<
  905.                                       _Tp, _Arg>::value)>
  906.     { };
  907.  
  908.   // Since default-construction and binary direct-initialization have
  909.   // been handled separately, the implementation of the remaining
  910.   // n-ary construction cases is rather straightforward. We can use
  911.   // here a functional cast, because array types are excluded anyway
  912.   // and this form is never interpreted as a C cast.
  913.   struct __do_is_nary_constructible_impl
  914.   {
  915.     template<typename _Tp, typename... _Args, typename
  916.              = decltype(_Tp(declval<_Args>()...))>
  917.       static true_type __test(int);
  918.  
  919.     template<typename, typename...>
  920.       static false_type __test(...);
  921.   };
  922.  
  923.   template<typename _Tp, typename... _Args>
  924.     struct __is_nary_constructible_impl
  925.     : public __do_is_nary_constructible_impl
  926.     {
  927.       typedef decltype(__test<_Tp, _Args...>(0)) type;
  928.     };
  929.  
  930.   template<typename _Tp, typename... _Args>
  931.     struct __is_nary_constructible
  932.     : public __is_nary_constructible_impl<_Tp, _Args...>::type
  933.     {
  934.       static_assert(sizeof...(_Args) > 1,
  935.                     "Only useful for > 1 arguments");
  936.     };
  937.  
  938.   template<typename _Tp, typename... _Args>
  939.     struct __is_constructible_impl
  940.     : public __is_nary_constructible<_Tp, _Args...>
  941.     { };
  942.  
  943.   template<typename _Tp, typename _Arg>
  944.     struct __is_constructible_impl<_Tp, _Arg>
  945.     : public __is_direct_constructible<_Tp, _Arg>
  946.     { };
  947.  
  948.   template<typename _Tp>
  949.     struct __is_constructible_impl<_Tp>
  950.     : public is_default_constructible<_Tp>
  951.     { };
  952.  
  953.   /// is_constructible
  954.   template<typename _Tp, typename... _Args>
  955.     struct is_constructible
  956.     : public integral_constant<bool, (__is_constructible_impl<_Tp,
  957.                                       _Args...>::value)>
  958.     { };
  959.  
  960.   template<typename _Tp, bool = is_void<_Tp>::value>
  961.     struct __is_copy_constructible_impl;
  962.  
  963.   template<typename _Tp>
  964.     struct __is_copy_constructible_impl<_Tp, true>
  965.     : public false_type { };
  966.  
  967.   template<typename _Tp>
  968.     struct __is_copy_constructible_impl<_Tp, false>
  969.     : public is_constructible<_Tp, const _Tp&>
  970.     { };
  971.  
  972.   /// is_copy_constructible
  973.   template<typename _Tp>
  974.     struct is_copy_constructible
  975.     : public __is_copy_constructible_impl<_Tp>
  976.     { };
  977.  
  978.   template<typename _Tp, bool = is_void<_Tp>::value>
  979.     struct __is_move_constructible_impl;
  980.  
  981.   template<typename _Tp>
  982.     struct __is_move_constructible_impl<_Tp, true>
  983.     : public false_type { };
  984.  
  985.   template<typename _Tp>
  986.     struct __is_move_constructible_impl<_Tp, false>
  987.     : public is_constructible<_Tp, _Tp&&>
  988.     { };
  989.  
  990.   /// is_move_constructible
  991.   template<typename _Tp>
  992.     struct is_move_constructible
  993.     : public __is_move_constructible_impl<_Tp>
  994.     { };
  995.  
  996.   template<typename _Tp>
  997.     struct __is_nt_default_constructible_atom
  998.     : public integral_constant<bool, noexcept(_Tp())>
  999.     { };
  1000.  
  1001.   template<typename _Tp, bool = is_array<_Tp>::value>
  1002.     struct __is_nt_default_constructible_impl;
  1003.  
  1004.   template<typename _Tp>
  1005.     struct __is_nt_default_constructible_impl<_Tp, true>
  1006.     : public __and_<__is_array_known_bounds<_Tp>,
  1007.                     __is_nt_default_constructible_atom<typename
  1008.                       remove_all_extents<_Tp>::type>>::type
  1009.     { };
  1010.  
  1011.   template<typename _Tp>
  1012.     struct __is_nt_default_constructible_impl<_Tp, false>
  1013.     : public __is_nt_default_constructible_atom<_Tp>
  1014.     { };
  1015.  
  1016.   /// is_nothrow_default_constructible
  1017.   template<typename _Tp>
  1018.     struct is_nothrow_default_constructible
  1019.     : public __and_<is_default_constructible<_Tp>,
  1020.                     __is_nt_default_constructible_impl<_Tp>>::type
  1021.     { };
  1022.  
  1023.   template<typename _Tp, typename... _Args>
  1024.     struct __is_nt_constructible_impl
  1025.     : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
  1026.     { };
  1027.  
  1028.   template<typename _Tp, typename _Arg>
  1029.     struct __is_nt_constructible_impl<_Tp, _Arg>
  1030.     : public integral_constant<bool,
  1031.                                noexcept(static_cast<_Tp>(declval<_Arg>()))>
  1032.     { };
  1033.  
  1034.   template<typename _Tp>
  1035.     struct __is_nt_constructible_impl<_Tp>
  1036.     : public is_nothrow_default_constructible<_Tp>
  1037.     { };
  1038.  
  1039.   /// is_nothrow_constructible
  1040.   template<typename _Tp, typename... _Args>
  1041.     struct is_nothrow_constructible
  1042.     : public __and_<is_constructible<_Tp, _Args...>,
  1043.                     __is_nt_constructible_impl<_Tp, _Args...>>::type
  1044.     { };
  1045.  
  1046.   template<typename _Tp, bool = is_void<_Tp>::value>
  1047.     struct __is_nothrow_copy_constructible_impl;
  1048.  
  1049.   template<typename _Tp>
  1050.     struct __is_nothrow_copy_constructible_impl<_Tp, true>
  1051.     : public false_type { };
  1052.  
  1053.   template<typename _Tp>
  1054.     struct __is_nothrow_copy_constructible_impl<_Tp, false>
  1055.     : public is_nothrow_constructible<_Tp, const _Tp&>
  1056.     { };
  1057.  
  1058.   /// is_nothrow_copy_constructible
  1059.   template<typename _Tp>
  1060.     struct is_nothrow_copy_constructible
  1061.     : public __is_nothrow_copy_constructible_impl<_Tp>
  1062.     { };
  1063.  
  1064.   template<typename _Tp, bool = is_void<_Tp>::value>
  1065.     struct __is_nothrow_move_constructible_impl;
  1066.  
  1067.   template<typename _Tp>
  1068.     struct __is_nothrow_move_constructible_impl<_Tp, true>
  1069.     : public false_type { };
  1070.  
  1071.   template<typename _Tp>
  1072.     struct __is_nothrow_move_constructible_impl<_Tp, false>
  1073.     : public is_nothrow_constructible<_Tp, _Tp&&>
  1074.     { };
  1075.  
  1076.   /// is_nothrow_move_constructible
  1077.   template<typename _Tp>
  1078.     struct is_nothrow_move_constructible
  1079.     : public __is_nothrow_move_constructible_impl<_Tp>
  1080.     { };
  1081.  
  1082.   template<typename _Tp, typename _Up>
  1083.     class __is_assignable_helper
  1084.     : public __sfinae_types
  1085.     {
  1086.       template<typename _Tp1, typename _Up1>
  1087.         static decltype(declval<_Tp1>() = declval<_Up1>(), __one())
  1088.         __test(int);
  1089.  
  1090.       template<typename, typename>
  1091.         static __two __test(...);
  1092.  
  1093.     public:
  1094.       static constexpr bool value = sizeof(__test<_Tp, _Up>(0)) == 1;
  1095.     };
  1096.  
  1097.   /// is_assignable
  1098.   template<typename _Tp, typename _Up>
  1099.     struct is_assignable
  1100.     : public integral_constant<bool,
  1101.                                __is_assignable_helper<_Tp, _Up>::value>
  1102.     { };
  1103.  
  1104.   template<typename _Tp, bool = is_void<_Tp>::value>
  1105.     struct __is_copy_assignable_impl;
  1106.  
  1107.   template<typename _Tp>
  1108.     struct __is_copy_assignable_impl<_Tp, true>
  1109.     : public false_type { };
  1110.  
  1111.   template<typename _Tp>
  1112.     struct __is_copy_assignable_impl<_Tp, false>
  1113.     : public is_assignable<_Tp&, const _Tp&>
  1114.     { };
  1115.  
  1116.   /// is_copy_assignable
  1117.   template<typename _Tp>
  1118.     struct is_copy_assignable
  1119.     : public __is_copy_assignable_impl<_Tp>
  1120.     { };
  1121.  
  1122.   template<typename _Tp, bool = is_void<_Tp>::value>
  1123.     struct __is_move_assignable_impl;
  1124.  
  1125.   template<typename _Tp>
  1126.     struct __is_move_assignable_impl<_Tp, true>
  1127.     : public false_type { };
  1128.  
  1129.   template<typename _Tp>
  1130.     struct __is_move_assignable_impl<_Tp, false>
  1131.     : public is_assignable<_Tp&, _Tp&&>
  1132.     { };
  1133.  
  1134.   /// is_move_assignable
  1135.   template<typename _Tp>
  1136.     struct is_move_assignable
  1137.     : public __is_move_assignable_impl<_Tp>
  1138.     { };
  1139.  
  1140.   template<typename _Tp, typename _Up>
  1141.     struct __is_nt_assignable_impl
  1142.     : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
  1143.     { };
  1144.  
  1145.   /// is_nothrow_assignable
  1146.   template<typename _Tp, typename _Up>
  1147.     struct is_nothrow_assignable
  1148.     : public __and_<is_assignable<_Tp, _Up>,
  1149.                     __is_nt_assignable_impl<_Tp, _Up>>::type
  1150.     { };
  1151.  
  1152.   template<typename _Tp, bool = is_void<_Tp>::value>
  1153.     struct __is_nt_copy_assignable_impl;
  1154.  
  1155.   template<typename _Tp>
  1156.     struct __is_nt_copy_assignable_impl<_Tp, true>
  1157.     : public false_type { };
  1158.  
  1159.   template<typename _Tp>
  1160.     struct __is_nt_copy_assignable_impl<_Tp, false>
  1161.     : public is_nothrow_assignable<_Tp&, const _Tp&>
  1162.     { };
  1163.  
  1164.   /// is_nothrow_copy_assignable
  1165.   template<typename _Tp>
  1166.     struct is_nothrow_copy_assignable
  1167.     : public __is_nt_copy_assignable_impl<_Tp>
  1168.     { };
  1169.  
  1170.   template<typename _Tp, bool = is_void<_Tp>::value>
  1171.     struct __is_nt_move_assignable_impl;
  1172.  
  1173.   template<typename _Tp>
  1174.     struct __is_nt_move_assignable_impl<_Tp, true>
  1175.     : public false_type { };
  1176.  
  1177.   template<typename _Tp>
  1178.     struct __is_nt_move_assignable_impl<_Tp, false>
  1179.     : public is_nothrow_assignable<_Tp&, _Tp&&>
  1180.     { };
  1181.  
  1182.   /// is_nothrow_move_assignable
  1183.   template<typename _Tp>
  1184.     struct is_nothrow_move_assignable
  1185.     : public __is_nt_move_assignable_impl<_Tp>
  1186.     { };
  1187.  
  1188.   /// is_trivially_constructible (still unimplemented)
  1189.  
  1190.   /// is_trivially_default_constructible (still unimplemented)
  1191.  
  1192.   /// is_trivially_copy_constructible (still unimplemented)
  1193.  
  1194.   /// is_trivially_move_constructible (still unimplemented)
  1195.  
  1196.   /// is_trivially_assignable (still unimplemented)
  1197.  
  1198.   /// is_trivially_copy_assignable (still unimplemented)
  1199.  
  1200.   /// is_trivially_move_assignable (still unimplemented)
  1201.  
  1202.   /// is_trivially_destructible
  1203.   template<typename _Tp>
  1204.     struct is_trivially_destructible
  1205.     : public __and_<is_destructible<_Tp>, integral_constant<bool,
  1206.                               __has_trivial_destructor(_Tp)>>::type
  1207.     { };
  1208.  
  1209.   /// has_trivial_default_constructor (temporary legacy)
  1210.   template<typename _Tp>
  1211.     struct has_trivial_default_constructor
  1212.     : public integral_constant<bool, __has_trivial_constructor(_Tp)>
  1213.     { };
  1214.  
  1215.   /// has_trivial_copy_constructor (temporary legacy)
  1216.   template<typename _Tp>
  1217.     struct has_trivial_copy_constructor
  1218.     : public integral_constant<bool, __has_trivial_copy(_Tp)>
  1219.     { };
  1220.  
  1221.   /// has_trivial_copy_assign (temporary legacy)
  1222.   template<typename _Tp>
  1223.     struct has_trivial_copy_assign
  1224.     : public integral_constant<bool, __has_trivial_assign(_Tp)>
  1225.     { };
  1226.  
  1227.   /// has_virtual_destructor
  1228.   template<typename _Tp>
  1229.     struct has_virtual_destructor
  1230.     : public integral_constant<bool, __has_virtual_destructor(_Tp)>
  1231.     { };
  1232.  
  1233.  
  1234.   // type property queries.
  1235.  
  1236.   /// alignment_of
  1237.   template<typename _Tp>
  1238.     struct alignment_of
  1239.     : public integral_constant<std::size_t, __alignof__(_Tp)> { };
  1240.  
  1241.   /// rank
  1242.   template<typename>
  1243.     struct rank
  1244.     : public integral_constant<std::size_t, 0> { };
  1245.    
  1246.   template<typename _Tp, std::size_t _Size>
  1247.     struct rank<_Tp[_Size]>
  1248.     : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
  1249.  
  1250.   template<typename _Tp>
  1251.     struct rank<_Tp[]>
  1252.     : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
  1253.  
  1254.   /// extent
  1255.   template<typename, unsigned _Uint>
  1256.     struct extent
  1257.     : public integral_constant<std::size_t, 0> { };
  1258.  
  1259.   template<typename _Tp, unsigned _Uint, std::size_t _Size>
  1260.     struct extent<_Tp[_Size], _Uint>
  1261.     : public integral_constant<std::size_t,
  1262.                                _Uint == 0 ? _Size : extent<_Tp,
  1263.                                                            _Uint - 1>::value>
  1264.     { };
  1265.  
  1266.   template<typename _Tp, unsigned _Uint>
  1267.     struct extent<_Tp[], _Uint>
  1268.     : public integral_constant<std::size_t,
  1269.                                _Uint == 0 ? 0 : extent<_Tp,
  1270.                                                        _Uint - 1>::value>
  1271.     { };
  1272.  
  1273.  
  1274.   // Type relations.
  1275.  
  1276.   /// is_same
  1277.   template<typename, typename>
  1278.     struct is_same
  1279.     : public false_type { };
  1280.  
  1281.   template<typename _Tp>
  1282.     struct is_same<_Tp, _Tp>
  1283.     : public true_type { };
  1284.  
  1285.   /// is_base_of
  1286.   template<typename _Base, typename _Derived>
  1287.     struct is_base_of
  1288.     : public integral_constant<bool, __is_base_of(_Base, _Derived)>
  1289.     { };
  1290.  
  1291.   template<typename _From, typename _To,
  1292.            bool = __or_<is_void<_From>, is_function<_To>,
  1293.                         is_array<_To>>::value>
  1294.     struct __is_convertible_helper
  1295.     { static constexpr bool value = is_void<_To>::value; };
  1296.  
  1297.   template<typename _From, typename _To>
  1298.     class __is_convertible_helper<_From, _To, false>
  1299.     : public __sfinae_types
  1300.     {
  1301.       template<typename _To1>
  1302.         static void __test_aux(_To1);
  1303.  
  1304.       template<typename _From1, typename _To1>
  1305.         static decltype(__test_aux<_To1>(std::declval<_From1>()), __one())
  1306.         __test(int);
  1307.  
  1308.       template<typename, typename>
  1309.         static __two __test(...);
  1310.  
  1311.     public:
  1312.       static constexpr bool value = sizeof(__test<_From, _To>(0)) == 1;
  1313.     };
  1314.  
  1315.   /// is_convertible
  1316.   template<typename _From, typename _To>
  1317.     struct is_convertible
  1318.     : public integral_constant<bool,
  1319.                                __is_convertible_helper<_From, _To>::value>
  1320.     { };
  1321.  
  1322.  
  1323.   // Const-volatile modifications.
  1324.  
  1325.   /// remove_const
  1326.   template<typename _Tp>
  1327.     struct remove_const
  1328.     { typedef _Tp     type; };
  1329.  
  1330.   template<typename _Tp>
  1331.     struct remove_const<_Tp const>
  1332.     { typedef _Tp     type; };
  1333.  
  1334.   /// remove_volatile
  1335.   template<typename _Tp>
  1336.     struct remove_volatile
  1337.     { typedef _Tp     type; };
  1338.  
  1339.   template<typename _Tp>
  1340.     struct remove_volatile<_Tp volatile>
  1341.     { typedef _Tp     type; };
  1342.  
  1343.   /// remove_cv
  1344.   template<typename _Tp>
  1345.     struct remove_cv
  1346.     {
  1347.       typedef typename
  1348.       remove_const<typename remove_volatile<_Tp>::type>::type     type;
  1349.     };
  1350.  
  1351.   /// add_const
  1352.   template<typename _Tp>
  1353.     struct add_const
  1354.     { typedef _Tp const     type; };
  1355.    
  1356.   /// add_volatile
  1357.   template<typename _Tp>
  1358.     struct add_volatile
  1359.     { typedef _Tp volatile     type; };
  1360.  
  1361.   /// add_cv
  1362.   template<typename _Tp>
  1363.     struct add_cv
  1364.     {
  1365.       typedef typename
  1366.       add_const<typename add_volatile<_Tp>::type>::type     type;
  1367.     };
  1368.  
  1369.  
  1370.   // Reference transformations.
  1371.  
  1372.   /// remove_reference
  1373.   template<typename _Tp>
  1374.     struct remove_reference
  1375.     { typedef _Tp   type; };
  1376.  
  1377.   template<typename _Tp>
  1378.     struct remove_reference<_Tp&>
  1379.     { typedef _Tp   type; };
  1380.  
  1381.   template<typename _Tp>
  1382.     struct remove_reference<_Tp&&>
  1383.     { typedef _Tp   type; };
  1384.  
  1385.   template<typename _Tp,
  1386.            bool = __and_<__not_<is_reference<_Tp>>,
  1387.                          __not_<is_void<_Tp>>>::value,
  1388.            bool = is_rvalue_reference<_Tp>::value>
  1389.     struct __add_lvalue_reference_helper
  1390.     { typedef _Tp   type; };
  1391.  
  1392.   template<typename _Tp>
  1393.     struct __add_lvalue_reference_helper<_Tp, true, false>
  1394.     { typedef _Tp&   type; };
  1395.  
  1396.   template<typename _Tp>
  1397.     struct __add_lvalue_reference_helper<_Tp, false, true>
  1398.     { typedef typename remove_reference<_Tp>::type&   type; };
  1399.  
  1400.   /// add_lvalue_reference
  1401.   template<typename _Tp>
  1402.     struct add_lvalue_reference
  1403.     : public __add_lvalue_reference_helper<_Tp>
  1404.     { };
  1405.  
  1406.   template<typename _Tp,
  1407.            bool = __and_<__not_<is_reference<_Tp>>,
  1408.                          __not_<is_void<_Tp>>>::value>
  1409.     struct __add_rvalue_reference_helper
  1410.     { typedef _Tp   type; };
  1411.  
  1412.   template<typename _Tp>
  1413.     struct __add_rvalue_reference_helper<_Tp, true>
  1414.     { typedef _Tp&&   type; };
  1415.  
  1416.   /// add_rvalue_reference
  1417.   template<typename _Tp>
  1418.     struct add_rvalue_reference
  1419.     : public __add_rvalue_reference_helper<_Tp>
  1420.     { };
  1421.  
  1422.  
  1423.   // Sign modifications.
  1424.  
  1425.   // Utility for constructing identically cv-qualified types.
  1426.   template<typename _Unqualified, bool _IsConst, bool _IsVol>
  1427.     struct __cv_selector;
  1428.  
  1429.   template<typename _Unqualified>
  1430.     struct __cv_selector<_Unqualified, false, false>
  1431.     { typedef _Unqualified __type; };
  1432.  
  1433.   template<typename _Unqualified>
  1434.     struct __cv_selector<_Unqualified, false, true>
  1435.     { typedef volatile _Unqualified __type; };
  1436.  
  1437.   template<typename _Unqualified>
  1438.     struct __cv_selector<_Unqualified, true, false>
  1439.     { typedef const _Unqualified __type; };
  1440.  
  1441.   template<typename _Unqualified>
  1442.     struct __cv_selector<_Unqualified, true, true>
  1443.     { typedef const volatile _Unqualified __type; };
  1444.  
  1445.   template<typename _Qualified, typename _Unqualified,
  1446.            bool _IsConst = is_const<_Qualified>::value,
  1447.            bool _IsVol = is_volatile<_Qualified>::value>
  1448.     class __match_cv_qualifiers
  1449.     {
  1450.       typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
  1451.  
  1452.     public:
  1453.       typedef typename __match::__type __type;
  1454.     };
  1455.  
  1456.   // Utility for finding the unsigned versions of signed integral types.
  1457.   template<typename _Tp>
  1458.     struct __make_unsigned
  1459.     { typedef _Tp __type; };
  1460.  
  1461.   template<>
  1462.     struct __make_unsigned<char>
  1463.     { typedef unsigned char __type; };
  1464.  
  1465.   template<>
  1466.     struct __make_unsigned<signed char>
  1467.     { typedef unsigned char __type; };
  1468.  
  1469.   template<>
  1470.     struct __make_unsigned<short>
  1471.     { typedef unsigned short __type; };
  1472.  
  1473.   template<>
  1474.     struct __make_unsigned<int>
  1475.     { typedef unsigned int __type; };
  1476.  
  1477.   template<>
  1478.     struct __make_unsigned<long>
  1479.     { typedef unsigned long __type; };
  1480.  
  1481.   template<>
  1482.     struct __make_unsigned<long long>
  1483.     { typedef unsigned long long __type; };
  1484.  
  1485. #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
  1486.   template<>
  1487.     struct __make_unsigned<__int128>
  1488.     { typedef unsigned __int128 __type; };
  1489. #endif
  1490.  
  1491.   // Select between integral and enum: not possible to be both.
  1492.   template<typename _Tp,
  1493.            bool _IsInt = is_integral<_Tp>::value,
  1494.            bool _IsEnum = is_enum<_Tp>::value>
  1495.     class __make_unsigned_selector;
  1496.  
  1497.   template<typename _Tp>
  1498.     class __make_unsigned_selector<_Tp, true, false>
  1499.     {
  1500.       typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
  1501.       typedef typename __unsignedt::__type __unsigned_type;
  1502.       typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
  1503.  
  1504.     public:
  1505.       typedef typename __cv_unsigned::__type __type;
  1506.     };
  1507.  
  1508.   template<typename _Tp>
  1509.     class __make_unsigned_selector<_Tp, false, true>
  1510.     {
  1511.       // With -fshort-enums, an enum may be as small as a char.
  1512.       typedef unsigned char __smallest;
  1513.       static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
  1514.       static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
  1515.       static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
  1516.       typedef conditional<__b2, unsigned int, unsigned long> __cond2;
  1517.       typedef typename __cond2::type __cond2_type;
  1518.       typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
  1519.       typedef typename __cond1::type __cond1_type;
  1520.  
  1521.     public:
  1522.       typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
  1523.     };
  1524.  
  1525.   // Given an integral/enum type, return the corresponding unsigned
  1526.   // integer type.
  1527.   // Primary template.
  1528.   /// make_unsigned
  1529.   template<typename _Tp>
  1530.     struct make_unsigned
  1531.     { typedef typename __make_unsigned_selector<_Tp>::__type type; };
  1532.  
  1533.   // Integral, but don't define.
  1534.   template<>
  1535.     struct make_unsigned<bool>;
  1536.  
  1537.  
  1538.   // Utility for finding the signed versions of unsigned integral types.
  1539.   template<typename _Tp>
  1540.     struct __make_signed
  1541.     { typedef _Tp __type; };
  1542.  
  1543.   template<>
  1544.     struct __make_signed<char>
  1545.     { typedef signed char __type; };
  1546.  
  1547.   template<>
  1548.     struct __make_signed<unsigned char>
  1549.     { typedef signed char __type; };
  1550.  
  1551.   template<>
  1552.     struct __make_signed<unsigned short>
  1553.     { typedef signed short __type; };
  1554.  
  1555.   template<>
  1556.     struct __make_signed<unsigned int>
  1557.     { typedef signed int __type; };
  1558.  
  1559.   template<>
  1560.     struct __make_signed<unsigned long>
  1561.     { typedef signed long __type; };
  1562.  
  1563.   template<>
  1564.     struct __make_signed<unsigned long long>
  1565.     { typedef signed long long __type; };
  1566.  
  1567. #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
  1568.   template<>
  1569.     struct __make_signed<unsigned __int128>
  1570.     { typedef __int128 __type; };
  1571. #endif
  1572.  
  1573.   // Select between integral and enum: not possible to be both.
  1574.   template<typename _Tp,
  1575.            bool _IsInt = is_integral<_Tp>::value,
  1576.            bool _IsEnum = is_enum<_Tp>::value>
  1577.     class __make_signed_selector;
  1578.  
  1579.   template<typename _Tp>
  1580.     class __make_signed_selector<_Tp, true, false>
  1581.     {
  1582.       typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
  1583.       typedef typename __signedt::__type __signed_type;
  1584.       typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
  1585.  
  1586.     public:
  1587.       typedef typename __cv_signed::__type __type;
  1588.     };
  1589.  
  1590.   template<typename _Tp>
  1591.     class __make_signed_selector<_Tp, false, true>
  1592.     {
  1593.       // With -fshort-enums, an enum may be as small as a char.
  1594.       typedef signed char __smallest;
  1595.       static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
  1596.       static const bool __b1 = sizeof(_Tp) <= sizeof(signed short);
  1597.       static const bool __b2 = sizeof(_Tp) <= sizeof(signed int);
  1598.       typedef conditional<__b2, signed int, signed long> __cond2;
  1599.       typedef typename __cond2::type __cond2_type;
  1600.       typedef conditional<__b1, signed short, __cond2_type> __cond1;
  1601.       typedef typename __cond1::type __cond1_type;
  1602.  
  1603.     public:
  1604.       typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
  1605.     };
  1606.  
  1607.   // Given an integral/enum type, return the corresponding signed
  1608.   // integer type.
  1609.   // Primary template.
  1610.   /// make_signed
  1611.   template<typename _Tp>
  1612.     struct make_signed
  1613.     { typedef typename __make_signed_selector<_Tp>::__type type; };
  1614.  
  1615.   // Integral, but don't define.
  1616.   template<>
  1617.     struct make_signed<bool>;
  1618.  
  1619.  
  1620.   // Array modifications.
  1621.  
  1622.   /// remove_extent
  1623.   template<typename _Tp>
  1624.     struct remove_extent
  1625.     { typedef _Tp     type; };
  1626.  
  1627.   template<typename _Tp, std::size_t _Size>
  1628.     struct remove_extent<_Tp[_Size]>
  1629.     { typedef _Tp     type; };
  1630.  
  1631.   template<typename _Tp>
  1632.     struct remove_extent<_Tp[]>
  1633.     { typedef _Tp     type; };
  1634.  
  1635.   /// remove_all_extents
  1636.   template<typename _Tp>
  1637.     struct remove_all_extents
  1638.     { typedef _Tp     type; };
  1639.  
  1640.   template<typename _Tp, std::size_t _Size>
  1641.     struct remove_all_extents<_Tp[_Size]>
  1642.     { typedef typename remove_all_extents<_Tp>::type     type; };
  1643.  
  1644.   template<typename _Tp>
  1645.     struct remove_all_extents<_Tp[]>
  1646.     { typedef typename remove_all_extents<_Tp>::type     type; };
  1647.  
  1648.  
  1649.   // Pointer modifications.
  1650.  
  1651.   template<typename _Tp, typename>
  1652.     struct __remove_pointer_helper
  1653.     { typedef _Tp     type; };
  1654.  
  1655.   template<typename _Tp, typename _Up>
  1656.     struct __remove_pointer_helper<_Tp, _Up*>
  1657.     { typedef _Up     type; };
  1658.  
  1659.   /// remove_pointer
  1660.   template<typename _Tp>
  1661.     struct remove_pointer
  1662.     : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
  1663.     { };
  1664.  
  1665.   /// add_pointer
  1666.   template<typename _Tp>
  1667.     struct add_pointer
  1668.     { typedef typename remove_reference<_Tp>::type*     type; };
  1669.  
  1670.  
  1671.   template<std::size_t _Len>
  1672.     struct __aligned_storage_msa
  1673.     {
  1674.       union __type
  1675.       {
  1676.         unsigned char __data[_Len];
  1677.         struct __attribute__((__aligned__)) { } __align;
  1678.       };
  1679.     };
  1680.  
  1681.   /**
  1682.    *  @brief Alignment type.
  1683.    *
  1684.    *  The value of _Align is a default-alignment which shall be the
  1685.    *  most stringent alignment requirement for any C++ object type
  1686.    *  whose size is no greater than _Len (3.9). The member typedef
  1687.    *  type shall be a POD type suitable for use as uninitialized
  1688.    *  storage for any object whose size is at most _Len and whose
  1689.    *  alignment is a divisor of _Align.
  1690.   */
  1691.   template<std::size_t _Len, std::size_t _Align =
  1692.            __alignof__(typename __aligned_storage_msa<_Len>::__type)>
  1693.     struct aligned_storage
  1694.     {
  1695.       union type
  1696.       {
  1697.         unsigned char __data[_Len];
  1698.         struct __attribute__((__aligned__((_Align)))) { } __align;
  1699.       };
  1700.     };
  1701.  
  1702.  
  1703.   // Decay trait for arrays and functions, used for perfect forwarding
  1704.   // in make_pair, make_tuple, etc.
  1705.   template<typename _Up,
  1706.            bool _IsArray = is_array<_Up>::value,
  1707.            bool _IsFunction = is_function<_Up>::value>
  1708.     struct __decay_selector;
  1709.  
  1710.   // NB: DR 705.
  1711.   template<typename _Up>
  1712.     struct __decay_selector<_Up, false, false>
  1713.     { typedef typename remove_cv<_Up>::type __type; };
  1714.  
  1715.   template<typename _Up>
  1716.     struct __decay_selector<_Up, true, false>
  1717.     { typedef typename remove_extent<_Up>::type* __type; };
  1718.  
  1719.   template<typename _Up>
  1720.     struct __decay_selector<_Up, false, true>
  1721.     { typedef typename add_pointer<_Up>::type __type; };
  1722.  
  1723.   /// decay
  1724.   template<typename _Tp>
  1725.     class decay
  1726.     {
  1727.       typedef typename remove_reference<_Tp>::type __remove_type;
  1728.  
  1729.     public:
  1730.       typedef typename __decay_selector<__remove_type>::__type type;
  1731.     };
  1732.  
  1733.   template<typename _Tp>
  1734.     class reference_wrapper;
  1735.  
  1736.   // Helper which adds a reference to a type when given a reference_wrapper
  1737.   template<typename _Tp>
  1738.     struct __strip_reference_wrapper
  1739.     {
  1740.       typedef _Tp __type;
  1741.     };
  1742.  
  1743.   template<typename _Tp>
  1744.     struct __strip_reference_wrapper<reference_wrapper<_Tp> >
  1745.     {
  1746.       typedef _Tp& __type;
  1747.     };
  1748.  
  1749.   template<typename _Tp>
  1750.     struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
  1751.     {
  1752.       typedef _Tp& __type;
  1753.     };
  1754.  
  1755.   template<typename _Tp>
  1756.     struct __decay_and_strip
  1757.     {
  1758.       typedef typename __strip_reference_wrapper<
  1759.         typename decay<_Tp>::type>::__type __type;
  1760.     };
  1761.  
  1762.  
  1763.   // Primary template.
  1764.   /// Define a member typedef @c type only if a boolean constant is true.
  1765.   template<bool, typename _Tp = void>
  1766.     struct enable_if
  1767.     { };
  1768.  
  1769.   // Partial specialization for true.
  1770.   template<typename _Tp>
  1771.     struct enable_if<true, _Tp>
  1772.     { typedef _Tp type; };
  1773.  
  1774.   template<typename... _Cond>
  1775.     using _Require = typename enable_if<__and_<_Cond...>::value>::type;
  1776.  
  1777.   // Primary template.
  1778.   /// Define a member typedef @c type to one of two argument types.
  1779.   template<bool _Cond, typename _Iftrue, typename _Iffalse>
  1780.     struct conditional
  1781.     { typedef _Iftrue type; };
  1782.  
  1783.   // Partial specialization for false.
  1784.   template<typename _Iftrue, typename _Iffalse>
  1785.     struct conditional<false, _Iftrue, _Iffalse>
  1786.     { typedef _Iffalse type; };
  1787.  
  1788.   /// common_type
  1789.   template<typename... _Tp>
  1790.     struct common_type;
  1791.  
  1792.   // Sfinae-friendly common_type implementation:
  1793.  
  1794.   struct __do_common_type_impl
  1795.   {
  1796.     template<typename _Tp, typename _Up>
  1797.       static __success_type<typename decay<decltype
  1798.                             (true ? std::declval<_Tp>()
  1799.                              : std::declval<_Up>())>::type> _S_test(int);
  1800.  
  1801.     template<typename, typename>
  1802.       static __failure_type _S_test(...);
  1803.   };
  1804.  
  1805.   template<typename _Tp, typename _Up>
  1806.     struct __common_type_impl
  1807.     : private __do_common_type_impl
  1808.     {
  1809.       typedef decltype(_S_test<_Tp, _Up>(0)) type;
  1810.     };
  1811.  
  1812.   struct __do_member_type_wrapper
  1813.   {
  1814.     template<typename _Tp>
  1815.       static __success_type<typename _Tp::type> _S_test(int);
  1816.  
  1817.     template<typename>
  1818.       static __failure_type _S_test(...);
  1819.   };
  1820.  
  1821.   template<typename _Tp>
  1822.     struct __member_type_wrapper
  1823.     : private __do_member_type_wrapper
  1824.     {
  1825.       typedef decltype(_S_test<_Tp>(0)) type;
  1826.     };
  1827.  
  1828.   template<typename _CTp, typename... _Args>
  1829.     struct __expanded_common_type_wrapper
  1830.     {
  1831.       typedef common_type<typename _CTp::type, _Args...> type;
  1832.     };
  1833.  
  1834.   template<typename... _Args>
  1835.     struct __expanded_common_type_wrapper<__failure_type, _Args...>
  1836.     { typedef __failure_type type; };
  1837.  
  1838.   template<typename _Tp>
  1839.     struct common_type<_Tp>
  1840.     { typedef typename decay<_Tp>::type type; };
  1841.  
  1842.   template<typename _Tp, typename _Up>
  1843.     struct common_type<_Tp, _Up>
  1844.     : public __common_type_impl<_Tp, _Up>::type
  1845.     { };
  1846.  
  1847.   template<typename _Tp, typename _Up, typename... _Vp>
  1848.     struct common_type<_Tp, _Up, _Vp...>
  1849.     : public __expanded_common_type_wrapper<typename __member_type_wrapper<
  1850.                common_type<_Tp, _Up>>::type, _Vp...>::type
  1851.     { };
  1852.  
  1853.   /// The underlying type of an enum.
  1854.   template<typename _Tp>
  1855.     struct underlying_type
  1856.     {
  1857.       typedef __underlying_type(_Tp) type;
  1858.     };
  1859.  
  1860.   template<typename _Tp>
  1861.     struct __declval_protector
  1862.     {
  1863.       static const bool __stop = false;
  1864.       static typename add_rvalue_reference<_Tp>::type __delegate();
  1865.     };
  1866.  
  1867.   template<typename _Tp>
  1868.     inline typename add_rvalue_reference<_Tp>::type
  1869.     declval() noexcept
  1870.     {
  1871.       static_assert(__declval_protector<_Tp>::__stop,
  1872.                     "declval() must not be used!");
  1873.       return __declval_protector<_Tp>::__delegate();
  1874.     }
  1875.  
  1876.   /// result_of
  1877.   template<typename _Signature>
  1878.     class result_of;
  1879.  
  1880.   // Sfinae-friendly result_of implementation:
  1881.  
  1882.   // [func.require] paragraph 1 bullet 1:
  1883.   struct __result_of_memfun_ref_impl
  1884.   {
  1885.     template<typename _Fp, typename _Tp1, typename... _Args>
  1886.       static __success_type<decltype(
  1887.       (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
  1888.       )> _S_test(int);
  1889.  
  1890.     template<typename...>
  1891.       static __failure_type _S_test(...);
  1892.   };
  1893.  
  1894.   template<typename _MemPtr, typename _Arg, typename... _Args>
  1895.     struct __result_of_memfun_ref
  1896.     : private __result_of_memfun_ref_impl
  1897.     {
  1898.       typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
  1899.     };
  1900.  
  1901.   // [func.require] paragraph 1 bullet 2:
  1902.   struct __result_of_memfun_deref_impl
  1903.   {
  1904.     template<typename _Fp, typename _Tp1, typename... _Args>
  1905.       static __success_type<decltype(
  1906.       ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
  1907.       )> _S_test(int);
  1908.  
  1909.     template<typename...>
  1910.       static __failure_type _S_test(...);
  1911.   };
  1912.  
  1913.   template<typename _MemPtr, typename _Arg, typename... _Args>
  1914.     struct __result_of_memfun_deref
  1915.     : private __result_of_memfun_deref_impl
  1916.     {
  1917.       typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
  1918.     };
  1919.  
  1920.   // [func.require] paragraph 1 bullet 3:
  1921.   struct __result_of_memobj_ref_impl
  1922.   {
  1923.     template<typename _Fp, typename _Tp1>
  1924.       static __success_type<decltype(
  1925.       std::declval<_Tp1>().*std::declval<_Fp>()
  1926.       )> _S_test(int);
  1927.  
  1928.     template<typename, typename>
  1929.       static __failure_type _S_test(...);
  1930.   };
  1931.  
  1932.   template<typename _MemPtr, typename _Arg>
  1933.     struct __result_of_memobj_ref
  1934.     : private __result_of_memobj_ref_impl
  1935.     {
  1936.       typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
  1937.     };
  1938.  
  1939.   // [func.require] paragraph 1 bullet 4:
  1940.   struct __result_of_memobj_deref_impl
  1941.   {
  1942.     template<typename _Fp, typename _Tp1>
  1943.       static __success_type<decltype(
  1944.       (*std::declval<_Tp1>()).*std::declval<_Fp>()
  1945.       )> _S_test(int);
  1946.  
  1947.     template<typename, typename>
  1948.       static __failure_type _S_test(...);
  1949.   };
  1950.  
  1951.   template<typename _MemPtr, typename _Arg>
  1952.     struct __result_of_memobj_deref
  1953.     : private __result_of_memobj_deref_impl
  1954.     {
  1955.       typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
  1956.     };
  1957.  
  1958.   template<typename _MemPtr, typename _Arg>
  1959.     struct __result_of_memobj;
  1960.  
  1961.   template<typename _Res, typename _Class, typename _Arg>
  1962.     struct __result_of_memobj<_Res _Class::*, _Arg>
  1963.     {
  1964.       typedef typename remove_cv<typename remove_reference<
  1965.         _Arg>::type>::type _Argval;
  1966.       typedef _Res _Class::* _MemPtr;
  1967.       typedef typename conditional<__or_<is_same<_Argval, _Class>,
  1968.         is_base_of<_Class, _Argval>>::value,
  1969.         __result_of_memobj_ref<_MemPtr, _Arg>,
  1970.         __result_of_memobj_deref<_MemPtr, _Arg>
  1971.       >::type::type type;
  1972.     };
  1973.  
  1974.   template<typename _MemPtr, typename _Arg, typename... _Args>
  1975.     struct __result_of_memfun;
  1976.  
  1977.   template<typename _Res, typename _Class, typename _Arg, typename... _Args>
  1978.     struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
  1979.     {
  1980.       typedef typename remove_cv<typename remove_reference<
  1981.         _Arg>::type>::type _Argval;
  1982.       typedef _Res _Class::* _MemPtr;
  1983.       typedef typename conditional<__or_<is_same<_Argval, _Class>,
  1984.         is_base_of<_Class, _Argval>>::value,
  1985.         __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
  1986.         __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
  1987.       >::type::type type;
  1988.     };
  1989.  
  1990.   template<bool, bool, typename _Functor, typename... _ArgTypes>
  1991.     struct __result_of_impl
  1992.     {
  1993.       typedef __failure_type type;
  1994.     };
  1995.  
  1996.   template<typename _MemPtr, typename _Arg>
  1997.     struct __result_of_impl<true, false, _MemPtr, _Arg>
  1998.     : public __result_of_memobj<typename decay<_MemPtr>::type, _Arg>
  1999.     { };
  2000.  
  2001.   template<typename _MemPtr, typename _Arg, typename... _Args>
  2002.     struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
  2003.     : public __result_of_memfun<typename decay<_MemPtr>::type, _Arg, _Args...>
  2004.     { };
  2005.  
  2006.   // [func.require] paragraph 1 bullet 5:
  2007.   struct __result_of_other_impl
  2008.   {
  2009.     template<typename _Fn, typename... _Args>
  2010.       static __success_type<decltype(
  2011.       std::declval<_Fn>()(std::declval<_Args>()...)
  2012.       )> _S_test(int);
  2013.  
  2014.     template<typename...>
  2015.       static __failure_type _S_test(...);
  2016.   };
  2017.  
  2018.   template<typename _Functor, typename... _ArgTypes>
  2019.     struct __result_of_impl<false, false, _Functor, _ArgTypes...>
  2020.     : private __result_of_other_impl
  2021.     {
  2022.       typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
  2023.     };
  2024.  
  2025.   template<typename _Functor, typename... _ArgTypes>
  2026.     struct result_of<_Functor(_ArgTypes...)>
  2027.     : public __result_of_impl<
  2028.         is_member_object_pointer<
  2029.           typename remove_reference<_Functor>::type
  2030.         >::value,
  2031.         is_member_function_pointer<
  2032.           typename remove_reference<_Functor>::type
  2033.         >::value,
  2034.             _Functor, _ArgTypes...
  2035.       >::type
  2036.     { };
  2037.  
  2038.   /// @} group metaprogramming
  2039.        
  2040.   /**
  2041.    *  Use SFINAE to determine if the type _Tp has a publicly-accessible
  2042.    *  member type _NTYPE.
  2043.    */
  2044. #define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE)                         \
  2045.   template<typename _Tp>                                         \
  2046.     class __has_##_NTYPE##_helper                                \
  2047.     : __sfinae_types                                             \
  2048.     {                                                            \
  2049.       template<typename _Up>                                     \
  2050.         struct _Wrap_type                                        \
  2051.         { };                                                     \
  2052.                                                                  \
  2053.       template<typename _Up>                                     \
  2054.         static __one __test(_Wrap_type<typename _Up::_NTYPE>*);  \
  2055.                                                                  \
  2056.       template<typename _Up>                                     \
  2057.         static __two __test(...);                                \
  2058.                                                                  \
  2059.     public:                                                      \
  2060.       static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; \
  2061.     };                                                           \
  2062.                                                                  \
  2063.   template<typename _Tp>                                         \
  2064.     struct __has_##_NTYPE                                        \
  2065.     : integral_constant<bool, __has_##_NTYPE##_helper            \
  2066.                         <typename remove_cv<_Tp>::type>::value>  \
  2067.     { };
  2068.  
  2069. _GLIBCXX_END_NAMESPACE_VERSION
  2070. } // namespace std
  2071.  
  2072. #endif  // C++11
  2073.  
  2074. #endif  // _GLIBCXX_TYPE_TRAITS
  2075.